'use strict';

var obsidian = require('obsidian');
var view = require('@codemirror/view');
var state = require('@codemirror/state');
var language = require('@codemirror/language');

/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function recalculateNumericBullets(root) {
    function visit(parent) {
        let index = 1;
        for (const child of parent.getChildren()) {
            if (/\d+\./.test(child.getBullet())) {
                child.replateBullet(`${index++}.`);
            }
            visit(child);
        }
    }
    visit(root);
}

class DeleteAndMergeWithPreviousLineOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        const list = root.getListUnderCursor();
        const cursor = root.getCursor();
        const lines = list.getLinesInfo();
        const lineNo = lines.findIndex((l) => cursor.ch === l.from.ch && cursor.line === l.from.line);
        if (lineNo === 0) {
            this.mergeWithPreviousItem(root, cursor, list);
        }
        else if (lineNo > 0) {
            this.mergeNotes(root, cursor, list, lines, lineNo);
        }
    }
    mergeNotes(root, cursor, list, lines, lineNo) {
        this.stopPropagation = true;
        this.updated = true;
        const prevLineNo = lineNo - 1;
        root.replaceCursor({
            line: cursor.line - 1,
            ch: lines[prevLineNo].text.length + lines[prevLineNo].from.ch,
        });
        lines[prevLineNo].text += lines[lineNo].text;
        lines.splice(lineNo, 1);
        list.replaceLines(lines.map((l) => l.text));
    }
    mergeWithPreviousItem(root, cursor, list) {
        if (root.getChildren()[0] === list && list.getChildren().length === 0) {
            return;
        }
        this.stopPropagation = true;
        const prev = root.getListUnderLine(cursor.line - 1);
        if (!prev) {
            return;
        }
        const bothAreEmpty = prev.isEmpty() && list.isEmpty();
        const prevIsEmptyAndSameLevel = prev.isEmpty() && !list.isEmpty() && prev.getLevel() == list.getLevel();
        const listIsEmptyAndPrevIsParent = list.isEmpty() && prev.getLevel() == list.getLevel() - 1;
        if (bothAreEmpty || prevIsEmptyAndSameLevel || listIsEmptyAndPrevIsParent) {
            this.updated = true;
            const parent = list.getParent();
            const prevEnd = prev.getLastLineContentEnd();
            if (!prev.getNotesIndent() && list.getNotesIndent()) {
                prev.setNotesIndent(prev.getFirstLineIndent() +
                    list.getNotesIndent().slice(list.getFirstLineIndent().length));
            }
            const oldLines = prev.getLines();
            const newLines = list.getLines();
            oldLines[oldLines.length - 1] += newLines[0];
            const resultLines = oldLines.concat(newLines.slice(1));
            prev.replaceLines(resultLines);
            parent.removeChild(list);
            for (const c of list.getChildren()) {
                list.removeChild(c);
                prev.addAfterAll(c);
            }
            root.replaceCursor(prevEnd);
            recalculateNumericBullets(root);
        }
    }
}

class DeleteAndMergeWithNextLineOperation {
    constructor(root) {
        this.root = root;
        this.deleteAndMergeWithPrevious =
            new DeleteAndMergeWithPreviousLineOperation(root);
    }
    shouldStopPropagation() {
        return this.deleteAndMergeWithPrevious.shouldStopPropagation();
    }
    shouldUpdate() {
        return this.deleteAndMergeWithPrevious.shouldUpdate();
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        const list = root.getListUnderCursor();
        const cursor = root.getCursor();
        const lines = list.getLinesInfo();
        const lineNo = lines.findIndex((l) => cursor.ch === l.to.ch && cursor.line === l.to.line);
        if (lineNo === lines.length - 1) {
            const nextLine = lines[lineNo].to.line + 1;
            const nextList = root.getListUnderLine(nextLine);
            if (!nextList) {
                return;
            }
            root.replaceCursor(nextList.getFirstLineContentStart());
            this.deleteAndMergeWithPrevious.perform();
        }
        else if (lineNo >= 0) {
            root.replaceCursor(lines[lineNo + 1].from);
            this.deleteAndMergeWithPrevious.perform();
        }
    }
}

class DeleteTillLineStartOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        this.updated = true;
        const cursor = root.getCursor();
        const list = root.getListUnderCursor();
        const lines = list.getLinesInfo();
        const lineNo = lines.findIndex((l) => l.from.line === cursor.line);
        lines[lineNo].text = lines[lineNo].text.slice(cursor.ch - lines[lineNo].from.ch);
        list.replaceLines(lines.map((l) => l.text));
        root.replaceCursor(lines[lineNo].from);
    }
}

class DeleteShouldIgnoreBulletsFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.stickCursor && !this.ime.isIMEOpened();
        };
        this.deleteAndMergeWithPreviousLine = (editor) => {
            return this.performOperation.performOperation((root) => new DeleteAndMergeWithPreviousLineOperation(root), editor);
        };
        this.deleteTillLineStart = (editor) => {
            return this.performOperation.performOperation((root) => new DeleteTillLineStartOperation(root), editor);
        };
        this.deleteAndMergeWithNextLine = (editor) => {
            return this.performOperation.performOperation((root) => new DeleteAndMergeWithNextLineOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.keymap.of([
                {
                    key: "Backspace",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.deleteAndMergeWithPreviousLine,
                    }),
                },
                {
                    key: "Delete",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.deleteAndMergeWithNextLine,
                    }),
                },
                {
                    mac: "m-Backspace",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.deleteTillLineStart,
                    }),
                },
            ]));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class EnsureCursorInListContentOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const cursor = root.getCursor();
        const list = root.getListUnderCursor();
        const contentStart = list.getFirstLineContentStart();
        const linePrefix = contentStart.line === cursor.line
            ? contentStart.ch + list.getCheckboxLength()
            : list.getNotesIndent().length;
        if (cursor.ch < linePrefix) {
            this.updated = true;
            root.replaceCursor({
                line: cursor.line,
                ch: linePrefix,
            });
        }
    }
}

class EnsureCursorIsInUnfoldedLineOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const cursor = root.getCursor();
        const list = root.getListUnderCursor();
        if (!list.isFolded()) {
            return;
        }
        const foldRoot = list.getTopFoldRoot();
        const firstLineEnd = foldRoot.getLinesInfo()[0].to;
        if (cursor.line > firstLineEnd.line) {
            this.updated = true;
            root.replaceCursor(firstLineEnd);
        }
    }
}

class EnsureCursorInListContentFeature {
    constructor(plugin, settings, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.transactionExtender = (tr) => {
            if (!this.settings.stickCursor || !tr.selection) {
                return null;
            }
            const editor = this.obsidian.getEditorFromState(tr.startState);
            setTimeout(() => {
                this.handleCursorActivity(editor);
            }, 0);
            return null;
        };
        this.handleCursorActivity = (editor) => {
            this.performOperation.performOperation((root) => new EnsureCursorIsInUnfoldedLineOperation(root), editor);
            this.performOperation.performOperation((root) => new EnsureCursorInListContentOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(state.EditorState.transactionExtender.of(this.transactionExtender));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class MoveLeftOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const list = root.getListUnderCursor();
        const parent = list.getParent();
        const grandParent = parent.getParent();
        if (!grandParent) {
            return;
        }
        this.updated = true;
        const listStartLineBefore = root.getContentLinesRangeOf(list)[0];
        const indentRmFrom = parent.getFirstLineIndent().length;
        const indentRmTill = list.getFirstLineIndent().length;
        parent.removeChild(list);
        grandParent.addAfter(parent, list);
        list.unindentContent(indentRmFrom, indentRmTill);
        const listStartLineAfter = root.getContentLinesRangeOf(list)[0];
        const lineDiff = listStartLineAfter - listStartLineBefore;
        const chDiff = indentRmTill - indentRmFrom;
        const cursor = root.getCursor();
        root.replaceCursor({
            line: cursor.line + lineDiff,
            ch: cursor.ch - chDiff,
        });
        recalculateNumericBullets(root);
    }
}

function isEmptyLineOrEmptyCheckbox(line) {
    return line === "" || line === "[ ] ";
}

class OutdentIfLineIsEmptyOperation {
    constructor(root) {
        this.root = root;
        this.moveLeftOp = new MoveLeftOperation(root);
    }
    shouldStopPropagation() {
        return this.moveLeftOp.shouldStopPropagation();
    }
    shouldUpdate() {
        return this.moveLeftOp.shouldUpdate();
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        const list = root.getListUnderCursor();
        const lines = list.getLines();
        if (lines.length > 1 ||
            !isEmptyLineOrEmptyCheckbox(lines[0]) ||
            list.getLevel() === 1) {
            return;
        }
        this.moveLeftOp.perform();
    }
}

class EnterOutdentIfLineIsEmptyFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.betterEnter && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            return this.performOperation.performOperation((root) => new OutdentIfLineIsEmptyOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(state.Prec.highest(view.keymap.of([
                {
                    key: "Enter",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ])));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

function cmpPos(a, b) {
    return a.line - b.line || a.ch - b.ch;
}
function maxPos(a, b) {
    return cmpPos(a, b) < 0 ? b : a;
}
function minPos(a, b) {
    return cmpPos(a, b) < 0 ? a : b;
}
class List {
    constructor(root, indent, bullet, checkboxLength, spaceAfterBullet, firstLine, foldRoot) {
        this.root = root;
        this.indent = indent;
        this.bullet = bullet;
        this.checkboxLength = checkboxLength;
        this.spaceAfterBullet = spaceAfterBullet;
        this.foldRoot = foldRoot;
        this.parent = null;
        this.children = [];
        this.notesIndent = null;
        this.lines = [];
        this.lines.push(firstLine);
    }
    getNotesIndent() {
        return this.notesIndent;
    }
    setNotesIndent(notesIndent) {
        if (this.notesIndent !== null) {
            throw new Error(`Notes indent already provided`);
        }
        this.notesIndent = notesIndent;
    }
    addLine(text) {
        if (this.notesIndent === null) {
            throw new Error(`Unable to add line, notes indent should be provided first`);
        }
        this.lines.push(text);
    }
    replaceLines(lines) {
        if (lines.length > 1 && this.notesIndent === null) {
            throw new Error(`Unable to add line, notes indent should be provided first`);
        }
        this.lines = lines;
    }
    getLineCount() {
        return this.lines.length;
    }
    getRoot() {
        return this.root;
    }
    getChildren() {
        return this.children.concat();
    }
    getLinesInfo() {
        const startLine = this.root.getContentLinesRangeOf(this)[0];
        return this.lines.map((row, i) => {
            const line = startLine + i;
            const startCh = i === 0 ? this.getContentStartCh() : this.notesIndent.length;
            const endCh = startCh + row.length;
            return {
                text: row,
                from: { line, ch: startCh },
                to: { line, ch: endCh },
            };
        });
    }
    getLines() {
        return this.lines.concat();
    }
    getFirstLineContentStart() {
        const startLine = this.root.getContentLinesRangeOf(this)[0];
        return {
            line: startLine,
            ch: this.getContentStartCh(),
        };
    }
    getLastLineContentEnd() {
        const endLine = this.root.getContentLinesRangeOf(this)[1];
        const endCh = this.lines.length === 1
            ? this.getContentStartCh() + this.lines[0].length
            : this.notesIndent.length + this.lines[this.lines.length - 1].length;
        return {
            line: endLine,
            ch: endCh,
        };
    }
    getContentStartCh() {
        return this.indent.length + this.bullet.length + 1;
    }
    isFolded() {
        if (this.foldRoot) {
            return true;
        }
        if (this.parent) {
            return this.parent.isFolded();
        }
        return false;
    }
    isFoldRoot() {
        return this.foldRoot;
    }
    getTopFoldRoot() {
        // eslint-disable-next-line @typescript-eslint/no-this-alias
        let tmp = this;
        let foldRoot = null;
        while (tmp) {
            if (tmp.isFoldRoot()) {
                foldRoot = tmp;
            }
            tmp = tmp.parent;
        }
        return foldRoot;
    }
    getLevel() {
        if (!this.parent) {
            return 0;
        }
        return this.parent.getLevel() + 1;
    }
    unindentContent(from, till) {
        this.indent = this.indent.slice(0, from) + this.indent.slice(till);
        if (this.notesIndent !== null) {
            this.notesIndent =
                this.notesIndent.slice(0, from) + this.notesIndent.slice(till);
        }
        for (const child of this.children) {
            child.unindentContent(from, till);
        }
    }
    indentContent(indentPos, indentChars) {
        this.indent =
            this.indent.slice(0, indentPos) +
                indentChars +
                this.indent.slice(indentPos);
        if (this.notesIndent !== null) {
            this.notesIndent =
                this.notesIndent.slice(0, indentPos) +
                    indentChars +
                    this.notesIndent.slice(indentPos);
        }
        for (const child of this.children) {
            child.indentContent(indentPos, indentChars);
        }
    }
    getFirstLineIndent() {
        return this.indent;
    }
    getBullet() {
        return this.bullet;
    }
    getSpaceAfterBullet() {
        return this.spaceAfterBullet;
    }
    getCheckboxLength() {
        return this.checkboxLength;
    }
    replateBullet(bullet) {
        this.bullet = bullet;
    }
    getParent() {
        return this.parent;
    }
    addBeforeAll(list) {
        this.children.unshift(list);
        list.parent = this;
    }
    addAfterAll(list) {
        this.children.push(list);
        list.parent = this;
    }
    removeChild(list) {
        const i = this.children.indexOf(list);
        this.children.splice(i, 1);
        list.parent = null;
    }
    addBefore(before, list) {
        const i = this.children.indexOf(before);
        this.children.splice(i, 0, list);
        list.parent = this;
    }
    addAfter(before, list) {
        const i = this.children.indexOf(before);
        this.children.splice(i + 1, 0, list);
        list.parent = this;
    }
    getPrevSiblingOf(list) {
        const i = this.children.indexOf(list);
        return i > 0 ? this.children[i - 1] : null;
    }
    getNextSiblingOf(list) {
        const i = this.children.indexOf(list);
        return i >= 0 && i < this.children.length ? this.children[i + 1] : null;
    }
    isEmpty() {
        return this.children.length === 0;
    }
    print() {
        let res = "";
        for (let i = 0; i < this.lines.length; i++) {
            res +=
                i === 0
                    ? this.indent + this.bullet + this.spaceAfterBullet
                    : this.notesIndent;
            res += this.lines[i];
            res += "\n";
        }
        for (const child of this.children) {
            res += child.print();
        }
        return res;
    }
}
class Root {
    constructor(start, end, selections) {
        this.start = start;
        this.end = end;
        this.rootList = new List(this, "", "", 0, "", "", false);
        this.selections = [];
        this.replaceSelections(selections);
    }
    getRootList() {
        return this.rootList;
    }
    getRange() {
        return [Object.assign({}, this.start), Object.assign({}, this.end)];
    }
    getSelections() {
        return this.selections.map((s) => ({
            anchor: Object.assign({}, s.anchor),
            head: Object.assign({}, s.head),
        }));
    }
    hasSingleCursor() {
        if (!this.hasSingleSelection()) {
            return false;
        }
        const selection = this.selections[0];
        return (selection.anchor.line === selection.head.line &&
            selection.anchor.ch === selection.head.ch);
    }
    hasSingleSelection() {
        return this.selections.length === 1;
    }
    getSelection() {
        const selection = this.selections[this.selections.length - 1];
        const from = selection.anchor.ch > selection.head.ch
            ? selection.head.ch
            : selection.anchor.ch;
        const to = selection.anchor.ch > selection.head.ch
            ? selection.anchor.ch
            : selection.head.ch;
        return Object.assign(Object.assign({}, selection), { from,
            to });
    }
    getCursor() {
        return Object.assign({}, this.selections[this.selections.length - 1].head);
    }
    replaceCursor(cursor) {
        this.selections = [{ anchor: cursor, head: cursor }];
    }
    replaceSelections(selections) {
        if (selections.length < 1) {
            throw new Error(`Unable to create Root without selections`);
        }
        this.selections = selections;
    }
    getListUnderCursor() {
        return this.getListUnderLine(this.getCursor().line);
    }
    getListUnderLine(line) {
        if (line < this.start.line || line > this.end.line) {
            return;
        }
        let result = null;
        let index = this.start.line;
        const visitArr = (ll) => {
            for (const l of ll) {
                const listFromLine = index;
                const listTillLine = listFromLine + l.getLineCount() - 1;
                if (line >= listFromLine && line <= listTillLine) {
                    result = l;
                }
                else {
                    index = listTillLine + 1;
                    visitArr(l.getChildren());
                }
                if (result !== null) {
                    return;
                }
            }
        };
        visitArr(this.rootList.getChildren());
        return result;
    }
    getContentLinesRangeOf(list) {
        let result = null;
        let line = this.start.line;
        const visitArr = (ll) => {
            for (const l of ll) {
                const listFromLine = line;
                const listTillLine = listFromLine + l.getLineCount() - 1;
                if (l === list) {
                    result = [listFromLine, listTillLine];
                }
                else {
                    line = listTillLine + 1;
                    visitArr(l.getChildren());
                }
                if (result !== null) {
                    return;
                }
            }
        };
        visitArr(this.rootList.getChildren());
        return result;
    }
    getChildren() {
        return this.rootList.getChildren();
    }
    print() {
        let res = "";
        for (const child of this.rootList.getChildren()) {
            res += child.print();
        }
        return res.replace(/\n$/, "");
    }
}

class CreateNewItemOperation {
    constructor(root, defaultIndentChars, getZoomRange) {
        this.root = root;
        this.defaultIndentChars = defaultIndentChars;
        this.getZoomRange = getZoomRange;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleSelection()) {
            return;
        }
        const selection = root.getSelection();
        if (!selection || selection.anchor.line !== selection.head.line) {
            return;
        }
        const list = root.getListUnderCursor();
        const lines = list.getLinesInfo();
        if (lines.length === 1 && isEmptyLineOrEmptyCheckbox(lines[0].text)) {
            return;
        }
        const cursor = root.getCursor();
        const lineUnderCursor = lines.find((l) => l.from.line === cursor.line);
        if (cursor.ch < lineUnderCursor.from.ch) {
            return;
        }
        const { oldLines, newLines } = lines.reduce((acc, line) => {
            if (cursor.line > line.from.line) {
                acc.oldLines.push(line.text);
            }
            else if (cursor.line === line.from.line) {
                const left = line.text.slice(0, selection.from - line.from.ch);
                const right = line.text.slice(selection.to - line.from.ch);
                acc.oldLines.push(left);
                acc.newLines.push(right);
            }
            else if (cursor.line < line.from.line) {
                acc.newLines.push(line.text);
            }
            return acc;
        }, {
            oldLines: [],
            newLines: [],
        });
        const codeBlockBacticks = oldLines.join("\n").split("```").length - 1;
        const isInsideCodeblock = codeBlockBacticks > 0 && codeBlockBacticks % 2 !== 0;
        if (isInsideCodeblock) {
            return;
        }
        this.stopPropagation = true;
        this.updated = true;
        const zoomRange = this.getZoomRange.getZoomRange();
        const listIsZoomingRoot = Boolean(zoomRange &&
            list.getFirstLineContentStart().line >= zoomRange.from.line &&
            list.getLastLineContentEnd().line <= zoomRange.from.line);
        const hasChildren = !list.isEmpty();
        const childIsFolded = list.isFoldRoot();
        const endPos = list.getLastLineContentEnd();
        const endOfLine = cursor.line === endPos.line && cursor.ch === endPos.ch;
        const onChildLevel = listIsZoomingRoot || (hasChildren && !childIsFolded && endOfLine);
        const indent = onChildLevel
            ? hasChildren
                ? list.getChildren()[0].getFirstLineIndent()
                : list.getFirstLineIndent() + this.defaultIndentChars
            : list.getFirstLineIndent();
        const bullet = onChildLevel && hasChildren
            ? list.getChildren()[0].getBullet()
            : list.getBullet();
        const spaceAfterBullet = onChildLevel && hasChildren
            ? list.getChildren()[0].getSpaceAfterBullet()
            : list.getSpaceAfterBullet();
        const prefix = oldLines[0].match(/^\[.\]/) ? "[ ] " : "";
        const newList = new List(list.getRoot(), indent, bullet, prefix.length, spaceAfterBullet, prefix + newLines.shift(), false);
        if (newLines.length > 0) {
            newList.setNotesIndent(list.getNotesIndent());
            for (const line of newLines) {
                newList.addLine(line);
            }
        }
        if (onChildLevel) {
            list.addBeforeAll(newList);
        }
        else {
            if (!childIsFolded || !endOfLine) {
                const children = list.getChildren();
                for (const child of children) {
                    list.removeChild(child);
                    newList.addAfterAll(child);
                }
            }
            list.getParent().addAfter(list, newList);
        }
        list.replaceLines(oldLines);
        const newListStart = newList.getFirstLineContentStart();
        root.replaceCursor({
            line: newListStart.line,
            ch: newListStart.ch + prefix.length,
        });
        recalculateNumericBullets(root);
    }
}

class EnterShouldCreateNewItemFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.betterEnter && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            const zoomRange = editor.getZoomRange();
            const res = this.performOperation.performOperation((root) => new CreateNewItemOperation(root, this.obsidian.getDefaultIndentChars(), {
                getZoomRange: () => zoomRange,
            }), editor);
            if (res.shouldUpdate && zoomRange) {
                editor.zoomIn(zoomRange.from.line);
            }
            return res;
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(state.Prec.highest(view.keymap.of([
                {
                    key: "Enter",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ])));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class FoldFeature {
    constructor(plugin, obsidian) {
        this.plugin = plugin;
        this.obsidian = obsidian;
        this.fold = (editor) => {
            return this.setFold(editor, "fold");
        };
        this.unfold = (editor) => {
            return this.setFold(editor, "unfold");
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.addCommand({
                id: "fold",
                icon: "chevrons-down-up",
                name: "Fold the list",
                editorCallback: this.obsidian.createEditorCallback(this.fold),
                hotkeys: [
                    {
                        modifiers: ["Mod"],
                        key: "ArrowUp",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "unfold",
                icon: "chevrons-up-down",
                name: "Unfold the list",
                editorCallback: this.obsidian.createEditorCallback(this.unfold),
                hotkeys: [
                    {
                        modifiers: ["Mod"],
                        key: "ArrowDown",
                    },
                ],
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
    setFold(editor, type) {
        if (!this.obsidian.getObsidianFoldSettings().foldIndent) {
            new obsidian.Notice(`Unable to ${type} because folding is disabled. Please enable "Fold indent" in Obsidian settings.`, 5000);
            return true;
        }
        const cursor = editor.getCursor();
        if (type === "fold") {
            editor.fold(cursor.line);
        }
        else {
            editor.unfold(cursor.line);
        }
        return true;
    }
}

function foldInside(view, from, to) {
    let found = null;
    language.foldedRanges(view.state).between(from, to, (from, to) => {
        if (!found || found.from > from)
            found = { from, to };
    });
    return found;
}
class MyEditor {
    constructor(e) {
        this.e = e;
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        this.view = this.e.cm;
    }
    getCursor() {
        return this.e.getCursor();
    }
    getLine(n) {
        return this.e.getLine(n);
    }
    lastLine() {
        return this.e.lastLine();
    }
    listSelections() {
        return this.e.listSelections();
    }
    getRange(from, to) {
        return this.e.getRange(from, to);
    }
    replaceRange(replacement, from, to) {
        return this.e.replaceRange(replacement, from, to);
    }
    setSelections(selections) {
        this.e.setSelections(selections);
    }
    setValue(text) {
        this.e.setValue(text);
    }
    getValue() {
        return this.e.getValue();
    }
    offsetToPos(offset) {
        return this.e.offsetToPos(offset);
    }
    posToOffset(pos) {
        return this.e.posToOffset(pos);
    }
    fold(n) {
        const { view } = this;
        const l = view.lineBlockAt(view.state.doc.line(n + 1).from);
        const range = language.foldable(view.state, l.from, l.to);
        if (!range || range.from === range.to) {
            return;
        }
        view.dispatch({ effects: [language.foldEffect.of(range)] });
    }
    unfold(n) {
        const { view } = this;
        const l = view.lineBlockAt(view.state.doc.line(n + 1).from);
        const range = foldInside(view, l.from, l.to);
        if (!range) {
            return;
        }
        view.dispatch({ effects: [language.unfoldEffect.of(range)] });
    }
    getAllFoldedLines() {
        const c = language.foldedRanges(this.view.state).iter();
        const res = [];
        while (c.value) {
            res.push(this.offsetToPos(c.from).line);
            c.next();
        }
        return res;
    }
    triggerOnKeyDown(e) {
        view.runScopeHandlers(this.view, e, "editor");
    }
    getZoomRange() {
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const api = window.ObsidianZoomPlugin;
        if (!api || !api.getZoomRange) {
            return null;
        }
        return api.getZoomRange(this.e);
    }
    zoomOut() {
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const api = window.ObsidianZoomPlugin;
        if (!api || !api.zoomOut) {
            return;
        }
        api.zoomOut(this.e);
    }
    zoomIn(line) {
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const api = window.ObsidianZoomPlugin;
        if (!api || !api.zoomIn) {
            return;
        }
        api.zoomIn(this.e, line);
    }
}

class ListLinesViewPluginValue {
    constructor(settings, obsidian$1, parser, view) {
        this.settings = settings;
        this.obsidian = obsidian$1;
        this.parser = parser;
        this.view = view;
        this.lineElements = [];
        this.waitForEditor = () => {
            const oe = this.view.state.field(obsidian.editorInfoField).editor;
            if (!oe) {
                setTimeout(this.waitForEditor, 0);
                return;
            }
            this.editor = new MyEditor(oe);
            this.scheduleRecalculate();
        };
        this.onScroll = (e) => {
            const { scrollLeft, scrollTop } = e.target;
            this.scroller.scrollTo(scrollLeft, scrollTop);
        };
        this.scheduleRecalculate = () => {
            clearTimeout(this.scheduled);
            this.scheduled = setTimeout(this.calculate, 0);
        };
        this.calculate = () => {
            this.lines = [];
            if (this.settings.listLines &&
                this.obsidian.isDefaultThemeEnabled() &&
                this.view.viewportLineBlocks.length > 0 &&
                this.view.visibleRanges.length > 0) {
                const fromLine = this.editor.offsetToPos(this.view.viewport.from).line;
                const toLine = this.editor.offsetToPos(this.view.viewport.to).line;
                const lists = this.parser.parseRange(this.editor, fromLine, toLine);
                for (const list of lists) {
                    this.lastLine = list.getRange()[1].line;
                    for (const c of list.getChildren()) {
                        this.recursive(c);
                    }
                }
                this.lines.sort((a, b) => a.top === b.top ? a.left - b.left : a.top - b.top);
            }
            this.updateDom();
        };
        this.onClick = (e) => {
            e.preventDefault();
            const line = this.lines[Number(e.target.dataset.index)];
            switch (this.settings.listLineAction) {
                case "zoom-in":
                    this.zoomIn(line);
                    break;
                case "toggle-folding":
                    this.toggleFolding(line);
                    break;
            }
        };
        this.view.scrollDOM.addEventListener("scroll", this.onScroll);
        this.settings.onChange("listLines", this.scheduleRecalculate);
        this.prepareDom();
        this.waitForEditor();
    }
    prepareDom() {
        this.contentContainer = document.createElement("div");
        this.contentContainer.classList.add("outliner-plugin-list-lines-content-container");
        this.scroller = document.createElement("div");
        this.scroller.classList.add("outliner-plugin-list-lines-scroller");
        this.scroller.appendChild(this.contentContainer);
        this.view.dom.appendChild(this.scroller);
    }
    update(update) {
        if (update.docChanged ||
            update.viewportChanged ||
            update.geometryChanged ||
            update.transactions.some((tr) => tr.reconfigured)) {
            this.scheduleRecalculate();
        }
    }
    getNextSibling(list) {
        let listTmp = list;
        let p = listTmp.getParent();
        while (p) {
            const nextSibling = p.getNextSiblingOf(listTmp);
            if (nextSibling) {
                return nextSibling;
            }
            listTmp = p;
            p = listTmp.getParent();
        }
        return null;
    }
    recursive(list, parentCtx = {}) {
        const children = list.getChildren();
        if (children.length === 0) {
            return;
        }
        const fromOffset = this.editor.posToOffset({
            line: list.getFirstLineContentStart().line,
            ch: list.getFirstLineIndent().length,
        });
        const nextSibling = this.getNextSibling(list);
        const tillOffset = this.editor.posToOffset({
            line: nextSibling
                ? nextSibling.getFirstLineContentStart().line - 1
                : this.lastLine,
            ch: 0,
        });
        let visibleFrom = this.view.visibleRanges[0].from;
        let visibleTo = this.view.visibleRanges[this.view.visibleRanges.length - 1].to;
        const zoomRange = this.editor.getZoomRange();
        if (zoomRange) {
            visibleFrom = Math.max(visibleFrom, this.editor.posToOffset(zoomRange.from));
            visibleTo = Math.min(visibleTo, this.editor.posToOffset(zoomRange.to));
        }
        if (fromOffset > visibleTo || tillOffset < visibleFrom) {
            return;
        }
        const coords = this.view.coordsAtPos(fromOffset, 1);
        if (parentCtx.rootLeft === undefined) {
            parentCtx.rootLeft = coords.left;
        }
        const left = Math.floor(coords.right - parentCtx.rootLeft);
        const top = visibleFrom > 0 && fromOffset < visibleFrom
            ? -20
            : this.view.lineBlockAt(fromOffset).top;
        const bottom = tillOffset > visibleTo
            ? this.view.lineBlockAt(visibleTo - 1).bottom
            : this.view.lineBlockAt(tillOffset).bottom;
        const height = bottom - top;
        if (height > 0 && !list.isFolded()) {
            const nextSibling = list.getParent().getNextSiblingOf(list);
            const hasNextSibling = !!nextSibling &&
                this.editor.posToOffset(nextSibling.getFirstLineContentStart()) <=
                    visibleTo;
            this.lines.push({
                top,
                left,
                height: `calc(${height}px ${hasNextSibling ? "- 1.5em" : "- 2em"})`,
                list,
            });
        }
        for (const child of children) {
            if (!child.isEmpty()) {
                this.recursive(child, parentCtx);
            }
        }
    }
    zoomIn(line) {
        const editor = new MyEditor(this.view.state.field(obsidian.editorInfoField).editor);
        editor.zoomIn(line.list.getFirstLineContentStart().line);
    }
    toggleFolding(line) {
        const { list } = line;
        if (list.isEmpty()) {
            return;
        }
        let needToUnfold = true;
        const linesToToggle = [];
        for (const c of list.getChildren()) {
            if (c.isEmpty()) {
                continue;
            }
            if (!c.isFolded()) {
                needToUnfold = false;
            }
            linesToToggle.push(c.getFirstLineContentStart().line);
        }
        const editor = new MyEditor(this.view.state.field(obsidian.editorInfoField).editor);
        for (const l of linesToToggle) {
            if (needToUnfold) {
                editor.unfold(l);
            }
            else {
                editor.fold(l);
            }
        }
    }
    updateDom() {
        const cmScroll = this.view.scrollDOM;
        const cmContent = this.view.contentDOM;
        const cmContentContainer = cmContent.parentElement;
        const cmSizer = cmContentContainer.parentElement;
        /**
         * Obsidian can add additional elements into Content Manager.
         * The most obvious case is the 'embedded-backlinks' core plugin that adds a menu inside a Content Manager.
         * We must take heights of all of these elements into account
         * to be able to calculate the correct size of lines' container.
         */
        let cmSizerChildrenSumHeight = 0;
        for (let i = 0; i < cmSizer.children.length; i++) {
            cmSizerChildrenSumHeight += cmSizer.children[i].clientHeight;
        }
        this.scroller.style.top = cmScroll.offsetTop + "px";
        this.contentContainer.style.height = cmSizerChildrenSumHeight + "px";
        this.contentContainer.style.marginLeft =
            cmContentContainer.offsetLeft + "px";
        this.contentContainer.style.marginTop =
            cmContent.firstElementChild.offsetTop - 24 + "px";
        for (let i = 0; i < this.lines.length; i++) {
            if (this.lineElements.length === i) {
                const e = document.createElement("div");
                e.classList.add("outliner-plugin-list-line");
                e.dataset.index = String(i);
                e.addEventListener("mousedown", this.onClick);
                this.contentContainer.appendChild(e);
                this.lineElements.push(e);
            }
            const l = this.lines[i];
            const e = this.lineElements[i];
            e.style.top = l.top + "px";
            e.style.left = l.left + "px";
            e.style.height = l.height;
            e.style.display = "block";
        }
        for (let i = this.lines.length; i < this.lineElements.length; i++) {
            const e = this.lineElements[i];
            e.style.top = "0px";
            e.style.left = "0px";
            e.style.height = "0px";
            e.style.display = "none";
        }
    }
    destroy() {
        this.settings.removeCallback("listLines", this.scheduleRecalculate);
        this.view.scrollDOM.removeEventListener("scroll", this.onScroll);
        this.view.dom.removeChild(this.scroller);
        clearTimeout(this.scheduled);
    }
}
class LinesFeature {
    constructor(plugin, settings, obsidian, parser) {
        this.plugin = plugin;
        this.settings = settings;
        this.obsidian = obsidian;
        this.parser = parser;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.ViewPlugin.define((view) => new ListLinesViewPluginValue(this.settings, this.obsidian, this.parser, view)));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

const BETTER_LISTS_CLASS = "outliner-plugin-better-lists";
const BETTER_BULLETS_CLASS = "outliner-plugin-better-bullets";
const VERTICAL_LINES = "outliner-plugin-vertical-lines";
const KNOWN_CLASSES = [
    BETTER_LISTS_CLASS,
    BETTER_BULLETS_CLASS,
    VERTICAL_LINES,
];
class ListsStylesFeature {
    constructor(settings, obsidian) {
        this.settings = settings;
        this.obsidian = obsidian;
        this.syncListsStyles = () => {
            const classes = [];
            if (this.obsidian.isDefaultThemeEnabled()) {
                if (this.settings.styleLists) {
                    classes.push(BETTER_LISTS_CLASS);
                    classes.push(BETTER_BULLETS_CLASS);
                }
                if (this.settings.listLines) {
                    classes.push(VERTICAL_LINES);
                }
            }
            this.applyListsStyles(classes);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.syncListsStyles();
            this.interval = window.setInterval(() => {
                this.syncListsStyles();
            }, 1000);
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            clearInterval(this.interval);
            this.applyListsStyles([]);
        });
    }
    applyListsStyles(classes) {
        const toKeep = classes.filter((c) => KNOWN_CLASSES.contains(c));
        const toRemove = KNOWN_CLASSES.filter((c) => !toKeep.contains(c));
        for (const c of toKeep) {
            if (!document.body.classList.contains(c)) {
                document.body.classList.add(c);
            }
        }
        for (const c of toRemove) {
            if (document.body.classList.contains(c)) {
                document.body.classList.remove(c);
            }
        }
    }
}

class MoveCursorToPreviousUnfoldedLineOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        const list = this.root.getListUnderCursor();
        const cursor = this.root.getCursor();
        const lines = list.getLinesInfo();
        const lineNo = lines.findIndex((l) => cursor.ch === l.from.ch + list.getCheckboxLength() &&
            cursor.line === l.from.line);
        if (lineNo === 0) {
            this.moveCursorToPreviousUnfoldedItem(root, cursor);
        }
        else if (lineNo > 0) {
            this.moveCursorToPreviousNoteLine(root, lines, lineNo);
        }
    }
    moveCursorToPreviousNoteLine(root, lines, lineNo) {
        this.stopPropagation = true;
        this.updated = true;
        root.replaceCursor(lines[lineNo - 1].to);
    }
    moveCursorToPreviousUnfoldedItem(root, cursor) {
        const prev = root.getListUnderLine(cursor.line - 1);
        if (!prev) {
            return;
        }
        this.stopPropagation = true;
        this.updated = true;
        if (prev.isFolded()) {
            const foldRoot = prev.getTopFoldRoot();
            const firstLineEnd = foldRoot.getLinesInfo()[0].to;
            root.replaceCursor(firstLineEnd);
        }
        else {
            root.replaceCursor(prev.getLastLineContentEnd());
        }
    }
}

class MoveCursorToPreviousUnfoldedLineFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.stickCursor && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            return this.performOperation.performOperation((root) => new MoveCursorToPreviousUnfoldedLineOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.keymap.of([
                {
                    key: "ArrowLeft",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
                {
                    win: "c-ArrowLeft",
                    linux: "c-ArrowLeft",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ]));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class MoveDownOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const list = root.getListUnderCursor();
        const parent = list.getParent();
        const grandParent = parent.getParent();
        const next = parent.getNextSiblingOf(list);
        const listStartLineBefore = root.getContentLinesRangeOf(list)[0];
        if (!next && grandParent) {
            const newParent = grandParent.getNextSiblingOf(parent);
            if (newParent) {
                this.updated = true;
                parent.removeChild(list);
                newParent.addBeforeAll(list);
            }
        }
        else if (next) {
            this.updated = true;
            parent.removeChild(list);
            parent.addAfter(next, list);
        }
        if (!this.updated) {
            return;
        }
        const listStartLineAfter = root.getContentLinesRangeOf(list)[0];
        const lineDiff = listStartLineAfter - listStartLineBefore;
        const cursor = root.getCursor();
        root.replaceCursor({
            line: cursor.line + lineDiff,
            ch: cursor.ch,
        });
        recalculateNumericBullets(root);
    }
}

class MoveRightOperation {
    constructor(root, defaultIndentChars) {
        this.root = root;
        this.defaultIndentChars = defaultIndentChars;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const list = root.getListUnderCursor();
        const parent = list.getParent();
        const prev = parent.getPrevSiblingOf(list);
        if (!prev) {
            return;
        }
        this.updated = true;
        const listStartLineBefore = root.getContentLinesRangeOf(list)[0];
        const indentPos = list.getFirstLineIndent().length;
        let indentChars = "";
        if (indentChars === "" && !prev.isEmpty()) {
            indentChars = prev
                .getChildren()[0]
                .getFirstLineIndent()
                .slice(prev.getFirstLineIndent().length);
        }
        if (indentChars === "") {
            indentChars = list
                .getFirstLineIndent()
                .slice(parent.getFirstLineIndent().length);
        }
        if (indentChars === "" && !list.isEmpty()) {
            indentChars = list.getChildren()[0].getFirstLineIndent();
        }
        if (indentChars === "") {
            indentChars = this.defaultIndentChars;
        }
        parent.removeChild(list);
        prev.addAfterAll(list);
        list.indentContent(indentPos, indentChars);
        const listStartLineAfter = root.getContentLinesRangeOf(list)[0];
        const lineDiff = listStartLineAfter - listStartLineBefore;
        const cursor = root.getCursor();
        root.replaceCursor({
            line: cursor.line + lineDiff,
            ch: cursor.ch + indentChars.length,
        });
        recalculateNumericBullets(root);
    }
}

class MoveUpOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        const list = root.getListUnderCursor();
        const parent = list.getParent();
        const grandParent = parent.getParent();
        const prev = parent.getPrevSiblingOf(list);
        const listStartLineBefore = root.getContentLinesRangeOf(list)[0];
        if (!prev && grandParent) {
            const newParent = grandParent.getPrevSiblingOf(parent);
            if (newParent) {
                this.updated = true;
                parent.removeChild(list);
                newParent.addAfterAll(list);
            }
        }
        else if (prev) {
            this.updated = true;
            parent.removeChild(list);
            parent.addBefore(prev, list);
        }
        if (!this.updated) {
            return;
        }
        const listStartLineAfter = root.getContentLinesRangeOf(list)[0];
        const lineDiff = listStartLineAfter - listStartLineBefore;
        const cursor = root.getCursor();
        root.replaceCursor({
            line: cursor.line + lineDiff,
            ch: cursor.ch,
        });
        recalculateNumericBullets(root);
    }
}

class MoveItemsFeature {
    constructor(plugin, ime, obsidian, settings, performOperation) {
        this.plugin = plugin;
        this.ime = ime;
        this.obsidian = obsidian;
        this.settings = settings;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.betterTab && !this.ime.isIMEOpened();
        };
        this.moveListElementDownCommand = (editor) => {
            const { shouldStopPropagation } = this.performOperation.performOperation((root) => new MoveDownOperation(root), editor);
            return shouldStopPropagation;
        };
        this.moveListElementUpCommand = (editor) => {
            const { shouldStopPropagation } = this.performOperation.performOperation((root) => new MoveUpOperation(root), editor);
            return shouldStopPropagation;
        };
        this.moveListElementRightCommand = (editor) => {
            if (this.ime.isIMEOpened()) {
                return true;
            }
            return this.moveListElementRight(editor).shouldStopPropagation;
        };
        this.moveListElementRight = (editor) => {
            return this.performOperation.performOperation((root) => new MoveRightOperation(root, this.obsidian.getDefaultIndentChars()), editor);
        };
        this.moveListElementLeftCommand = (editor) => {
            if (this.ime.isIMEOpened()) {
                return true;
            }
            return this.moveListElementLeft(editor).shouldStopPropagation;
        };
        this.moveListElementLeft = (editor) => {
            return this.performOperation.performOperation((root) => new MoveLeftOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.addCommand({
                id: "move-list-item-up",
                icon: "arrow-up",
                name: "Move list and sublists up",
                editorCallback: this.obsidian.createEditorCallback(this.moveListElementUpCommand),
                hotkeys: [
                    {
                        modifiers: ["Mod", "Shift"],
                        key: "ArrowUp",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "move-list-item-down",
                icon: "arrow-down",
                name: "Move list and sublists down",
                editorCallback: this.obsidian.createEditorCallback(this.moveListElementDownCommand),
                hotkeys: [
                    {
                        modifiers: ["Mod", "Shift"],
                        key: "ArrowDown",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "indent-list",
                icon: "indent",
                name: "Indent the list and sublists",
                editorCallback: this.obsidian.createEditorCallback(this.moveListElementRightCommand),
                hotkeys: [],
            });
            this.plugin.addCommand({
                id: "outdent-list",
                icon: "outdent",
                name: "Outdent the list and sublists",
                editorCallback: this.obsidian.createEditorCallback(this.moveListElementLeftCommand),
                hotkeys: [],
            });
            this.plugin.registerEditorExtension(state.Prec.highest(view.keymap.of([
                {
                    key: "Tab",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.moveListElementRight,
                    }),
                },
                {
                    key: "s-Tab",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.moveListElementLeft,
                    }),
                },
            ])));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class SelectAllOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleSelection()) {
            return;
        }
        const selection = root.getSelections()[0];
        const [rootStart, rootEnd] = root.getRange();
        const selectionFrom = minPos(selection.anchor, selection.head);
        const selectionTo = maxPos(selection.anchor, selection.head);
        if (selectionFrom.line < rootStart.line ||
            selectionTo.line > rootEnd.line) {
            return false;
        }
        if (selectionFrom.line === rootStart.line &&
            selectionFrom.ch === rootStart.ch &&
            selectionTo.line === rootEnd.line &&
            selectionTo.ch === rootEnd.ch) {
            return false;
        }
        const list = root.getListUnderCursor();
        const contentStart = list.getFirstLineContentStart();
        const contentEnd = list.getLastLineContentEnd();
        if (selectionFrom.line < contentStart.line ||
            selectionTo.line > contentEnd.line) {
            return false;
        }
        this.stopPropagation = true;
        this.updated = true;
        if (selectionFrom.line === contentStart.line &&
            selectionFrom.ch === contentStart.ch &&
            selectionTo.line === contentEnd.line &&
            selectionTo.ch === contentEnd.ch) {
            // select all list
            root.replaceSelections([{ anchor: rootStart, head: rootEnd }]);
        }
        else {
            // select all line
            root.replaceSelections([{ anchor: contentStart, head: contentEnd }]);
        }
        return true;
    }
}

class SelectAllFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.selectAll && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            return this.performOperation.performOperation((root) => new SelectAllOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.keymap.of([
                {
                    key: "c-a",
                    mac: "m-a",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ]));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class SelectTillLineStartOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        this.stopPropagation = true;
        this.updated = true;
        const cursor = root.getCursor();
        const list = root.getListUnderCursor();
        const lines = list.getLinesInfo();
        const lineNo = lines.findIndex((l) => l.from.line === cursor.line);
        root.replaceSelections([{ head: lines[lineNo].from, anchor: cursor }]);
    }
}

class SelectionShouldIgnoreBulletsFeature {
    constructor(plugin, settings, ime, obsidian, performOperation) {
        this.plugin = plugin;
        this.settings = settings;
        this.ime = ime;
        this.obsidian = obsidian;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.stickCursor && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            return this.performOperation.performOperation((root) => new SelectTillLineStartOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.keymap.of([
                {
                    key: "m-s-ArrowLeft",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ]));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class ObsidianOutlinerPluginSettingTab extends obsidian.PluginSettingTab {
    constructor(app, plugin, settings) {
        super(app, plugin);
        this.settings = settings;
    }
    display() {
        const { containerEl } = this;
        containerEl.empty();
        new obsidian.Setting(containerEl)
            .setName("Improve the style of your lists")
            .setDesc("Styles are only compatible with built-in Obsidian themes and may not be compatible with other themes.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.styleLists).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.styleLists = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Draw vertical indentation lines")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.listLines).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.listLines = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Vertical indentation line click action")
            .addDropdown((dropdown) => {
            dropdown
                .addOptions({
                none: "None",
                "zoom-in": "Zoom In",
                "toggle-folding": "Toggle Folding",
            })
                .setValue(this.settings.listLineAction)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.listLineAction = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Stick the cursor to the content")
            .setDesc("Don't let the cursor move to the bullet position.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.stickCursor).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.stickCursor = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Enhance the Enter key")
            .setDesc("Make the Enter key behave the same as other outliners.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.betterEnter).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.betterEnter = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Enhance the Tab key")
            .setDesc("Make Tab and Shift-Tab behave the same as other outliners.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.betterTab).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.betterTab = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Enhance the Ctrl+A or Cmd+A behavior")
            .setDesc("Press the hotkey once to select the current list item. Press the hotkey twice to select the entire list.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.selectAll).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.selectAll = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Debug mode")
            .setDesc("Open DevTools (Command+Option+I or Control+Shift+I) to copy the debug logs.")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.debug).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.debug = value;
                yield this.settings.save();
            }));
        });
    }
}
class SettingsTabFeature {
    constructor(plugin, settings) {
        this.plugin = plugin;
        this.settings = settings;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.addSettingTab(new ObsidianOutlinerPluginSettingTab(this.plugin.app, this.plugin, this.settings));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class CreateNoteLineOperation {
    constructor(root) {
        this.root = root;
        this.stopPropagation = false;
        this.updated = false;
    }
    shouldStopPropagation() {
        return this.stopPropagation;
    }
    shouldUpdate() {
        return this.updated;
    }
    perform() {
        const { root } = this;
        if (!root.hasSingleCursor()) {
            return;
        }
        const cursor = root.getCursor();
        const list = root.getListUnderCursor();
        const lineUnderCursor = list
            .getLinesInfo()
            .find((l) => l.from.line === cursor.line);
        if (cursor.ch < lineUnderCursor.from.ch) {
            return;
        }
        this.stopPropagation = true;
        this.updated = true;
        if (!list.getNotesIndent()) {
            list.setNotesIndent(list.getFirstLineIndent() + "  ");
        }
        const lines = list.getLinesInfo().reduce((acc, line) => {
            if (cursor.line === line.from.line) {
                acc.push(line.text.slice(0, cursor.ch - line.from.ch));
                acc.push(line.text.slice(cursor.ch - line.from.ch));
            }
            else {
                acc.push(line.text);
            }
            return acc;
        }, []);
        list.replaceLines(lines);
        root.replaceCursor({
            line: cursor.line + 1,
            ch: list.getNotesIndent().length,
        });
    }
}

class ShiftEnterShouldCreateNoteFeature {
    constructor(plugin, obsidian, settings, ime, performOperation) {
        this.plugin = plugin;
        this.obsidian = obsidian;
        this.settings = settings;
        this.ime = ime;
        this.performOperation = performOperation;
        this.check = () => {
            return this.settings.betterEnter && !this.ime.isIMEOpened();
        };
        this.run = (editor) => {
            return this.performOperation.performOperation((root) => new CreateNoteLineOperation(root), editor);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerEditorExtension(view.keymap.of([
                {
                    key: "s-Enter",
                    run: this.obsidian.createKeymapRunCallback({
                        check: this.check,
                        run: this.run,
                    }),
                },
            ]));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
}

class ApplyChangesService {
    applyChanges(editor, root) {
        const rootRange = root.getRange();
        const oldString = editor.getRange(rootRange[0], rootRange[1]);
        const newString = root.print();
        const fromLine = rootRange[0].line;
        const toLine = rootRange[1].line;
        for (let l = fromLine; l <= toLine; l++) {
            editor.unfold(l);
        }
        const changeFrom = Object.assign({}, rootRange[0]);
        const changeTo = Object.assign({}, rootRange[1]);
        let oldTmp = oldString;
        let newTmp = newString;
        // eslint-disable-next-line no-constant-condition
        while (true) {
            const nlIndex = oldTmp.lastIndexOf("\n");
            if (nlIndex < 0) {
                break;
            }
            const oldLine = oldTmp.slice(nlIndex);
            const newLine = newTmp.slice(-oldLine.length);
            if (oldLine !== newLine) {
                break;
            }
            oldTmp = oldTmp.slice(0, -oldLine.length);
            newTmp = newTmp.slice(0, -oldLine.length);
            const nlIndex2 = oldTmp.lastIndexOf("\n");
            changeTo.ch =
                nlIndex2 >= 0 ? oldTmp.length - nlIndex2 - 1 : oldTmp.length;
            changeTo.line--;
        }
        // eslint-disable-next-line no-constant-condition
        while (true) {
            const nlIndex = oldTmp.indexOf("\n");
            if (nlIndex < 0) {
                break;
            }
            const oldLine = oldTmp.slice(0, nlIndex + 1);
            const newLine = newTmp.slice(0, oldLine.length);
            if (oldLine !== newLine) {
                break;
            }
            changeFrom.line++;
            oldTmp = oldTmp.slice(oldLine.length);
            newTmp = newTmp.slice(oldLine.length);
        }
        if (oldTmp !== newTmp) {
            editor.replaceRange(newTmp, changeFrom, changeTo);
        }
        editor.setSelections(root.getSelections());
        function recursive(list) {
            for (const c of list.getChildren()) {
                recursive(c);
            }
            if (list.isFoldRoot()) {
                editor.fold(list.getFirstLineContentStart().line);
            }
        }
        for (const c of root.getChildren()) {
            recursive(c);
        }
    }
}

class IMEService {
    constructor() {
        this.composition = false;
        this.onCompositionStart = () => {
            this.composition = true;
        };
        this.onCompositionEnd = () => {
            this.composition = false;
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            document.addEventListener("compositionstart", this.onCompositionStart);
            document.addEventListener("compositionend", this.onCompositionEnd);
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            document.removeEventListener("compositionend", this.onCompositionEnd);
            document.removeEventListener("compositionstart", this.onCompositionStart);
        });
    }
    isIMEOpened() {
        return this.composition && obsidian.Platform.isDesktop;
    }
}

class LoggerService {
    constructor(settings) {
        this.settings = settings;
    }
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    log(method, ...args) {
        if (!this.settings.debug) {
            return;
        }
        console.info(method, ...args);
    }
    bind(method) {
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        return (...args) => this.log(method, ...args);
    }
}

class ObsidianService {
    constructor(app) {
        this.app = app;
    }
    isLegacyEditorEnabled() {
        const config = Object.assign({ legacyEditor: false }, this.app.vault.config);
        return config.legacyEditor;
    }
    isDefaultThemeEnabled() {
        const config = Object.assign({ cssTheme: "" }, this.app.vault.config);
        return config.cssTheme === "";
    }
    getObsidianTabsSettings() {
        return Object.assign({ useTab: true, tabSize: 4 }, this.app.vault.config);
    }
    getObsidianFoldSettings() {
        return Object.assign({ foldIndent: true }, this.app.vault.config);
    }
    getDefaultIndentChars() {
        const { useTab, tabSize } = this.getObsidianTabsSettings();
        return useTab ? "\t" : new Array(tabSize).fill(" ").join("");
    }
    getEditorFromState(state) {
        return new MyEditor(state.field(obsidian.editorInfoField).editor);
    }
    createKeymapRunCallback(config) {
        const check = config.check || (() => true);
        const { run } = config;
        return (view) => {
            const editor = this.getEditorFromState(view.state);
            if (!check(editor)) {
                return false;
            }
            const { shouldUpdate, shouldStopPropagation } = run(editor);
            return shouldUpdate || shouldStopPropagation;
        };
    }
    createEditorCallback(cb) {
        return (editor) => {
            const myEditor = new MyEditor(editor);
            const shouldStopPropagation = cb(myEditor);
            if (!shouldStopPropagation &&
                window.event &&
                window.event.type === "keydown") {
                myEditor.triggerOnKeyDown(window.event);
            }
        };
    }
}

const bulletSign = `(?:[-*+]|\\d+\\.)`;
const optionalCheckbox = `(?:\\[[ xX]\\]( |\t))?`;
const listItemWithoutSpacesRe = new RegExp(`^${bulletSign}( |\t)`);
const listItemRe = new RegExp(`^[ \t]*${bulletSign}( |\t)`);
const stringWithSpacesRe = new RegExp(`^[ \t]+`);
const parseListItemRe = new RegExp(`^([ \t]*)(${bulletSign})( |\t)((${optionalCheckbox}).*)$`);
class ParserService {
    constructor(logger) {
        this.logger = logger;
    }
    parseRange(editor, fromLine = 0, toLine = editor.lastLine()) {
        const lists = [];
        for (let i = fromLine; i <= toLine; i++) {
            const line = editor.getLine(i);
            if (i === fromLine || this.isListItem(line)) {
                const list = this.parseWithLimits(editor, i, fromLine, toLine);
                if (list) {
                    lists.push(list);
                    i = list.getRange()[1].line;
                }
            }
        }
        return lists;
    }
    parse(editor, cursor = editor.getCursor()) {
        return this.parseWithLimits(editor, cursor.line, 0, editor.lastLine());
    }
    parseWithLimits(editor, parsingStartLine, limitFrom, limitTo) {
        const d = this.logger.bind("parseList");
        const error = (msg) => {
            d(msg);
            return null;
        };
        const line = editor.getLine(parsingStartLine);
        let listLookingPos = null;
        if (this.isListItem(line)) {
            listLookingPos = parsingStartLine;
        }
        else if (this.isLineWithIndent(line)) {
            let listLookingPosSearch = parsingStartLine - 1;
            while (listLookingPosSearch >= 0) {
                const line = editor.getLine(listLookingPosSearch);
                if (this.isListItem(line)) {
                    listLookingPos = listLookingPosSearch;
                    break;
                }
                else if (this.isLineWithIndent(line)) {
                    listLookingPosSearch--;
                }
                else {
                    break;
                }
            }
        }
        if (listLookingPos == null) {
            return null;
        }
        let listStartLine = null;
        let listStartLineLookup = listLookingPos;
        while (listStartLineLookup >= 0) {
            const line = editor.getLine(listStartLineLookup);
            if (!this.isListItem(line) && !this.isLineWithIndent(line)) {
                break;
            }
            if (this.isListItemWithoutSpaces(line)) {
                listStartLine = listStartLineLookup;
                if (listStartLineLookup <= limitFrom) {
                    break;
                }
            }
            listStartLineLookup--;
        }
        if (listStartLine === null) {
            return null;
        }
        let listEndLine = listLookingPos;
        let listEndLineLookup = listLookingPos;
        while (listEndLineLookup <= editor.lastLine()) {
            const line = editor.getLine(listEndLineLookup);
            if (!this.isListItem(line) && !this.isLineWithIndent(line)) {
                break;
            }
            if (!this.isEmptyLine(line)) {
                listEndLine = listEndLineLookup;
            }
            if (listEndLineLookup >= limitTo) {
                listEndLine = limitTo;
                break;
            }
            listEndLineLookup++;
        }
        if (listStartLine > parsingStartLine || listEndLine < parsingStartLine) {
            return null;
        }
        const root = new Root({ line: listStartLine, ch: 0 }, { line: listEndLine, ch: editor.getLine(listEndLine).length }, editor.listSelections().map((r) => ({
            anchor: { line: r.anchor.line, ch: r.anchor.ch },
            head: { line: r.head.line, ch: r.head.ch },
        })));
        let currentParent = root.getRootList();
        let currentList = null;
        let currentIndent = "";
        const foldedLines = editor.getAllFoldedLines();
        for (let l = listStartLine; l <= listEndLine; l++) {
            const line = editor.getLine(l);
            const matches = parseListItemRe.exec(line);
            if (matches) {
                const [, indent, bullet, spaceAfterBullet, content, optionalCheckbox] = matches;
                const compareLength = Math.min(currentIndent.length, indent.length);
                const indentSlice = indent.slice(0, compareLength);
                const currentIndentSlice = currentIndent.slice(0, compareLength);
                if (indentSlice !== currentIndentSlice) {
                    const expected = currentIndentSlice
                        .replace(/ /g, "S")
                        .replace(/\t/g, "T");
                    const got = indentSlice.replace(/ /g, "S").replace(/\t/g, "T");
                    return error(`Unable to parse list: expected indent "${expected}", got "${got}"`);
                }
                if (indent.length > currentIndent.length) {
                    currentParent = currentList;
                    currentIndent = indent;
                }
                else if (indent.length < currentIndent.length) {
                    while (currentParent.getFirstLineIndent().length >= indent.length &&
                        currentParent.getParent()) {
                        currentParent = currentParent.getParent();
                    }
                    currentIndent = indent;
                }
                const foldRoot = foldedLines.includes(l);
                currentList = new List(root, indent, bullet, optionalCheckbox.length, spaceAfterBullet, content, foldRoot);
                currentParent.addAfterAll(currentList);
            }
            else if (this.isLineWithIndent(line)) {
                if (!currentList) {
                    return error(`Unable to parse list: expected list item, got empty line`);
                }
                const indentToCheck = currentList.getNotesIndent() || currentIndent;
                if (line.indexOf(indentToCheck) !== 0) {
                    const expected = indentToCheck.replace(/ /g, "S").replace(/\t/g, "T");
                    const got = line
                        .match(/^[ \t]*/)[0]
                        .replace(/ /g, "S")
                        .replace(/\t/g, "T");
                    return error(`Unable to parse list: expected indent "${expected}", got "${got}"`);
                }
                if (!currentList.getNotesIndent()) {
                    const matches = line.match(/^[ \t]+/);
                    if (!matches || matches[0].length <= currentIndent.length) {
                        if (/^\s+$/.test(line)) {
                            continue;
                        }
                        return error(`Unable to parse list: expected some indent, got no indent`);
                    }
                    currentList.setNotesIndent(matches[0]);
                }
                currentList.addLine(line.slice(currentList.getNotesIndent().length));
            }
            else {
                return error(`Unable to parse list: expected list item or note, got "${line}"`);
            }
        }
        return root;
    }
    isEmptyLine(line) {
        return line.length === 0;
    }
    isLineWithIndent(line) {
        return stringWithSpacesRe.test(line);
    }
    isListItem(line) {
        return listItemRe.test(line);
    }
    isListItemWithoutSpaces(line) {
        return listItemWithoutSpacesRe.test(line);
    }
}

class PerformOperationService {
    constructor(parser, applyChanges) {
        this.parser = parser;
        this.applyChanges = applyChanges;
    }
    evalOperation(root, op, editor) {
        op.perform();
        if (op.shouldUpdate()) {
            this.applyChanges.applyChanges(editor, root);
        }
        return {
            shouldUpdate: op.shouldUpdate(),
            shouldStopPropagation: op.shouldStopPropagation(),
        };
    }
    performOperation(cb, editor, cursor = editor.getCursor()) {
        const root = this.parser.parse(editor, cursor);
        if (!root) {
            return { shouldUpdate: false, shouldStopPropagation: false };
        }
        const op = cb(root);
        return this.evalOperation(root, op, editor);
    }
}

const DEFAULT_SETTINGS = {
    styleLists: true,
    debug: false,
    stickCursor: true,
    betterEnter: true,
    betterTab: true,
    selectAll: true,
    listLines: false,
    listLineAction: "toggle-folding",
};
class SettingsService {
    constructor(storage) {
        this.storage = storage;
        this.handlers = new Map();
    }
    get styleLists() {
        return this.values.styleLists;
    }
    set styleLists(value) {
        this.set("styleLists", value);
    }
    get debug() {
        return this.values.debug;
    }
    set debug(value) {
        this.set("debug", value);
    }
    get stickCursor() {
        return this.values.stickCursor;
    }
    set stickCursor(value) {
        this.set("stickCursor", value);
    }
    get betterEnter() {
        return this.values.betterEnter;
    }
    set betterEnter(value) {
        this.set("betterEnter", value);
    }
    get betterTab() {
        return this.values.betterTab;
    }
    set betterTab(value) {
        this.set("betterTab", value);
    }
    get selectAll() {
        return this.values.selectAll;
    }
    set selectAll(value) {
        this.set("selectAll", value);
    }
    get listLines() {
        return this.values.listLines;
    }
    set listLines(value) {
        this.set("listLines", value);
    }
    get listLineAction() {
        return this.values.listLineAction;
    }
    set listLineAction(value) {
        this.set("listLineAction", value);
    }
    onChange(key, cb) {
        if (!this.handlers.has(key)) {
            this.handlers.set(key, new Set());
        }
        this.handlers.get(key).add(cb);
    }
    removeCallback(key, cb) {
        const handlers = this.handlers.get(key);
        if (handlers) {
            handlers.delete(cb);
        }
    }
    reset() {
        for (const [k, v] of Object.entries(DEFAULT_SETTINGS)) {
            this.set(k, v);
        }
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.values = Object.assign({}, DEFAULT_SETTINGS, yield this.storage.loadData());
        });
    }
    save() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.storage.saveData(this.values);
        });
    }
    set(key, value) {
        this.values[key] = value;
        const callbacks = this.handlers.get(key);
        if (!callbacks) {
            return;
        }
        for (const cb of callbacks.values()) {
            cb(value);
        }
    }
}

class ObsidianOutlinerPlugin extends obsidian.Plugin {
    onload() {
        return __awaiter(this, void 0, void 0, function* () {
            console.log(`Loading obsidian-outliner`);
            this.obsidian = new ObsidianService(this.app);
            this.settings = new SettingsService(this);
            yield this.settings.load();
            this.logger = new LoggerService(this.settings);
            this.parser = new ParserService(this.logger);
            this.applyChanges = new ApplyChangesService();
            this.performOperation = new PerformOperationService(this.parser, this.applyChanges);
            this.ime = new IMEService();
            yield this.ime.load();
            this.features = [
                new SettingsTabFeature(this, this.settings),
                new ListsStylesFeature(this.settings, this.obsidian),
                new EnterOutdentIfLineIsEmptyFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new EnterShouldCreateNewItemFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new EnsureCursorInListContentFeature(this, this.settings, this.obsidian, this.performOperation),
                new MoveCursorToPreviousUnfoldedLineFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new DeleteShouldIgnoreBulletsFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new SelectionShouldIgnoreBulletsFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new FoldFeature(this, this.obsidian),
                new SelectAllFeature(this, this.settings, this.ime, this.obsidian, this.performOperation),
                new MoveItemsFeature(this, this.ime, this.obsidian, this.settings, this.performOperation),
                new ShiftEnterShouldCreateNoteFeature(this, this.obsidian, this.settings, this.ime, this.performOperation),
                new LinesFeature(this, this.settings, this.obsidian, this.parser),
            ];
            for (const feature of this.features) {
                yield feature.load();
            }
        });
    }
    onunload() {
        return __awaiter(this, void 0, void 0, function* () {
            console.log(`Unloading obsidian-outliner`);
            yield this.ime.unload();
            for (const feature of this.features) {
                yield feature.unload();
            }
        });
    }
}

module.exports = ObsidianOutlinerPlugin;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/root/recalculateNumericBullets.ts","src/operations/DeleteAndMergeWithPreviousLineOperation.ts","src/operations/DeleteAndMergeWithNextLineOperation.ts","src/operations/DeleteTillLineStartOperation.ts","src/features/DeleteShouldIgnoreBulletsFeature.ts","src/operations/EnsureCursorInListContentOperation.ts","src/operations/EnsureCursorIsInUnfoldedLineOperation.ts","src/features/EnsureCursorInListContentFeature.ts","src/operations/MoveLeftOperation.ts","src/utils/isEmptyLineOrEmptyCheckbox.ts","src/operations/OutdentIfLineIsEmptyOperation.ts","src/features/EnterOutdentIfLineIsEmptyFeature.ts","src/root/index.ts","src/operations/CreateNewItemOperation.ts","src/features/EnterShouldCreateNewItemOnChildLevelFeature.ts","src/features/FoldFeature.ts","src/MyEditor.ts","src/features/LinesFeature.ts","src/features/ListsStylesFeature.ts","src/operations/MoveCursorToPreviousUnfoldedLineOperation.ts","src/features/MoveCursorToPreviousUnfoldedLineFeature.ts","src/operations/MoveDownOperation.ts","src/operations/MoveRightOperation.ts","src/operations/MoveUpOperation.ts","src/features/MoveItemsFeature.ts","src/operations/SelectAllOperation.ts","src/features/SelectAllFeature.ts","src/operations/SelectTillLineStartOperation.ts","src/features/SelectionShouldIgnoreBulletsFeature.ts","src/features/SettingsTabFeature.ts","src/operations/CreateNoteLineOperation.ts","src/features/ShiftEnterShouldCreateNoteFeature.ts","src/services/ApplyChangesService.ts","src/services/IMEService.ts","src/services/LoggerService.ts","src/services/ObsidianService.ts","src/services/ParserService.ts","src/services/PerformOperationService.ts","src/services/SettingsService.ts","src/ObsidianOutlinerPlugin.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import { List, Root } from \".\";\n\nexport function recalculateNumericBullets(root: Root) {\n  function visit(parent: Root | List) {\n    let index = 1;\n\n    for (const child of parent.getChildren()) {\n      if (/\\d+\\./.test(child.getBullet())) {\n        child.replateBullet(`${index++}.`);\n      }\n\n      visit(child);\n    }\n  }\n\n  visit(root);\n}\n","import { Operation } from \"./Operation\";\n\nimport { List, ListLine, Position, Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\n\nexport class DeleteAndMergeWithPreviousLineOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    const list = root.getListUnderCursor();\n    const cursor = root.getCursor();\n    const lines = list.getLinesInfo();\n\n    const lineNo = lines.findIndex(\n      (l) => cursor.ch === l.from.ch && cursor.line === l.from.line\n    );\n\n    if (lineNo === 0) {\n      this.mergeWithPreviousItem(root, cursor, list);\n    } else if (lineNo > 0) {\n      this.mergeNotes(root, cursor, list, lines, lineNo);\n    }\n  }\n\n  private mergeNotes(\n    root: Root,\n    cursor: Position,\n    list: List,\n    lines: ListLine[],\n    lineNo: number\n  ) {\n    this.stopPropagation = true;\n    this.updated = true;\n\n    const prevLineNo = lineNo - 1;\n\n    root.replaceCursor({\n      line: cursor.line - 1,\n      ch: lines[prevLineNo].text.length + lines[prevLineNo].from.ch,\n    });\n\n    lines[prevLineNo].text += lines[lineNo].text;\n    lines.splice(lineNo, 1);\n\n    list.replaceLines(lines.map((l) => l.text));\n  }\n\n  private mergeWithPreviousItem(root: Root, cursor: Position, list: List) {\n    if (root.getChildren()[0] === list && list.getChildren().length === 0) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const prev = root.getListUnderLine(cursor.line - 1);\n\n    if (!prev) {\n      return;\n    }\n\n    const bothAreEmpty = prev.isEmpty() && list.isEmpty();\n    const prevIsEmptyAndSameLevel =\n      prev.isEmpty() && !list.isEmpty() && prev.getLevel() == list.getLevel();\n    const listIsEmptyAndPrevIsParent =\n      list.isEmpty() && prev.getLevel() == list.getLevel() - 1;\n\n    if (bothAreEmpty || prevIsEmptyAndSameLevel || listIsEmptyAndPrevIsParent) {\n      this.updated = true;\n\n      const parent = list.getParent();\n      const prevEnd = prev.getLastLineContentEnd();\n\n      if (!prev.getNotesIndent() && list.getNotesIndent()) {\n        prev.setNotesIndent(\n          prev.getFirstLineIndent() +\n            list.getNotesIndent().slice(list.getFirstLineIndent().length)\n        );\n      }\n\n      const oldLines = prev.getLines();\n      const newLines = list.getLines();\n      oldLines[oldLines.length - 1] += newLines[0];\n      const resultLines = oldLines.concat(newLines.slice(1));\n\n      prev.replaceLines(resultLines);\n      parent.removeChild(list);\n\n      for (const c of list.getChildren()) {\n        list.removeChild(c);\n        prev.addAfterAll(c);\n      }\n\n      root.replaceCursor(prevEnd);\n\n      recalculateNumericBullets(root);\n    }\n  }\n}\n","import { DeleteAndMergeWithPreviousLineOperation } from \"./DeleteAndMergeWithPreviousLineOperation\";\nimport { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class DeleteAndMergeWithNextLineOperation implements Operation {\n  private deleteAndMergeWithPrevious: DeleteAndMergeWithPreviousLineOperation;\n\n  constructor(private root: Root) {\n    this.deleteAndMergeWithPrevious =\n      new DeleteAndMergeWithPreviousLineOperation(root);\n  }\n\n  shouldStopPropagation() {\n    return this.deleteAndMergeWithPrevious.shouldStopPropagation();\n  }\n\n  shouldUpdate() {\n    return this.deleteAndMergeWithPrevious.shouldUpdate();\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    const list = root.getListUnderCursor();\n    const cursor = root.getCursor();\n    const lines = list.getLinesInfo();\n\n    const lineNo = lines.findIndex(\n      (l) => cursor.ch === l.to.ch && cursor.line === l.to.line\n    );\n\n    if (lineNo === lines.length - 1) {\n      const nextLine = lines[lineNo].to.line + 1;\n      const nextList = root.getListUnderLine(nextLine);\n      if (!nextList) {\n        return;\n      }\n      root.replaceCursor(nextList.getFirstLineContentStart());\n      this.deleteAndMergeWithPrevious.perform();\n    } else if (lineNo >= 0) {\n      root.replaceCursor(lines[lineNo + 1].from);\n      this.deleteAndMergeWithPrevious.perform();\n    }\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class DeleteTillLineStartOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    const cursor = root.getCursor();\n    const list = root.getListUnderCursor();\n    const lines = list.getLinesInfo();\n    const lineNo = lines.findIndex((l) => l.from.line === cursor.line);\n\n    lines[lineNo].text = lines[lineNo].text.slice(\n      cursor.ch - lines[lineNo].from.ch\n    );\n\n    list.replaceLines(lines.map((l) => l.text));\n    root.replaceCursor(lines[lineNo].from);\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { keymap } from \"@codemirror/view\";\n\nimport { Feature } from \"./Feature\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { DeleteAndMergeWithNextLineOperation } from \"../operations/DeleteAndMergeWithNextLineOperation\";\nimport { DeleteAndMergeWithPreviousLineOperation } from \"../operations/DeleteAndMergeWithPreviousLineOperation\";\nimport { DeleteTillLineStartOperation } from \"../operations/DeleteTillLineStartOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class DeleteShouldIgnoreBulletsFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      keymap.of([\n        {\n          key: \"Backspace\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.deleteAndMergeWithPreviousLine,\n          }),\n        },\n        {\n          key: \"Delete\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.deleteAndMergeWithNextLine,\n          }),\n        },\n        {\n          mac: \"m-Backspace\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.deleteTillLineStart,\n          }),\n        },\n      ])\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.stickCursor && !this.ime.isIMEOpened();\n  };\n\n  private deleteAndMergeWithPreviousLine = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new DeleteAndMergeWithPreviousLineOperation(root),\n      editor\n    );\n  };\n\n  private deleteTillLineStart = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new DeleteTillLineStartOperation(root),\n      editor\n    );\n  };\n\n  private deleteAndMergeWithNextLine = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new DeleteAndMergeWithNextLineOperation(root),\n      editor\n    );\n  };\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class EnsureCursorInListContentOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const cursor = root.getCursor();\n    const list = root.getListUnderCursor();\n    const contentStart = list.getFirstLineContentStart();\n    const linePrefix =\n      contentStart.line === cursor.line\n        ? contentStart.ch + list.getCheckboxLength()\n        : list.getNotesIndent().length;\n\n    if (cursor.ch < linePrefix) {\n      this.updated = true;\n      root.replaceCursor({\n        line: cursor.line,\n        ch: linePrefix,\n      });\n    }\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class EnsureCursorIsInUnfoldedLineOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const cursor = root.getCursor();\n\n    const list = root.getListUnderCursor();\n    if (!list.isFolded()) {\n      return;\n    }\n\n    const foldRoot = list.getTopFoldRoot();\n    const firstLineEnd = foldRoot.getLinesInfo()[0].to;\n\n    if (cursor.line > firstLineEnd.line) {\n      this.updated = true;\n      root.replaceCursor(firstLineEnd);\n    }\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { EditorState, Transaction } from \"@codemirror/state\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { EnsureCursorInListContentOperation } from \"../operations/EnsureCursorInListContentOperation\";\nimport { EnsureCursorIsInUnfoldedLineOperation } from \"../operations/EnsureCursorIsInUnfoldedLineOperation\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class EnsureCursorInListContentFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      EditorState.transactionExtender.of(this.transactionExtender)\n    );\n  }\n\n  async unload() {}\n\n  private transactionExtender = (tr: Transaction): null => {\n    if (!this.settings.stickCursor || !tr.selection) {\n      return null;\n    }\n\n    const editor = this.obsidian.getEditorFromState(tr.startState);\n\n    setTimeout(() => {\n      this.handleCursorActivity(editor);\n    }, 0);\n\n    return null;\n  };\n\n  private handleCursorActivity = (editor: MyEditor) => {\n    this.performOperation.performOperation(\n      (root) => new EnsureCursorIsInUnfoldedLineOperation(root),\n      editor\n    );\n\n    this.performOperation.performOperation(\n      (root) => new EnsureCursorInListContentOperation(root),\n      editor\n    );\n  };\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\n\nexport class MoveLeftOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const list = root.getListUnderCursor();\n    const parent = list.getParent();\n    const grandParent = parent.getParent();\n\n    if (!grandParent) {\n      return;\n    }\n\n    this.updated = true;\n\n    const listStartLineBefore = root.getContentLinesRangeOf(list)[0];\n    const indentRmFrom = parent.getFirstLineIndent().length;\n    const indentRmTill = list.getFirstLineIndent().length;\n\n    parent.removeChild(list);\n    grandParent.addAfter(parent, list);\n    list.unindentContent(indentRmFrom, indentRmTill);\n\n    const listStartLineAfter = root.getContentLinesRangeOf(list)[0];\n    const lineDiff = listStartLineAfter - listStartLineBefore;\n    const chDiff = indentRmTill - indentRmFrom;\n\n    const cursor = root.getCursor();\n    root.replaceCursor({\n      line: cursor.line + lineDiff,\n      ch: cursor.ch - chDiff,\n    });\n\n    recalculateNumericBullets(root);\n  }\n}\n","export function isEmptyLineOrEmptyCheckbox(line: string) {\n  return line === \"\" || line === \"[ ] \";\n}\n","import { MoveLeftOperation } from \"./MoveLeftOperation\";\nimport { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\nimport { isEmptyLineOrEmptyCheckbox } from \"../utils/isEmptyLineOrEmptyCheckbox\";\n\nexport class OutdentIfLineIsEmptyOperation implements Operation {\n  private moveLeftOp: MoveLeftOperation;\n\n  constructor(private root: Root) {\n    this.moveLeftOp = new MoveLeftOperation(root);\n  }\n\n  shouldStopPropagation() {\n    return this.moveLeftOp.shouldStopPropagation();\n  }\n\n  shouldUpdate() {\n    return this.moveLeftOp.shouldUpdate();\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    const list = root.getListUnderCursor();\n    const lines = list.getLines();\n\n    if (\n      lines.length > 1 ||\n      !isEmptyLineOrEmptyCheckbox(lines[0]) ||\n      list.getLevel() === 1\n    ) {\n      return;\n    }\n\n    this.moveLeftOp.perform();\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { Prec } from \"@codemirror/state\";\nimport { keymap } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { OutdentIfLineIsEmptyOperation } from \"../operations/OutdentIfLineIsEmptyOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class EnterOutdentIfLineIsEmptyFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      Prec.highest(\n        keymap.of([\n          {\n            key: \"Enter\",\n            run: this.obsidian.createKeymapRunCallback({\n              check: this.check,\n              run: this.run,\n            }),\n          },\n        ])\n      )\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.betterEnter && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new OutdentIfLineIsEmptyOperation(root),\n      editor\n    );\n  };\n}\n","export function cmpPos(a: Position, b: Position) {\n  return a.line - b.line || a.ch - b.ch;\n}\n\nexport function maxPos(a: Position, b: Position) {\n  return cmpPos(a, b) < 0 ? b : a;\n}\n\nexport function minPos(a: Position, b: Position) {\n  return cmpPos(a, b) < 0 ? a : b;\n}\n\nexport interface Position {\n  ch: number;\n  line: number;\n}\n\nexport interface ListLine {\n  text: string;\n  from: Position;\n  to: Position;\n}\n\nexport interface Range {\n  anchor: Position;\n  head: Position;\n}\n\nexport class List {\n  private parent: List | null = null;\n  private children: List[] = [];\n  private notesIndent: string | null = null;\n  private lines: string[] = [];\n\n  constructor(\n    private root: Root,\n    private indent: string,\n    private bullet: string,\n    private checkboxLength: number,\n    private spaceAfterBullet: string,\n    firstLine: string,\n    private foldRoot: boolean\n  ) {\n    this.lines.push(firstLine);\n  }\n\n  getNotesIndent(): string | null {\n    return this.notesIndent;\n  }\n\n  setNotesIndent(notesIndent: string) {\n    if (this.notesIndent !== null) {\n      throw new Error(`Notes indent already provided`);\n    }\n    this.notesIndent = notesIndent;\n  }\n\n  addLine(text: string) {\n    if (this.notesIndent === null) {\n      throw new Error(\n        `Unable to add line, notes indent should be provided first`\n      );\n    }\n\n    this.lines.push(text);\n  }\n\n  replaceLines(lines: string[]) {\n    if (lines.length > 1 && this.notesIndent === null) {\n      throw new Error(\n        `Unable to add line, notes indent should be provided first`\n      );\n    }\n\n    this.lines = lines;\n  }\n\n  getLineCount() {\n    return this.lines.length;\n  }\n\n  getRoot() {\n    return this.root;\n  }\n\n  getChildren() {\n    return this.children.concat();\n  }\n\n  getLinesInfo(): ListLine[] {\n    const startLine = this.root.getContentLinesRangeOf(this)[0];\n\n    return this.lines.map((row, i) => {\n      const line = startLine + i;\n      const startCh =\n        i === 0 ? this.getContentStartCh() : this.notesIndent.length;\n      const endCh = startCh + row.length;\n\n      return {\n        text: row,\n        from: { line, ch: startCh },\n        to: { line, ch: endCh },\n      };\n    });\n  }\n\n  getLines(): string[] {\n    return this.lines.concat();\n  }\n\n  getFirstLineContentStart() {\n    const startLine = this.root.getContentLinesRangeOf(this)[0];\n\n    return {\n      line: startLine,\n      ch: this.getContentStartCh(),\n    };\n  }\n\n  getLastLineContentEnd() {\n    const endLine = this.root.getContentLinesRangeOf(this)[1];\n    const endCh =\n      this.lines.length === 1\n        ? this.getContentStartCh() + this.lines[0].length\n        : this.notesIndent.length + this.lines[this.lines.length - 1].length;\n\n    return {\n      line: endLine,\n      ch: endCh,\n    };\n  }\n\n  private getContentStartCh() {\n    return this.indent.length + this.bullet.length + 1;\n  }\n\n  isFolded(): boolean {\n    if (this.foldRoot) {\n      return true;\n    }\n\n    if (this.parent) {\n      return this.parent.isFolded();\n    }\n\n    return false;\n  }\n\n  isFoldRoot() {\n    return this.foldRoot;\n  }\n\n  getTopFoldRoot() {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    let tmp: List = this;\n    let foldRoot: List | null = null;\n    while (tmp) {\n      if (tmp.isFoldRoot()) {\n        foldRoot = tmp;\n      }\n      tmp = tmp.parent;\n    }\n    return foldRoot;\n  }\n\n  getLevel(): number {\n    if (!this.parent) {\n      return 0;\n    }\n\n    return this.parent.getLevel() + 1;\n  }\n\n  unindentContent(from: number, till: number) {\n    this.indent = this.indent.slice(0, from) + this.indent.slice(till);\n    if (this.notesIndent !== null) {\n      this.notesIndent =\n        this.notesIndent.slice(0, from) + this.notesIndent.slice(till);\n    }\n\n    for (const child of this.children) {\n      child.unindentContent(from, till);\n    }\n  }\n\n  indentContent(indentPos: number, indentChars: string) {\n    this.indent =\n      this.indent.slice(0, indentPos) +\n      indentChars +\n      this.indent.slice(indentPos);\n    if (this.notesIndent !== null) {\n      this.notesIndent =\n        this.notesIndent.slice(0, indentPos) +\n        indentChars +\n        this.notesIndent.slice(indentPos);\n    }\n\n    for (const child of this.children) {\n      child.indentContent(indentPos, indentChars);\n    }\n  }\n\n  getFirstLineIndent() {\n    return this.indent;\n  }\n\n  getBullet() {\n    return this.bullet;\n  }\n\n  getSpaceAfterBullet() {\n    return this.spaceAfterBullet;\n  }\n\n  getCheckboxLength() {\n    return this.checkboxLength;\n  }\n\n  replateBullet(bullet: string) {\n    this.bullet = bullet;\n  }\n\n  getParent() {\n    return this.parent;\n  }\n\n  addBeforeAll(list: List) {\n    this.children.unshift(list);\n    list.parent = this;\n  }\n\n  addAfterAll(list: List) {\n    this.children.push(list);\n    list.parent = this;\n  }\n\n  removeChild(list: List) {\n    const i = this.children.indexOf(list);\n    this.children.splice(i, 1);\n    list.parent = null;\n  }\n\n  addBefore(before: List, list: List) {\n    const i = this.children.indexOf(before);\n    this.children.splice(i, 0, list);\n    list.parent = this;\n  }\n\n  addAfter(before: List, list: List) {\n    const i = this.children.indexOf(before);\n    this.children.splice(i + 1, 0, list);\n    list.parent = this;\n  }\n\n  getPrevSiblingOf(list: List) {\n    const i = this.children.indexOf(list);\n    return i > 0 ? this.children[i - 1] : null;\n  }\n\n  getNextSiblingOf(list: List) {\n    const i = this.children.indexOf(list);\n    return i >= 0 && i < this.children.length ? this.children[i + 1] : null;\n  }\n\n  isEmpty() {\n    return this.children.length === 0;\n  }\n\n  print() {\n    let res = \"\";\n\n    for (let i = 0; i < this.lines.length; i++) {\n      res +=\n        i === 0\n          ? this.indent + this.bullet + this.spaceAfterBullet\n          : this.notesIndent;\n      res += this.lines[i];\n      res += \"\\n\";\n    }\n\n    for (const child of this.children) {\n      res += child.print();\n    }\n\n    return res;\n  }\n}\n\nexport class Root {\n  private rootList = new List(this, \"\", \"\", 0, \"\", \"\", false);\n  private selections: Range[] = [];\n\n  constructor(\n    private start: Position,\n    private end: Position,\n    selections: Range[]\n  ) {\n    this.replaceSelections(selections);\n  }\n\n  getRootList() {\n    return this.rootList;\n  }\n\n  getRange(): [Position, Position] {\n    return [{ ...this.start }, { ...this.end }];\n  }\n\n  getSelections(): Range[] {\n    return this.selections.map((s) => ({\n      anchor: { ...s.anchor },\n      head: { ...s.head },\n    }));\n  }\n\n  hasSingleCursor() {\n    if (!this.hasSingleSelection()) {\n      return false;\n    }\n\n    const selection = this.selections[0];\n\n    return (\n      selection.anchor.line === selection.head.line &&\n      selection.anchor.ch === selection.head.ch\n    );\n  }\n\n  hasSingleSelection() {\n    return this.selections.length === 1;\n  }\n\n  getSelection() {\n    const selection = this.selections[this.selections.length - 1];\n\n    const from =\n      selection.anchor.ch > selection.head.ch\n        ? selection.head.ch\n        : selection.anchor.ch;\n    const to =\n      selection.anchor.ch > selection.head.ch\n        ? selection.anchor.ch\n        : selection.head.ch;\n\n    return {\n      ...selection,\n      from,\n      to,\n    };\n  }\n\n  getCursor() {\n    return { ...this.selections[this.selections.length - 1].head };\n  }\n\n  replaceCursor(cursor: Position) {\n    this.selections = [{ anchor: cursor, head: cursor }];\n  }\n\n  replaceSelections(selections: Range[]) {\n    if (selections.length < 1) {\n      throw new Error(`Unable to create Root without selections`);\n    }\n    this.selections = selections;\n  }\n\n  getListUnderCursor(): List {\n    return this.getListUnderLine(this.getCursor().line);\n  }\n\n  getListUnderLine(line: number) {\n    if (line < this.start.line || line > this.end.line) {\n      return;\n    }\n\n    let result: List = null;\n    let index: number = this.start.line;\n\n    const visitArr = (ll: List[]) => {\n      for (const l of ll) {\n        const listFromLine = index;\n        const listTillLine = listFromLine + l.getLineCount() - 1;\n\n        if (line >= listFromLine && line <= listTillLine) {\n          result = l;\n        } else {\n          index = listTillLine + 1;\n          visitArr(l.getChildren());\n        }\n        if (result !== null) {\n          return;\n        }\n      }\n    };\n\n    visitArr(this.rootList.getChildren());\n\n    return result;\n  }\n\n  getContentLinesRangeOf(list: List): [number, number] | null {\n    let result: [number, number] | null = null;\n    let line: number = this.start.line;\n\n    const visitArr = (ll: List[]) => {\n      for (const l of ll) {\n        const listFromLine = line;\n        const listTillLine = listFromLine + l.getLineCount() - 1;\n\n        if (l === list) {\n          result = [listFromLine, listTillLine];\n        } else {\n          line = listTillLine + 1;\n          visitArr(l.getChildren());\n        }\n\n        if (result !== null) {\n          return;\n        }\n      }\n    };\n\n    visitArr(this.rootList.getChildren());\n\n    return result;\n  }\n\n  getChildren() {\n    return this.rootList.getChildren();\n  }\n\n  print() {\n    let res = \"\";\n\n    for (const child of this.rootList.getChildren()) {\n      res += child.print();\n    }\n\n    return res.replace(/\\n$/, \"\");\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { List, Position, Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\nimport { isEmptyLineOrEmptyCheckbox } from \"../utils/isEmptyLineOrEmptyCheckbox\";\n\nexport interface GetZoomRange {\n  getZoomRange(): { from: Position; to: Position } | null;\n}\n\nexport class CreateNewItemOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(\n    private root: Root,\n    private defaultIndentChars: string,\n    private getZoomRange: GetZoomRange\n  ) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleSelection()) {\n      return;\n    }\n\n    const selection = root.getSelection();\n    if (!selection || selection.anchor.line !== selection.head.line) {\n      return;\n    }\n\n    const list = root.getListUnderCursor();\n    const lines = list.getLinesInfo();\n\n    if (lines.length === 1 && isEmptyLineOrEmptyCheckbox(lines[0].text)) {\n      return;\n    }\n\n    const cursor = root.getCursor();\n    const lineUnderCursor = lines.find((l) => l.from.line === cursor.line);\n\n    if (cursor.ch < lineUnderCursor.from.ch) {\n      return;\n    }\n\n    const { oldLines, newLines } = lines.reduce(\n      (acc, line) => {\n        if (cursor.line > line.from.line) {\n          acc.oldLines.push(line.text);\n        } else if (cursor.line === line.from.line) {\n          const left = line.text.slice(0, selection.from - line.from.ch);\n          const right = line.text.slice(selection.to - line.from.ch);\n          acc.oldLines.push(left);\n          acc.newLines.push(right);\n        } else if (cursor.line < line.from.line) {\n          acc.newLines.push(line.text);\n        }\n\n        return acc;\n      },\n      {\n        oldLines: [],\n        newLines: [],\n      }\n    );\n\n    const codeBlockBacticks = oldLines.join(\"\\n\").split(\"```\").length - 1;\n    const isInsideCodeblock =\n      codeBlockBacticks > 0 && codeBlockBacticks % 2 !== 0;\n\n    if (isInsideCodeblock) {\n      return;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    const zoomRange = this.getZoomRange.getZoomRange();\n    const listIsZoomingRoot = Boolean(\n      zoomRange &&\n        list.getFirstLineContentStart().line >= zoomRange.from.line &&\n        list.getLastLineContentEnd().line <= zoomRange.from.line\n    );\n\n    const hasChildren = !list.isEmpty();\n    const childIsFolded = list.isFoldRoot();\n    const endPos = list.getLastLineContentEnd();\n    const endOfLine = cursor.line === endPos.line && cursor.ch === endPos.ch;\n\n    const onChildLevel =\n      listIsZoomingRoot || (hasChildren && !childIsFolded && endOfLine);\n\n    const indent = onChildLevel\n      ? hasChildren\n        ? list.getChildren()[0].getFirstLineIndent()\n        : list.getFirstLineIndent() + this.defaultIndentChars\n      : list.getFirstLineIndent();\n\n    const bullet =\n      onChildLevel && hasChildren\n        ? list.getChildren()[0].getBullet()\n        : list.getBullet();\n\n    const spaceAfterBullet =\n      onChildLevel && hasChildren\n        ? list.getChildren()[0].getSpaceAfterBullet()\n        : list.getSpaceAfterBullet();\n\n    const prefix = oldLines[0].match(/^\\[.\\]/) ? \"[ ] \" : \"\";\n\n    const newList = new List(\n      list.getRoot(),\n      indent,\n      bullet,\n      prefix.length,\n      spaceAfterBullet,\n      prefix + newLines.shift(),\n      false\n    );\n\n    if (newLines.length > 0) {\n      newList.setNotesIndent(list.getNotesIndent());\n      for (const line of newLines) {\n        newList.addLine(line);\n      }\n    }\n\n    if (onChildLevel) {\n      list.addBeforeAll(newList);\n    } else {\n      if (!childIsFolded || !endOfLine) {\n        const children = list.getChildren();\n        for (const child of children) {\n          list.removeChild(child);\n          newList.addAfterAll(child);\n        }\n      }\n\n      list.getParent().addAfter(list, newList);\n    }\n\n    list.replaceLines(oldLines);\n\n    const newListStart = newList.getFirstLineContentStart();\n    root.replaceCursor({\n      line: newListStart.line,\n      ch: newListStart.ch + prefix.length,\n    });\n\n    recalculateNumericBullets(root);\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { Prec } from \"@codemirror/state\";\nimport { keymap } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { CreateNewItemOperation } from \"../operations/CreateNewItemOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class EnterShouldCreateNewItemFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      Prec.highest(\n        keymap.of([\n          {\n            key: \"Enter\",\n            run: this.obsidian.createKeymapRunCallback({\n              check: this.check,\n              run: this.run,\n            }),\n          },\n        ])\n      )\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.betterEnter && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    const zoomRange = editor.getZoomRange();\n\n    const res = this.performOperation.performOperation(\n      (root) =>\n        new CreateNewItemOperation(\n          root,\n          this.obsidian.getDefaultIndentChars(),\n          {\n            getZoomRange: () => zoomRange,\n          }\n        ),\n      editor\n    );\n\n    if (res.shouldUpdate && zoomRange) {\n      editor.zoomIn(zoomRange.from.line);\n    }\n\n    return res;\n  };\n}\n","import { Notice, Plugin_2 } from \"obsidian\";\n\nimport { Feature } from \"./Feature\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { ObsidianService } from \"../services/ObsidianService\";\n\nexport class FoldFeature implements Feature {\n  constructor(private plugin: Plugin_2, private obsidian: ObsidianService) {}\n\n  async load() {\n    this.plugin.addCommand({\n      id: \"fold\",\n      icon: \"chevrons-down-up\",\n      name: \"Fold the list\",\n      editorCallback: this.obsidian.createEditorCallback(this.fold),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\"],\n          key: \"ArrowUp\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"unfold\",\n      icon: \"chevrons-up-down\",\n      name: \"Unfold the list\",\n      editorCallback: this.obsidian.createEditorCallback(this.unfold),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\"],\n          key: \"ArrowDown\",\n        },\n      ],\n    });\n  }\n\n  async unload() {}\n\n  private setFold(editor: MyEditor, type: \"fold\" | \"unfold\") {\n    if (!this.obsidian.getObsidianFoldSettings().foldIndent) {\n      new Notice(\n        `Unable to ${type} because folding is disabled. Please enable \"Fold indent\" in Obsidian settings.`,\n        5000\n      );\n      return true;\n    }\n\n    const cursor = editor.getCursor();\n\n    if (type === \"fold\") {\n      editor.fold(cursor.line);\n    } else {\n      editor.unfold(cursor.line);\n    }\n\n    return true;\n  }\n\n  private fold = (editor: MyEditor) => {\n    return this.setFold(editor, \"fold\");\n  };\n\n  private unfold = (editor: MyEditor) => {\n    return this.setFold(editor, \"unfold\");\n  };\n}\n","/* eslint-disable @typescript-eslint/no-unused-vars */\nimport { Editor } from \"obsidian\";\n\nimport {\n  foldEffect,\n  foldable,\n  foldedRanges,\n  unfoldEffect,\n} from \"@codemirror/language\";\nimport { EditorView, runScopeHandlers } from \"@codemirror/view\";\n\nexport class MyEditorPosition {\n  line: number;\n  ch: number;\n}\n\nexport class MyEditorRange {\n  from: MyEditorPosition;\n  to: MyEditorPosition;\n}\n\nexport class MyEditorSelection {\n  anchor: MyEditorPosition;\n  head: MyEditorPosition;\n}\n\nfunction foldInside(view: EditorView, from: number, to: number) {\n  let found: { from: number; to: number } | null = null;\n  foldedRanges(view.state).between(from, to, (from, to) => {\n    if (!found || found.from > from) found = { from, to };\n  });\n  return found;\n}\n\nexport class MyEditor {\n  private view: EditorView;\n\n  constructor(private e: Editor) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this.view = (this.e as any).cm;\n  }\n\n  getCursor(): MyEditorPosition {\n    return this.e.getCursor();\n  }\n\n  getLine(n: number): string {\n    return this.e.getLine(n);\n  }\n\n  lastLine(): number {\n    return this.e.lastLine();\n  }\n\n  listSelections(): MyEditorSelection[] {\n    return this.e.listSelections();\n  }\n\n  getRange(from: MyEditorPosition, to: MyEditorPosition): string {\n    return this.e.getRange(from, to);\n  }\n\n  replaceRange(\n    replacement: string,\n    from: MyEditorPosition,\n    to: MyEditorPosition\n  ): void {\n    return this.e.replaceRange(replacement, from, to);\n  }\n\n  setSelections(selections: MyEditorSelection[]): void {\n    this.e.setSelections(selections);\n  }\n\n  setValue(text: string): void {\n    this.e.setValue(text);\n  }\n\n  getValue(): string {\n    return this.e.getValue();\n  }\n\n  offsetToPos(offset: number): MyEditorPosition {\n    return this.e.offsetToPos(offset);\n  }\n\n  posToOffset(pos: MyEditorPosition): number {\n    return this.e.posToOffset(pos);\n  }\n\n  fold(n: number): void {\n    const { view } = this;\n    const l = view.lineBlockAt(view.state.doc.line(n + 1).from);\n    const range = foldable(view.state, l.from, l.to);\n\n    if (!range || range.from === range.to) {\n      return;\n    }\n\n    view.dispatch({ effects: [foldEffect.of(range)] });\n  }\n\n  unfold(n: number): void {\n    const { view } = this;\n    const l = view.lineBlockAt(view.state.doc.line(n + 1).from);\n    const range = foldInside(view, l.from, l.to);\n\n    if (!range) {\n      return;\n    }\n\n    view.dispatch({ effects: [unfoldEffect.of(range)] });\n  }\n\n  getAllFoldedLines(): number[] {\n    const c = foldedRanges(this.view.state).iter();\n    const res: number[] = [];\n    while (c.value) {\n      res.push(this.offsetToPos(c.from).line);\n      c.next();\n    }\n    return res;\n  }\n\n  triggerOnKeyDown(e: KeyboardEvent): void {\n    runScopeHandlers(this.view, e, \"editor\");\n  }\n\n  getZoomRange(): MyEditorRange | null {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const api = (window as any).ObsidianZoomPlugin;\n\n    if (!api || !api.getZoomRange) {\n      return null;\n    }\n\n    return api.getZoomRange(this.e);\n  }\n\n  zoomOut() {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const api = (window as any).ObsidianZoomPlugin;\n\n    if (!api || !api.zoomOut) {\n      return;\n    }\n\n    api.zoomOut(this.e);\n  }\n\n  zoomIn(line: number) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const api = (window as any).ObsidianZoomPlugin;\n\n    if (!api || !api.zoomIn) {\n      return;\n    }\n\n    api.zoomIn(this.e, line);\n  }\n}\n","import { Plugin_2, editorInfoField } from \"obsidian\";\n\nimport {\n  EditorView,\n  PluginValue,\n  ViewPlugin,\n  ViewUpdate,\n} from \"@codemirror/view\";\n\nimport { Feature } from \"./Feature\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { List } from \"../root\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { ParserService } from \"../services/ParserService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\ninterface LineData {\n  top: number;\n  left: number;\n  height: string;\n  list: List;\n}\n\nclass ListLinesViewPluginValue implements PluginValue {\n  private scheduled: ReturnType<typeof setTimeout>;\n  private scroller: HTMLElement;\n  private contentContainer: HTMLElement;\n  private editor: MyEditor;\n  private lastLine: number;\n  private lines: LineData[];\n  private lineElements: HTMLElement[] = [];\n\n  constructor(\n    private settings: SettingsService,\n    private obsidian: ObsidianService,\n    private parser: ParserService,\n    private view: EditorView\n  ) {\n    this.view.scrollDOM.addEventListener(\"scroll\", this.onScroll);\n    this.settings.onChange(\"listLines\", this.scheduleRecalculate);\n\n    this.prepareDom();\n    this.waitForEditor();\n  }\n\n  private waitForEditor = () => {\n    const oe = this.view.state.field(editorInfoField).editor;\n    if (!oe) {\n      setTimeout(this.waitForEditor, 0);\n      return;\n    }\n    this.editor = new MyEditor(oe);\n    this.scheduleRecalculate();\n  };\n\n  private prepareDom() {\n    this.contentContainer = document.createElement(\"div\");\n    this.contentContainer.classList.add(\n      \"outliner-plugin-list-lines-content-container\"\n    );\n\n    this.scroller = document.createElement(\"div\");\n    this.scroller.classList.add(\"outliner-plugin-list-lines-scroller\");\n\n    this.scroller.appendChild(this.contentContainer);\n    this.view.dom.appendChild(this.scroller);\n  }\n\n  private onScroll = (e: Event) => {\n    const { scrollLeft, scrollTop } = e.target as HTMLElement;\n    this.scroller.scrollTo(scrollLeft, scrollTop);\n  };\n\n  private scheduleRecalculate = () => {\n    clearTimeout(this.scheduled);\n    this.scheduled = setTimeout(this.calculate, 0);\n  };\n\n  update(update: ViewUpdate) {\n    if (\n      update.docChanged ||\n      update.viewportChanged ||\n      update.geometryChanged ||\n      update.transactions.some((tr) => tr.reconfigured)\n    ) {\n      this.scheduleRecalculate();\n    }\n  }\n\n  private calculate = () => {\n    this.lines = [];\n\n    if (\n      this.settings.listLines &&\n      this.obsidian.isDefaultThemeEnabled() &&\n      this.view.viewportLineBlocks.length > 0 &&\n      this.view.visibleRanges.length > 0\n    ) {\n      const fromLine = this.editor.offsetToPos(this.view.viewport.from).line;\n      const toLine = this.editor.offsetToPos(this.view.viewport.to).line;\n      const lists = this.parser.parseRange(this.editor, fromLine, toLine);\n\n      for (const list of lists) {\n        this.lastLine = list.getRange()[1].line;\n\n        for (const c of list.getChildren()) {\n          this.recursive(c);\n        }\n      }\n\n      this.lines.sort((a, b) =>\n        a.top === b.top ? a.left - b.left : a.top - b.top\n      );\n    }\n\n    this.updateDom();\n  };\n\n  private getNextSibling(list: List): List | null {\n    let listTmp = list;\n    let p = listTmp.getParent();\n    while (p) {\n      const nextSibling = p.getNextSiblingOf(listTmp);\n      if (nextSibling) {\n        return nextSibling;\n      }\n      listTmp = p;\n      p = listTmp.getParent();\n    }\n    return null;\n  }\n\n  private recursive(list: List, parentCtx: { rootLeft?: number } = {}) {\n    const children = list.getChildren();\n\n    if (children.length === 0) {\n      return;\n    }\n\n    const fromOffset = this.editor.posToOffset({\n      line: list.getFirstLineContentStart().line,\n      ch: list.getFirstLineIndent().length,\n    });\n    const nextSibling = this.getNextSibling(list);\n    const tillOffset = this.editor.posToOffset({\n      line: nextSibling\n        ? nextSibling.getFirstLineContentStart().line - 1\n        : this.lastLine,\n      ch: 0,\n    });\n\n    let visibleFrom = this.view.visibleRanges[0].from;\n    let visibleTo =\n      this.view.visibleRanges[this.view.visibleRanges.length - 1].to;\n    const zoomRange = this.editor.getZoomRange();\n    if (zoomRange) {\n      visibleFrom = Math.max(\n        visibleFrom,\n        this.editor.posToOffset(zoomRange.from)\n      );\n      visibleTo = Math.min(visibleTo, this.editor.posToOffset(zoomRange.to));\n    }\n\n    if (fromOffset > visibleTo || tillOffset < visibleFrom) {\n      return;\n    }\n\n    const coords = this.view.coordsAtPos(fromOffset, 1);\n    if (parentCtx.rootLeft === undefined) {\n      parentCtx.rootLeft = coords.left;\n    }\n    const left = Math.floor(coords.right - parentCtx.rootLeft);\n\n    const top =\n      visibleFrom > 0 && fromOffset < visibleFrom\n        ? -20\n        : this.view.lineBlockAt(fromOffset).top;\n    const bottom =\n      tillOffset > visibleTo\n        ? this.view.lineBlockAt(visibleTo - 1).bottom\n        : this.view.lineBlockAt(tillOffset).bottom;\n    const height = bottom - top;\n\n    if (height > 0 && !list.isFolded()) {\n      const nextSibling = list.getParent().getNextSiblingOf(list);\n      const hasNextSibling =\n        !!nextSibling &&\n        this.editor.posToOffset(nextSibling.getFirstLineContentStart()) <=\n          visibleTo;\n\n      this.lines.push({\n        top,\n        left,\n        height: `calc(${height}px ${hasNextSibling ? \"- 1.5em\" : \"- 2em\"})`,\n        list,\n      });\n    }\n\n    for (const child of children) {\n      if (!child.isEmpty()) {\n        this.recursive(child, parentCtx);\n      }\n    }\n  }\n\n  private onClick = (e: MouseEvent) => {\n    e.preventDefault();\n\n    const line = this.lines[Number((e.target as HTMLElement).dataset.index)];\n\n    switch (this.settings.listLineAction) {\n      case \"zoom-in\":\n        this.zoomIn(line);\n        break;\n\n      case \"toggle-folding\":\n        this.toggleFolding(line);\n        break;\n    }\n  };\n\n  private zoomIn(line: LineData) {\n    const editor = new MyEditor(this.view.state.field(editorInfoField).editor);\n\n    editor.zoomIn(line.list.getFirstLineContentStart().line);\n  }\n\n  private toggleFolding(line: LineData) {\n    const { list } = line;\n\n    if (list.isEmpty()) {\n      return;\n    }\n\n    let needToUnfold = true;\n    const linesToToggle: number[] = [];\n    for (const c of list.getChildren()) {\n      if (c.isEmpty()) {\n        continue;\n      }\n      if (!c.isFolded()) {\n        needToUnfold = false;\n      }\n      linesToToggle.push(c.getFirstLineContentStart().line);\n    }\n\n    const editor = new MyEditor(this.view.state.field(editorInfoField).editor);\n\n    for (const l of linesToToggle) {\n      if (needToUnfold) {\n        editor.unfold(l);\n      } else {\n        editor.fold(l);\n      }\n    }\n  }\n\n  private updateDom() {\n    const cmScroll = this.view.scrollDOM;\n    const cmContent = this.view.contentDOM;\n    const cmContentContainer = cmContent.parentElement;\n    const cmSizer = cmContentContainer.parentElement;\n\n    /**\n     * Obsidian can add additional elements into Content Manager.\n     * The most obvious case is the 'embedded-backlinks' core plugin that adds a menu inside a Content Manager.\n     * We must take heights of all of these elements into account\n     * to be able to calculate the correct size of lines' container.\n     */\n    let cmSizerChildrenSumHeight = 0;\n    for (let i = 0; i < cmSizer.children.length; i++) {\n      cmSizerChildrenSumHeight += cmSizer.children[i].clientHeight;\n    }\n\n    this.scroller.style.top = cmScroll.offsetTop + \"px\";\n    this.contentContainer.style.height = cmSizerChildrenSumHeight + \"px\";\n    this.contentContainer.style.marginLeft =\n      cmContentContainer.offsetLeft + \"px\";\n    this.contentContainer.style.marginTop =\n      (cmContent.firstElementChild as HTMLElement).offsetTop - 24 + \"px\";\n\n    for (let i = 0; i < this.lines.length; i++) {\n      if (this.lineElements.length === i) {\n        const e = document.createElement(\"div\");\n        e.classList.add(\"outliner-plugin-list-line\");\n        e.dataset.index = String(i);\n        e.addEventListener(\"mousedown\", this.onClick);\n        this.contentContainer.appendChild(e);\n        this.lineElements.push(e);\n      }\n\n      const l = this.lines[i];\n      const e = this.lineElements[i];\n      e.style.top = l.top + \"px\";\n      e.style.left = l.left + \"px\";\n      e.style.height = l.height;\n      e.style.display = \"block\";\n    }\n\n    for (let i = this.lines.length; i < this.lineElements.length; i++) {\n      const e = this.lineElements[i];\n      e.style.top = \"0px\";\n      e.style.left = \"0px\";\n      e.style.height = \"0px\";\n      e.style.display = \"none\";\n    }\n  }\n\n  destroy() {\n    this.settings.removeCallback(\"listLines\", this.scheduleRecalculate);\n    this.view.scrollDOM.removeEventListener(\"scroll\", this.onScroll);\n    this.view.dom.removeChild(this.scroller);\n    clearTimeout(this.scheduled);\n  }\n}\n\nexport class LinesFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private obsidian: ObsidianService,\n    private parser: ParserService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      ViewPlugin.define(\n        (view) =>\n          new ListLinesViewPluginValue(\n            this.settings,\n            this.obsidian,\n            this.parser,\n            view\n          )\n      )\n    );\n  }\n\n  async unload() {}\n}\n","import { Feature } from \"./Feature\";\n\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nconst BETTER_LISTS_CLASS = \"outliner-plugin-better-lists\";\nconst BETTER_BULLETS_CLASS = \"outliner-plugin-better-bullets\";\nconst VERTICAL_LINES = \"outliner-plugin-vertical-lines\";\nconst KNOWN_CLASSES = [\n  BETTER_LISTS_CLASS,\n  BETTER_BULLETS_CLASS,\n  VERTICAL_LINES,\n];\n\nexport class ListsStylesFeature implements Feature {\n  private interval: number;\n\n  constructor(\n    private settings: SettingsService,\n    private obsidian: ObsidianService\n  ) {}\n\n  async load() {\n    this.syncListsStyles();\n    this.interval = window.setInterval(() => {\n      this.syncListsStyles();\n    }, 1000);\n  }\n\n  async unload() {\n    clearInterval(this.interval);\n    this.applyListsStyles([]);\n  }\n\n  private syncListsStyles = () => {\n    const classes = [];\n\n    if (this.obsidian.isDefaultThemeEnabled()) {\n      if (this.settings.styleLists) {\n        classes.push(BETTER_LISTS_CLASS);\n        classes.push(BETTER_BULLETS_CLASS);\n      }\n\n      if (this.settings.listLines) {\n        classes.push(VERTICAL_LINES);\n      }\n    }\n\n    this.applyListsStyles(classes);\n  };\n\n  private applyListsStyles(classes: string[]) {\n    const toKeep = classes.filter((c) => KNOWN_CLASSES.contains(c));\n    const toRemove = KNOWN_CLASSES.filter((c) => !toKeep.contains(c));\n\n    for (const c of toKeep) {\n      if (!document.body.classList.contains(c)) {\n        document.body.classList.add(c);\n      }\n    }\n\n    for (const c of toRemove) {\n      if (document.body.classList.contains(c)) {\n        document.body.classList.remove(c);\n      }\n    }\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { ListLine, Position, Root } from \"../root\";\n\nexport class MoveCursorToPreviousUnfoldedLineOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    const list = this.root.getListUnderCursor();\n    const cursor = this.root.getCursor();\n    const lines = list.getLinesInfo();\n    const lineNo = lines.findIndex(\n      (l) =>\n        cursor.ch === l.from.ch + list.getCheckboxLength() &&\n        cursor.line === l.from.line\n    );\n\n    if (lineNo === 0) {\n      this.moveCursorToPreviousUnfoldedItem(root, cursor);\n    } else if (lineNo > 0) {\n      this.moveCursorToPreviousNoteLine(root, lines, lineNo);\n    }\n  }\n\n  private moveCursorToPreviousNoteLine(\n    root: Root,\n    lines: ListLine[],\n    lineNo: number\n  ) {\n    this.stopPropagation = true;\n    this.updated = true;\n\n    root.replaceCursor(lines[lineNo - 1].to);\n  }\n\n  private moveCursorToPreviousUnfoldedItem(root: Root, cursor: Position) {\n    const prev = root.getListUnderLine(cursor.line - 1);\n\n    if (!prev) {\n      return;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    if (prev.isFolded()) {\n      const foldRoot = prev.getTopFoldRoot();\n      const firstLineEnd = foldRoot.getLinesInfo()[0].to;\n      root.replaceCursor(firstLineEnd);\n    } else {\n      root.replaceCursor(prev.getLastLineContentEnd());\n    }\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { keymap } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { MoveCursorToPreviousUnfoldedLineOperation } from \"../operations/MoveCursorToPreviousUnfoldedLineOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class MoveCursorToPreviousUnfoldedLineFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      keymap.of([\n        {\n          key: \"ArrowLeft\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.run,\n          }),\n        },\n        {\n          win: \"c-ArrowLeft\",\n          linux: \"c-ArrowLeft\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.run,\n          }),\n        },\n      ])\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.stickCursor && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new MoveCursorToPreviousUnfoldedLineOperation(root),\n      editor\n    );\n  };\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\n\nexport class MoveDownOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const list = root.getListUnderCursor();\n    const parent = list.getParent();\n    const grandParent = parent.getParent();\n    const next = parent.getNextSiblingOf(list);\n\n    const listStartLineBefore = root.getContentLinesRangeOf(list)[0];\n\n    if (!next && grandParent) {\n      const newParent = grandParent.getNextSiblingOf(parent);\n\n      if (newParent) {\n        this.updated = true;\n        parent.removeChild(list);\n        newParent.addBeforeAll(list);\n      }\n    } else if (next) {\n      this.updated = true;\n      parent.removeChild(list);\n      parent.addAfter(next, list);\n    }\n\n    if (!this.updated) {\n      return;\n    }\n\n    const listStartLineAfter = root.getContentLinesRangeOf(list)[0];\n    const lineDiff = listStartLineAfter - listStartLineBefore;\n\n    const cursor = root.getCursor();\n    root.replaceCursor({\n      line: cursor.line + lineDiff,\n      ch: cursor.ch,\n    });\n\n    recalculateNumericBullets(root);\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\n\nexport class MoveRightOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root, private defaultIndentChars: string) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const list = root.getListUnderCursor();\n    const parent = list.getParent();\n    const prev = parent.getPrevSiblingOf(list);\n\n    if (!prev) {\n      return;\n    }\n\n    this.updated = true;\n\n    const listStartLineBefore = root.getContentLinesRangeOf(list)[0];\n\n    const indentPos = list.getFirstLineIndent().length;\n    let indentChars = \"\";\n\n    if (indentChars === \"\" && !prev.isEmpty()) {\n      indentChars = prev\n        .getChildren()[0]\n        .getFirstLineIndent()\n        .slice(prev.getFirstLineIndent().length);\n    }\n\n    if (indentChars === \"\") {\n      indentChars = list\n        .getFirstLineIndent()\n        .slice(parent.getFirstLineIndent().length);\n    }\n\n    if (indentChars === \"\" && !list.isEmpty()) {\n      indentChars = list.getChildren()[0].getFirstLineIndent();\n    }\n\n    if (indentChars === \"\") {\n      indentChars = this.defaultIndentChars;\n    }\n\n    parent.removeChild(list);\n    prev.addAfterAll(list);\n    list.indentContent(indentPos, indentChars);\n\n    const listStartLineAfter = root.getContentLinesRangeOf(list)[0];\n    const lineDiff = listStartLineAfter - listStartLineBefore;\n\n    const cursor = root.getCursor();\n    root.replaceCursor({\n      line: cursor.line + lineDiff,\n      ch: cursor.ch + indentChars.length,\n    });\n\n    recalculateNumericBullets(root);\n  }\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\nimport { recalculateNumericBullets } from \"../root/recalculateNumericBullets\";\n\nexport class MoveUpOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n\n    const list = root.getListUnderCursor();\n    const parent = list.getParent();\n    const grandParent = parent.getParent();\n    const prev = parent.getPrevSiblingOf(list);\n\n    const listStartLineBefore = root.getContentLinesRangeOf(list)[0];\n\n    if (!prev && grandParent) {\n      const newParent = grandParent.getPrevSiblingOf(parent);\n\n      if (newParent) {\n        this.updated = true;\n        parent.removeChild(list);\n        newParent.addAfterAll(list);\n      }\n    } else if (prev) {\n      this.updated = true;\n      parent.removeChild(list);\n      parent.addBefore(prev, list);\n    }\n\n    if (!this.updated) {\n      return;\n    }\n\n    const listStartLineAfter = root.getContentLinesRangeOf(list)[0];\n    const lineDiff = listStartLineAfter - listStartLineBefore;\n\n    const cursor = root.getCursor();\n    root.replaceCursor({\n      line: cursor.line + lineDiff,\n      ch: cursor.ch,\n    });\n\n    recalculateNumericBullets(root);\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { Prec } from \"@codemirror/state\";\nimport { keymap } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { MoveDownOperation } from \"../operations/MoveDownOperation\";\nimport { MoveLeftOperation } from \"../operations/MoveLeftOperation\";\nimport { MoveRightOperation } from \"../operations/MoveRightOperation\";\nimport { MoveUpOperation } from \"../operations/MoveUpOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class MoveItemsFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private settings: SettingsService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.addCommand({\n      id: \"move-list-item-up\",\n      icon: \"arrow-up\",\n      name: \"Move list and sublists up\",\n      editorCallback: this.obsidian.createEditorCallback(\n        this.moveListElementUpCommand\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\", \"Shift\"],\n          key: \"ArrowUp\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"move-list-item-down\",\n      icon: \"arrow-down\",\n      name: \"Move list and sublists down\",\n      editorCallback: this.obsidian.createEditorCallback(\n        this.moveListElementDownCommand\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\", \"Shift\"],\n          key: \"ArrowDown\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"indent-list\",\n      icon: \"indent\",\n      name: \"Indent the list and sublists\",\n      editorCallback: this.obsidian.createEditorCallback(\n        this.moveListElementRightCommand\n      ),\n      hotkeys: [],\n    });\n\n    this.plugin.addCommand({\n      id: \"outdent-list\",\n      icon: \"outdent\",\n      name: \"Outdent the list and sublists\",\n      editorCallback: this.obsidian.createEditorCallback(\n        this.moveListElementLeftCommand\n      ),\n      hotkeys: [],\n    });\n\n    this.plugin.registerEditorExtension(\n      Prec.highest(\n        keymap.of([\n          {\n            key: \"Tab\",\n            run: this.obsidian.createKeymapRunCallback({\n              check: this.check,\n              run: this.moveListElementRight,\n            }),\n          },\n          {\n            key: \"s-Tab\",\n            run: this.obsidian.createKeymapRunCallback({\n              check: this.check,\n              run: this.moveListElementLeft,\n            }),\n          },\n        ])\n      )\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.betterTab && !this.ime.isIMEOpened();\n  };\n\n  private moveListElementDownCommand = (editor: MyEditor) => {\n    const { shouldStopPropagation } = this.performOperation.performOperation(\n      (root) => new MoveDownOperation(root),\n      editor\n    );\n\n    return shouldStopPropagation;\n  };\n\n  private moveListElementUpCommand = (editor: MyEditor) => {\n    const { shouldStopPropagation } = this.performOperation.performOperation(\n      (root) => new MoveUpOperation(root),\n      editor\n    );\n\n    return shouldStopPropagation;\n  };\n\n  private moveListElementRightCommand = (editor: MyEditor) => {\n    if (this.ime.isIMEOpened()) {\n      return true;\n    }\n\n    return this.moveListElementRight(editor).shouldStopPropagation;\n  };\n\n  private moveListElementRight = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) =>\n        new MoveRightOperation(root, this.obsidian.getDefaultIndentChars()),\n      editor\n    );\n  };\n\n  private moveListElementLeftCommand = (editor: MyEditor) => {\n    if (this.ime.isIMEOpened()) {\n      return true;\n    }\n\n    return this.moveListElementLeft(editor).shouldStopPropagation;\n  };\n\n  private moveListElementLeft = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new MoveLeftOperation(root),\n      editor\n    );\n  };\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root, maxPos, minPos } from \"../root\";\n\nexport class SelectAllOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleSelection()) {\n      return;\n    }\n\n    const selection = root.getSelections()[0];\n    const [rootStart, rootEnd] = root.getRange();\n\n    const selectionFrom = minPos(selection.anchor, selection.head);\n    const selectionTo = maxPos(selection.anchor, selection.head);\n\n    if (\n      selectionFrom.line < rootStart.line ||\n      selectionTo.line > rootEnd.line\n    ) {\n      return false;\n    }\n\n    if (\n      selectionFrom.line === rootStart.line &&\n      selectionFrom.ch === rootStart.ch &&\n      selectionTo.line === rootEnd.line &&\n      selectionTo.ch === rootEnd.ch\n    ) {\n      return false;\n    }\n\n    const list = root.getListUnderCursor();\n    const contentStart = list.getFirstLineContentStart();\n    const contentEnd = list.getLastLineContentEnd();\n\n    if (\n      selectionFrom.line < contentStart.line ||\n      selectionTo.line > contentEnd.line\n    ) {\n      return false;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    if (\n      selectionFrom.line === contentStart.line &&\n      selectionFrom.ch === contentStart.ch &&\n      selectionTo.line === contentEnd.line &&\n      selectionTo.ch === contentEnd.ch\n    ) {\n      // select all list\n      root.replaceSelections([{ anchor: rootStart, head: rootEnd }]);\n    } else {\n      // select all line\n      root.replaceSelections([{ anchor: contentStart, head: contentEnd }]);\n    }\n\n    return true;\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { keymap } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Feature } from \"../features/Feature\";\nimport { SelectAllOperation } from \"../operations/SelectAllOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class SelectAllFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      keymap.of([\n        {\n          key: \"c-a\",\n          mac: \"m-a\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.run,\n          }),\n        },\n      ])\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.selectAll && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new SelectAllOperation(root),\n      editor\n    );\n  };\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class SelectTillLineStartOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    const cursor = root.getCursor();\n    const list = root.getListUnderCursor();\n    const lines = list.getLinesInfo();\n    const lineNo = lines.findIndex((l) => l.from.line === cursor.line);\n\n    root.replaceSelections([{ head: lines[lineNo].from, anchor: cursor }]);\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { keymap } from \"@codemirror/view\";\n\nimport { Feature } from \"./Feature\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { SelectTillLineStartOperation } from \"../operations/SelectTillLineStartOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class SelectionShouldIgnoreBulletsFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private obsidian: ObsidianService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      keymap.of([\n        {\n          key: \"m-s-ArrowLeft\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.run,\n          }),\n        },\n      ])\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.stickCursor && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new SelectTillLineStartOperation(root),\n      editor\n    );\n  };\n}\n","import { App, PluginSettingTab, Plugin_2, Setting } from \"obsidian\";\n\nimport { Feature } from \"./Feature\";\n\nimport { ListLineAction, SettingsService } from \"../services/SettingsService\";\n\nclass ObsidianOutlinerPluginSettingTab extends PluginSettingTab {\n  constructor(app: App, plugin: Plugin_2, private settings: SettingsService) {\n    super(app, plugin);\n  }\n\n  display(): void {\n    const { containerEl } = this;\n\n    containerEl.empty();\n\n    new Setting(containerEl)\n      .setName(\"Improve the style of your lists\")\n      .setDesc(\n        \"Styles are only compatible with built-in Obsidian themes and may not be compatible with other themes.\"\n      )\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.styleLists).onChange(async (value) => {\n          this.settings.styleLists = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Draw vertical indentation lines\")\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.listLines).onChange(async (value) => {\n          this.settings.listLines = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Vertical indentation line click action\")\n      .addDropdown((dropdown) => {\n        dropdown\n          .addOptions({\n            none: \"None\",\n            \"zoom-in\": \"Zoom In\",\n            \"toggle-folding\": \"Toggle Folding\",\n          } as { [key in ListLineAction]: string })\n          .setValue(this.settings.listLineAction)\n          .onChange(async (value) => {\n            this.settings.listLineAction = value as ListLineAction;\n            await this.settings.save();\n          });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Stick the cursor to the content\")\n      .setDesc(\"Don't let the cursor move to the bullet position.\")\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.stickCursor).onChange(async (value) => {\n          this.settings.stickCursor = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Enhance the Enter key\")\n      .setDesc(\"Make the Enter key behave the same as other outliners.\")\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.betterEnter).onChange(async (value) => {\n          this.settings.betterEnter = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Enhance the Tab key\")\n      .setDesc(\"Make Tab and Shift-Tab behave the same as other outliners.\")\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.betterTab).onChange(async (value) => {\n          this.settings.betterTab = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Enhance the Ctrl+A or Cmd+A behavior\")\n      .setDesc(\n        \"Press the hotkey once to select the current list item. Press the hotkey twice to select the entire list.\"\n      )\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.selectAll).onChange(async (value) => {\n          this.settings.selectAll = value;\n          await this.settings.save();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Debug mode\")\n      .setDesc(\n        \"Open DevTools (Command+Option+I or Control+Shift+I) to copy the debug logs.\"\n      )\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.debug).onChange(async (value) => {\n          this.settings.debug = value;\n          await this.settings.save();\n        });\n      });\n  }\n}\n\nexport class SettingsTabFeature implements Feature {\n  constructor(private plugin: Plugin_2, private settings: SettingsService) {}\n\n  async load() {\n    this.plugin.addSettingTab(\n      new ObsidianOutlinerPluginSettingTab(\n        this.plugin.app,\n        this.plugin,\n        this.settings\n      )\n    );\n  }\n\n  async unload() {}\n}\n","import { Operation } from \"./Operation\";\n\nimport { Root } from \"../root\";\n\nexport class CreateNoteLineOperation implements Operation {\n  private stopPropagation = false;\n  private updated = false;\n\n  constructor(private root: Root) {}\n\n  shouldStopPropagation() {\n    return this.stopPropagation;\n  }\n\n  shouldUpdate() {\n    return this.updated;\n  }\n\n  perform() {\n    const { root } = this;\n\n    if (!root.hasSingleCursor()) {\n      return;\n    }\n\n    const cursor = root.getCursor();\n    const list = root.getListUnderCursor();\n    const lineUnderCursor = list\n      .getLinesInfo()\n      .find((l) => l.from.line === cursor.line);\n\n    if (cursor.ch < lineUnderCursor.from.ch) {\n      return;\n    }\n\n    this.stopPropagation = true;\n    this.updated = true;\n\n    if (!list.getNotesIndent()) {\n      list.setNotesIndent(list.getFirstLineIndent() + \"  \");\n    }\n\n    const lines = list.getLinesInfo().reduce((acc, line) => {\n      if (cursor.line === line.from.line) {\n        acc.push(line.text.slice(0, cursor.ch - line.from.ch));\n        acc.push(line.text.slice(cursor.ch - line.from.ch));\n      } else {\n        acc.push(line.text);\n      }\n\n      return acc;\n    }, [] as string[]);\n\n    list.replaceLines(lines);\n\n    root.replaceCursor({\n      line: cursor.line + 1,\n      ch: list.getNotesIndent().length,\n    });\n  }\n}\n","import { Plugin_2 } from \"obsidian\";\n\nimport { keymap } from \"@codemirror/view\";\n\nimport { Feature } from \"./Feature\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { CreateNoteLineOperation } from \"../operations/CreateNoteLineOperation\";\nimport { IMEService } from \"../services/IMEService\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { PerformOperationService } from \"../services/PerformOperationService\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class ShiftEnterShouldCreateNoteFeature implements Feature {\n  constructor(\n    private plugin: Plugin_2,\n    private obsidian: ObsidianService,\n    private settings: SettingsService,\n    private ime: IMEService,\n    private performOperation: PerformOperationService\n  ) {}\n\n  async load() {\n    this.plugin.registerEditorExtension(\n      keymap.of([\n        {\n          key: \"s-Enter\",\n          run: this.obsidian.createKeymapRunCallback({\n            check: this.check,\n            run: this.run,\n          }),\n        },\n      ])\n    );\n  }\n\n  async unload() {}\n\n  private check = () => {\n    return this.settings.betterEnter && !this.ime.isIMEOpened();\n  };\n\n  private run = (editor: MyEditor) => {\n    return this.performOperation.performOperation(\n      (root) => new CreateNoteLineOperation(root),\n      editor\n    );\n  };\n}\n","export interface ApplyChangesEditorPosition {\n  line: number;\n  ch: number;\n}\n\nexport interface ApplyChangesEditorSelection {\n  anchor: ApplyChangesEditorPosition;\n  head: ApplyChangesEditorPosition;\n}\n\nexport interface ApplyChangesEditor {\n  getRange(\n    from: ApplyChangesEditorPosition,\n    to: ApplyChangesEditorPosition\n  ): string;\n  replaceRange(\n    replacement: string,\n    from: ApplyChangesEditorPosition,\n    to: ApplyChangesEditorPosition\n  ): void;\n  setSelections(selections: ApplyChangesEditorSelection[]): void;\n  fold(n: number): void;\n  unfold(n: number): void;\n}\n\nexport interface ApplyChangesList {\n  isFoldRoot(): boolean;\n  getChildren(): ApplyChangesList[];\n  getFirstLineContentStart(): { line: number };\n}\n\nexport interface ApplyChangesRoot {\n  getRange(): [ApplyChangesEditorPosition, ApplyChangesEditorPosition];\n  getSelections(): {\n    anchor: ApplyChangesEditorPosition;\n    head: ApplyChangesEditorPosition;\n  }[];\n  print(): string;\n  getChildren(): ApplyChangesList[];\n}\n\nexport class ApplyChangesService {\n  applyChanges(editor: ApplyChangesEditor, root: ApplyChangesRoot) {\n    const rootRange = root.getRange();\n    const oldString = editor.getRange(rootRange[0], rootRange[1]);\n    const newString = root.print();\n\n    const fromLine = rootRange[0].line;\n    const toLine = rootRange[1].line;\n\n    for (let l = fromLine; l <= toLine; l++) {\n      editor.unfold(l);\n    }\n\n    const changeFrom = { ...rootRange[0] };\n    const changeTo = { ...rootRange[1] };\n    let oldTmp = oldString;\n    let newTmp = newString;\n\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const nlIndex = oldTmp.lastIndexOf(\"\\n\");\n      if (nlIndex < 0) {\n        break;\n      }\n      const oldLine = oldTmp.slice(nlIndex);\n      const newLine = newTmp.slice(-oldLine.length);\n      if (oldLine !== newLine) {\n        break;\n      }\n      oldTmp = oldTmp.slice(0, -oldLine.length);\n      newTmp = newTmp.slice(0, -oldLine.length);\n\n      const nlIndex2 = oldTmp.lastIndexOf(\"\\n\");\n      changeTo.ch =\n        nlIndex2 >= 0 ? oldTmp.length - nlIndex2 - 1 : oldTmp.length;\n      changeTo.line--;\n    }\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const nlIndex = oldTmp.indexOf(\"\\n\");\n      if (nlIndex < 0) {\n        break;\n      }\n      const oldLine = oldTmp.slice(0, nlIndex + 1);\n      const newLine = newTmp.slice(0, oldLine.length);\n      if (oldLine !== newLine) {\n        break;\n      }\n      changeFrom.line++;\n      oldTmp = oldTmp.slice(oldLine.length);\n      newTmp = newTmp.slice(oldLine.length);\n    }\n\n    if (oldTmp !== newTmp) {\n      editor.replaceRange(newTmp, changeFrom, changeTo);\n    }\n\n    editor.setSelections(root.getSelections());\n\n    function recursive(list: ApplyChangesList) {\n      for (const c of list.getChildren()) {\n        recursive(c);\n      }\n      if (list.isFoldRoot()) {\n        editor.fold(list.getFirstLineContentStart().line);\n      }\n    }\n    for (const c of root.getChildren()) {\n      recursive(c);\n    }\n  }\n}\n","import { Platform } from \"obsidian\";\n\nexport class IMEService {\n  private composition = false;\n\n  async load() {\n    document.addEventListener(\"compositionstart\", this.onCompositionStart);\n    document.addEventListener(\"compositionend\", this.onCompositionEnd);\n  }\n\n  async unload() {\n    document.removeEventListener(\"compositionend\", this.onCompositionEnd);\n    document.removeEventListener(\"compositionstart\", this.onCompositionStart);\n  }\n\n  isIMEOpened() {\n    return this.composition && Platform.isDesktop;\n  }\n\n  private onCompositionStart = () => {\n    this.composition = true;\n  };\n\n  private onCompositionEnd = () => {\n    this.composition = false;\n  };\n}\n","import { SettingsService } from \"./SettingsService\";\n\nexport class LoggerService {\n  constructor(private settings: SettingsService) {}\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  log(method: string, ...args: any[]) {\n    if (!this.settings.debug) {\n      return;\n    }\n\n    console.info(method, ...args);\n  }\n\n  bind(method: string) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (...args: any[]) => this.log(method, ...args);\n  }\n}\n","import { App, Editor, editorInfoField } from \"obsidian\";\n\nimport { EditorState } from \"@codemirror/state\";\nimport { EditorView } from \"@codemirror/view\";\n\nimport { MyEditor } from \"../MyEditor\";\n\nexport interface ObsidianTabsSettings {\n  useTab: boolean;\n  tabSize: number;\n}\n\nexport interface ObsidianFoldSettings {\n  foldIndent: boolean;\n}\n\nexport class ObsidianService {\n  constructor(private app: App) {}\n\n  isLegacyEditorEnabled() {\n    const config: { legacyEditor: boolean } = {\n      legacyEditor: false,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ...(this.app.vault as any).config,\n    };\n\n    return config.legacyEditor;\n  }\n\n  isDefaultThemeEnabled() {\n    const config: { cssTheme: string } = {\n      cssTheme: \"\",\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ...(this.app.vault as any).config,\n    };\n\n    return config.cssTheme === \"\";\n  }\n\n  getObsidianTabsSettings(): ObsidianTabsSettings {\n    return {\n      useTab: true,\n      tabSize: 4,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ...(this.app.vault as any).config,\n    };\n  }\n\n  getObsidianFoldSettings(): ObsidianFoldSettings {\n    return {\n      foldIndent: true,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      ...(this.app.vault as any).config,\n    };\n  }\n\n  getDefaultIndentChars() {\n    const { useTab, tabSize } = this.getObsidianTabsSettings();\n\n    return useTab ? \"\\t\" : new Array(tabSize).fill(\" \").join(\"\");\n  }\n\n  getEditorFromState(state: EditorState) {\n    return new MyEditor(state.field(editorInfoField).editor);\n  }\n\n  createKeymapRunCallback(config: {\n    check?: (editor: MyEditor) => boolean;\n    run: (editor: MyEditor) => {\n      shouldUpdate: boolean;\n      shouldStopPropagation: boolean;\n    };\n  }) {\n    const check = config.check || (() => true);\n    const { run } = config;\n\n    return (view: EditorView): boolean => {\n      const editor = this.getEditorFromState(view.state);\n\n      if (!check(editor)) {\n        return false;\n      }\n\n      const { shouldUpdate, shouldStopPropagation } = run(editor);\n\n      return shouldUpdate || shouldStopPropagation;\n    };\n  }\n\n  createEditorCallback(cb: (editor: MyEditor) => boolean) {\n    return (editor: Editor) => {\n      const myEditor = new MyEditor(editor);\n      const shouldStopPropagation = cb(myEditor);\n\n      if (\n        !shouldStopPropagation &&\n        window.event &&\n        window.event.type === \"keydown\"\n      ) {\n        myEditor.triggerOnKeyDown(window.event as KeyboardEvent);\n      }\n    };\n  }\n}\n","import { List, Root } from \"../root\";\nimport { LoggerService } from \"../services/LoggerService\";\n\nconst bulletSign = `(?:[-*+]|\\\\d+\\\\.)`;\nconst optionalCheckbox = `(?:\\\\[[ xX]\\\\]( |\\t))?`;\n\nconst listItemWithoutSpacesRe = new RegExp(`^${bulletSign}( |\\t)`);\nconst listItemRe = new RegExp(`^[ \\t]*${bulletSign}( |\\t)`);\nconst stringWithSpacesRe = new RegExp(`^[ \\t]+`);\nconst parseListItemRe = new RegExp(\n  `^([ \\t]*)(${bulletSign})( |\\t)((${optionalCheckbox}).*)$`\n);\n\nexport interface ReaderPosition {\n  line: number;\n  ch: number;\n}\n\nexport interface ReaderSelection {\n  anchor: ReaderPosition;\n  head: ReaderPosition;\n}\n\nexport interface Reader {\n  getCursor(): ReaderPosition;\n  getLine(n: number): string;\n  lastLine(): number;\n  listSelections(): ReaderSelection[];\n  getAllFoldedLines(): number[];\n}\n\ninterface ParseListList {\n  getFirstLineIndent(): string;\n  setNotesIndent(notesIndent: string): void;\n  getNotesIndent(): string | null;\n  addLine(text: string): void;\n  getParent(): ParseListList | null;\n  addAfterAll(list: ParseListList): void;\n}\n\nexport class ParserService {\n  constructor(private logger: LoggerService) {}\n\n  parseRange(editor: Reader, fromLine = 0, toLine = editor.lastLine()): Root[] {\n    const lists: Root[] = [];\n\n    for (let i = fromLine; i <= toLine; i++) {\n      const line = editor.getLine(i);\n\n      if (i === fromLine || this.isListItem(line)) {\n        const list = this.parseWithLimits(editor, i, fromLine, toLine);\n\n        if (list) {\n          lists.push(list);\n          i = list.getRange()[1].line;\n        }\n      }\n    }\n\n    return lists;\n  }\n\n  parse(editor: Reader, cursor = editor.getCursor()): Root | null {\n    return this.parseWithLimits(editor, cursor.line, 0, editor.lastLine());\n  }\n\n  private parseWithLimits(\n    editor: Reader,\n    parsingStartLine: number,\n    limitFrom: number,\n    limitTo: number\n  ): Root | null {\n    const d = this.logger.bind(\"parseList\");\n    const error = (msg: string): null => {\n      d(msg);\n      return null;\n    };\n\n    const line = editor.getLine(parsingStartLine);\n\n    let listLookingPos: number | null = null;\n\n    if (this.isListItem(line)) {\n      listLookingPos = parsingStartLine;\n    } else if (this.isLineWithIndent(line)) {\n      let listLookingPosSearch = parsingStartLine - 1;\n      while (listLookingPosSearch >= 0) {\n        const line = editor.getLine(listLookingPosSearch);\n        if (this.isListItem(line)) {\n          listLookingPos = listLookingPosSearch;\n          break;\n        } else if (this.isLineWithIndent(line)) {\n          listLookingPosSearch--;\n        } else {\n          break;\n        }\n      }\n    }\n\n    if (listLookingPos == null) {\n      return null;\n    }\n\n    let listStartLine: number | null = null;\n    let listStartLineLookup = listLookingPos;\n    while (listStartLineLookup >= 0) {\n      const line = editor.getLine(listStartLineLookup);\n      if (!this.isListItem(line) && !this.isLineWithIndent(line)) {\n        break;\n      }\n      if (this.isListItemWithoutSpaces(line)) {\n        listStartLine = listStartLineLookup;\n        if (listStartLineLookup <= limitFrom) {\n          break;\n        }\n      }\n      listStartLineLookup--;\n    }\n\n    if (listStartLine === null) {\n      return null;\n    }\n\n    let listEndLine = listLookingPos;\n    let listEndLineLookup = listLookingPos;\n    while (listEndLineLookup <= editor.lastLine()) {\n      const line = editor.getLine(listEndLineLookup);\n      if (!this.isListItem(line) && !this.isLineWithIndent(line)) {\n        break;\n      }\n      if (!this.isEmptyLine(line)) {\n        listEndLine = listEndLineLookup;\n      }\n      if (listEndLineLookup >= limitTo) {\n        listEndLine = limitTo;\n        break;\n      }\n      listEndLineLookup++;\n    }\n\n    if (listStartLine > parsingStartLine || listEndLine < parsingStartLine) {\n      return null;\n    }\n\n    const root = new Root(\n      { line: listStartLine, ch: 0 },\n      { line: listEndLine, ch: editor.getLine(listEndLine).length },\n      editor.listSelections().map((r) => ({\n        anchor: { line: r.anchor.line, ch: r.anchor.ch },\n        head: { line: r.head.line, ch: r.head.ch },\n      }))\n    );\n\n    let currentParent: ParseListList = root.getRootList();\n    let currentList: ParseListList | null = null;\n    let currentIndent = \"\";\n\n    const foldedLines = editor.getAllFoldedLines();\n\n    for (let l = listStartLine; l <= listEndLine; l++) {\n      const line = editor.getLine(l);\n      const matches = parseListItemRe.exec(line);\n\n      if (matches) {\n        const [, indent, bullet, spaceAfterBullet, content, optionalCheckbox] =\n          matches;\n\n        const compareLength = Math.min(currentIndent.length, indent.length);\n        const indentSlice = indent.slice(0, compareLength);\n        const currentIndentSlice = currentIndent.slice(0, compareLength);\n\n        if (indentSlice !== currentIndentSlice) {\n          const expected = currentIndentSlice\n            .replace(/ /g, \"S\")\n            .replace(/\\t/g, \"T\");\n          const got = indentSlice.replace(/ /g, \"S\").replace(/\\t/g, \"T\");\n\n          return error(\n            `Unable to parse list: expected indent \"${expected}\", got \"${got}\"`\n          );\n        }\n\n        if (indent.length > currentIndent.length) {\n          currentParent = currentList;\n          currentIndent = indent;\n        } else if (indent.length < currentIndent.length) {\n          while (\n            currentParent.getFirstLineIndent().length >= indent.length &&\n            currentParent.getParent()\n          ) {\n            currentParent = currentParent.getParent();\n          }\n          currentIndent = indent;\n        }\n\n        const foldRoot = foldedLines.includes(l);\n\n        currentList = new List(\n          root,\n          indent,\n          bullet,\n          optionalCheckbox.length,\n          spaceAfterBullet,\n          content,\n          foldRoot\n        );\n        currentParent.addAfterAll(currentList);\n      } else if (this.isLineWithIndent(line)) {\n        if (!currentList) {\n          return error(\n            `Unable to parse list: expected list item, got empty line`\n          );\n        }\n\n        const indentToCheck = currentList.getNotesIndent() || currentIndent;\n\n        if (line.indexOf(indentToCheck) !== 0) {\n          const expected = indentToCheck.replace(/ /g, \"S\").replace(/\\t/g, \"T\");\n          const got = line\n            .match(/^[ \\t]*/)[0]\n            .replace(/ /g, \"S\")\n            .replace(/\\t/g, \"T\");\n\n          return error(\n            `Unable to parse list: expected indent \"${expected}\", got \"${got}\"`\n          );\n        }\n\n        if (!currentList.getNotesIndent()) {\n          const matches = line.match(/^[ \\t]+/);\n\n          if (!matches || matches[0].length <= currentIndent.length) {\n            if (/^\\s+$/.test(line)) {\n              continue;\n            }\n\n            return error(\n              `Unable to parse list: expected some indent, got no indent`\n            );\n          }\n\n          currentList.setNotesIndent(matches[0]);\n        }\n\n        currentList.addLine(line.slice(currentList.getNotesIndent().length));\n      } else {\n        return error(\n          `Unable to parse list: expected list item or note, got \"${line}\"`\n        );\n      }\n    }\n\n    return root;\n  }\n\n  private isEmptyLine(line: string) {\n    return line.length === 0;\n  }\n\n  private isLineWithIndent(line: string) {\n    return stringWithSpacesRe.test(line);\n  }\n\n  private isListItem(line: string) {\n    return listItemRe.test(line);\n  }\n\n  private isListItemWithoutSpaces(line: string) {\n    return listItemWithoutSpacesRe.test(line);\n  }\n}\n","import { ApplyChangesService } from \"./ApplyChangesService\";\nimport { ParserService } from \"./ParserService\";\n\nimport { MyEditor } from \"../MyEditor\";\nimport { Operation } from \"../operations/Operation\";\nimport { Root } from \"../root\";\n\nexport class PerformOperationService {\n  constructor(\n    private parser: ParserService,\n    private applyChanges: ApplyChangesService\n  ) {}\n\n  evalOperation(root: Root, op: Operation, editor: MyEditor) {\n    op.perform();\n\n    if (op.shouldUpdate()) {\n      this.applyChanges.applyChanges(editor, root);\n    }\n\n    return {\n      shouldUpdate: op.shouldUpdate(),\n      shouldStopPropagation: op.shouldStopPropagation(),\n    };\n  }\n\n  performOperation(\n    cb: (root: Root) => Operation,\n    editor: MyEditor,\n    cursor = editor.getCursor()\n  ) {\n    const root = this.parser.parse(editor, cursor);\n\n    if (!root) {\n      return { shouldUpdate: false, shouldStopPropagation: false };\n    }\n\n    const op = cb(root);\n\n    return this.evalOperation(root, op, editor);\n  }\n}\n","export type ListLineAction = \"none\" | \"zoom-in\" | \"toggle-folding\";\n\nexport interface ObsidianOutlinerPluginSettings {\n  styleLists: boolean;\n  debug: boolean;\n  stickCursor: boolean;\n  betterEnter: boolean;\n  betterTab: boolean;\n  selectAll: boolean;\n  listLines: boolean;\n  listLineAction: ListLineAction;\n}\n\nconst DEFAULT_SETTINGS: ObsidianOutlinerPluginSettings = {\n  styleLists: true,\n  debug: false,\n  stickCursor: true,\n  betterEnter: true,\n  betterTab: true,\n  selectAll: true,\n  listLines: false,\n  listLineAction: \"toggle-folding\",\n};\n\nexport interface Storage {\n  loadData(): Promise<ObsidianOutlinerPluginSettings>;\n  saveData(settigns: ObsidianOutlinerPluginSettings): Promise<void>;\n}\n\ntype K = keyof ObsidianOutlinerPluginSettings;\ntype Callback<T extends K> = (cb: ObsidianOutlinerPluginSettings[T]) => void;\n\nexport class SettingsService implements ObsidianOutlinerPluginSettings {\n  private storage: Storage;\n  private values: ObsidianOutlinerPluginSettings;\n  private handlers: Map<K, Set<Callback<K>>>;\n\n  constructor(storage: Storage) {\n    this.storage = storage;\n    this.handlers = new Map();\n  }\n\n  get styleLists() {\n    return this.values.styleLists;\n  }\n  set styleLists(value: boolean) {\n    this.set(\"styleLists\", value);\n  }\n\n  get debug() {\n    return this.values.debug;\n  }\n  set debug(value: boolean) {\n    this.set(\"debug\", value);\n  }\n\n  get stickCursor() {\n    return this.values.stickCursor;\n  }\n  set stickCursor(value: boolean) {\n    this.set(\"stickCursor\", value);\n  }\n\n  get betterEnter() {\n    return this.values.betterEnter;\n  }\n  set betterEnter(value: boolean) {\n    this.set(\"betterEnter\", value);\n  }\n\n  get betterTab() {\n    return this.values.betterTab;\n  }\n  set betterTab(value: boolean) {\n    this.set(\"betterTab\", value);\n  }\n\n  get selectAll() {\n    return this.values.selectAll;\n  }\n  set selectAll(value: boolean) {\n    this.set(\"selectAll\", value);\n  }\n\n  get listLines() {\n    return this.values.listLines;\n  }\n  set listLines(value: boolean) {\n    this.set(\"listLines\", value);\n  }\n\n  get listLineAction() {\n    return this.values.listLineAction;\n  }\n  set listLineAction(value: ListLineAction) {\n    this.set(\"listLineAction\", value);\n  }\n\n  onChange<T extends K>(key: T, cb: Callback<T>) {\n    if (!this.handlers.has(key)) {\n      this.handlers.set(key, new Set());\n    }\n\n    this.handlers.get(key).add(cb);\n  }\n\n  removeCallback<T extends K>(key: T, cb: Callback<T>): void {\n    const handlers = this.handlers.get(key);\n\n    if (handlers) {\n      handlers.delete(cb);\n    }\n  }\n\n  reset() {\n    for (const [k, v] of Object.entries(DEFAULT_SETTINGS)) {\n      this.set(k as keyof ObsidianOutlinerPluginSettings, v);\n    }\n  }\n\n  async load() {\n    this.values = Object.assign(\n      {},\n      DEFAULT_SETTINGS,\n      await this.storage.loadData()\n    );\n  }\n\n  async save() {\n    await this.storage.saveData(this.values);\n  }\n\n  set<T extends K>(key: T, value: ObsidianOutlinerPluginSettings[T]): void {\n    this.values[key] = value;\n    const callbacks = this.handlers.get(key);\n\n    if (!callbacks) {\n      return;\n    }\n\n    for (const cb of callbacks.values()) {\n      cb(value);\n    }\n  }\n}\n","import { Plugin } from \"obsidian\";\n\nimport { DeleteShouldIgnoreBulletsFeature } from \"./features/DeleteShouldIgnoreBulletsFeature\";\nimport { EnsureCursorInListContentFeature } from \"./features/EnsureCursorInListContentFeature\";\nimport { EnterOutdentIfLineIsEmptyFeature } from \"./features/EnterOutdentIfLineIsEmptyFeature\";\nimport { EnterShouldCreateNewItemFeature } from \"./features/EnterShouldCreateNewItemOnChildLevelFeature\";\nimport { Feature } from \"./features/Feature\";\nimport { FoldFeature } from \"./features/FoldFeature\";\nimport { LinesFeature } from \"./features/LinesFeature\";\nimport { ListsStylesFeature } from \"./features/ListsStylesFeature\";\nimport { MoveCursorToPreviousUnfoldedLineFeature } from \"./features/MoveCursorToPreviousUnfoldedLineFeature\";\nimport { MoveItemsFeature } from \"./features/MoveItemsFeature\";\nimport { SelectAllFeature } from \"./features/SelectAllFeature\";\nimport { SelectionShouldIgnoreBulletsFeature } from \"./features/SelectionShouldIgnoreBulletsFeature\";\nimport { SettingsTabFeature } from \"./features/SettingsTabFeature\";\nimport { ShiftEnterShouldCreateNoteFeature } from \"./features/ShiftEnterShouldCreateNoteFeature\";\nimport { ApplyChangesService } from \"./services/ApplyChangesService\";\nimport { IMEService } from \"./services/IMEService\";\nimport { LoggerService } from \"./services/LoggerService\";\nimport { ObsidianService } from \"./services/ObsidianService\";\nimport { ParserService } from \"./services/ParserService\";\nimport { PerformOperationService } from \"./services/PerformOperationService\";\nimport { SettingsService } from \"./services/SettingsService\";\n\nexport default class ObsidianOutlinerPlugin extends Plugin {\n  private features: Feature[];\n  protected settings: SettingsService;\n  private logger: LoggerService;\n  private obsidian: ObsidianService;\n  private parser: ParserService;\n  private applyChanges: ApplyChangesService;\n  private performOperation: PerformOperationService;\n  private ime: IMEService;\n\n  async onload() {\n    console.log(`Loading obsidian-outliner`);\n\n    this.obsidian = new ObsidianService(this.app);\n\n    this.settings = new SettingsService(this);\n    await this.settings.load();\n\n    this.logger = new LoggerService(this.settings);\n\n    this.parser = new ParserService(this.logger);\n    this.applyChanges = new ApplyChangesService();\n    this.performOperation = new PerformOperationService(\n      this.parser,\n      this.applyChanges\n    );\n\n    this.ime = new IMEService();\n    await this.ime.load();\n\n    this.features = [\n      new SettingsTabFeature(this, this.settings),\n      new ListsStylesFeature(this.settings, this.obsidian),\n      new EnterOutdentIfLineIsEmptyFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new EnterShouldCreateNewItemFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new EnsureCursorInListContentFeature(\n        this,\n        this.settings,\n        this.obsidian,\n        this.performOperation\n      ),\n      new MoveCursorToPreviousUnfoldedLineFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new DeleteShouldIgnoreBulletsFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new SelectionShouldIgnoreBulletsFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new FoldFeature(this, this.obsidian),\n      new SelectAllFeature(\n        this,\n        this.settings,\n        this.ime,\n        this.obsidian,\n        this.performOperation\n      ),\n      new MoveItemsFeature(\n        this,\n        this.ime,\n        this.obsidian,\n        this.settings,\n        this.performOperation\n      ),\n      new ShiftEnterShouldCreateNoteFeature(\n        this,\n        this.obsidian,\n        this.settings,\n        this.ime,\n        this.performOperation\n      ),\n      new LinesFeature(this, this.settings, this.obsidian, this.parser),\n    ];\n\n    for (const feature of this.features) {\n      await feature.load();\n    }\n  }\n\n  async onunload() {\n    console.log(`Unloading obsidian-outliner`);\n\n    await this.ime.unload();\n\n    for (const feature of this.features) {\n      await feature.unload();\n    }\n  }\n}\n"],"names":["keymap","EditorState","Prec","Notice","foldedRanges","foldable","foldEffect","unfoldEffect","runScopeHandlers","obsidian","editorInfoField","ViewPlugin","PluginSettingTab","Setting","Platform","Plugin"],"mappings":"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"}