notes/notes/.obsidian/plugins/obsidian-outliner/main.js

'use strict';

var obsidian = require('obsidian');

/*! *****************************************************************************
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());
    });
}

const DEFAULT_SETTINGS = {
    styleLists: false,
    debug: false,
    stickCursor: true,
    betterEnter: true,
    selectAll: true,
    disableZoomNotification: false,
    hideWarning: false,
};
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 selectAll() {
        return this.values.selectAll;
    }
    set selectAll(value) {
        this.set("selectAll", value);
    }
    get disableZoomNotification() {
        return this.values.disableZoomNotification;
    }
    set disableZoomNotification(value) {
        this.set("disableZoomNotification", value);
    }
    get hideWarning() {
        return this.values.hideWarning;
    }
    set hideWarning(value) {
        this.set("hideWarning", 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 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. Styles only work well with spaces or four-space tabs.")
            .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("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 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("Disable notification about Obsidian Zoom plugin")
            .addToggle((toggle) => {
            toggle
                .setValue(this.settings.disableZoomNotification)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.disableZoomNotification = value;
                yield this.settings.save();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Hide the warning about four-space tabs")
            .addToggle((toggle) => {
            toggle.setValue(this.settings.hideWarning).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.settings.hideWarning = 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 ObsidianService {
    constructor(app) {
        this.app = app;
    }
    getObsidianTabsSettigns() {
        return Object.assign({ useTab: true, tabSize: 4 }, this.app.vault.config);
    }
    getObsidianFoldSettigns() {
        return Object.assign({ foldIndent: false }, this.app.vault.config);
    }
    getActiveLeafDisplayText() {
        return this.app.workspace.activeLeaf.getDisplayText();
    }
    createCommandCallback(cb) {
        return () => {
            const view = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);
            if (!view) {
                return;
            }
            const editor = view.sourceMode.cmEditor;
            const shouldStopPropagation = cb(editor);
            if (!shouldStopPropagation &&
                window.event &&
                window.event.type === "keydown") {
                editor.triggerOnKeyDown(window.event);
            }
        };
    }
}

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, firstLine, folded) {
        this.root = root;
        this.indent = indent;
        this.bullet = bullet;
        this.folded = folded;
        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.folded) {
            return true;
        }
        if (this.parent) {
            return this.parent.isFolded();
        }
        return false;
    }
    isFoldRoot() {
        let parent = this.getParent();
        while (parent) {
            if (parent.folded) {
                return false;
            }
            parent = parent.getParent();
        }
        return this.folded;
    }
    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;
    }
    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.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, "", "", "", 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;
    }
    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$/, "");
    }
}

const bulletSign = `(?:[-*+]|\\d+\\.)`;
const listItemWithoutSpacesRe = new RegExp(`^${bulletSign} `);
const listItemRe = new RegExp(`^[ \t]*${bulletSign} `);
const stringWithSpacesRe = new RegExp(`^[ \t]+`);
const parseListItemRe = new RegExp(`^([ \t]*)(${bulletSign}) (.*)$`);
class ListsService {
    constructor(loggerService, obsidianService) {
        this.loggerService = loggerService;
        this.obsidianService = obsidianService;
    }
    evalOperation(root, op, editor) {
        op.perform();
        if (op.shouldUpdate()) {
            this.applyChanges(editor, root);
        }
        return {
            shouldUpdate: op.shouldUpdate(),
            shouldStopPropagation: op.shouldStopPropagation(),
        };
    }
    performOperation(cb, editor, cursor = editor.getCursor()) {
        const root = this.parseList(editor, cursor);
        if (!root) {
            return { shouldUpdate: false, shouldStopPropagation: false };
        }
        const op = cb(root);
        return this.evalOperation(root, op, editor);
    }
    parseList(editor, cursor = editor.getCursor()) {
        const d = this.loggerService.bind("parseList");
        const error = (msg) => {
            d(msg);
            return null;
        };
        const line = editor.getLine(cursor.line);
        let listLookingPos = null;
        if (this.isListItem(line)) {
            listLookingPos = cursor.line;
        }
        else if (this.isLineWithIndent(line)) {
            let listLookingPosSearch = cursor.line - 1;
            while (listLookingPosSearch >= editor.firstLine()) {
                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 >= editor.firstLine()) {
            const line = editor.getLine(listStartLineLookup);
            if (!this.isListItem(line) && !this.isLineWithIndent(line)) {
                break;
            }
            if (this.isListItemWithoutSpaces(line)) {
                listStartLine = listStartLineLookup;
            }
            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;
            }
            listEndLineLookup++;
        }
        if (listStartLine > cursor.line || listEndLine < cursor.line) {
            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 = "";
        for (let l = listStartLine; l <= listEndLine; l++) {
            const line = editor.getLine(l);
            const matches = parseListItemRe.exec(line);
            if (matches) {
                const [_, indent, bullet, content] = 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 folded = !!editor.isFolded({
                    line: Math.min(l + 1, listEndLine),
                    ch: 0,
                });
                currentList = new List(root, indent, bullet, content, folded);
                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) {
                        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;
    }
    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.foldCode(l, null, "unfold");
        }
        let changeFrom = Object.assign({}, rootRange[0]);
        let changeTo = Object.assign({}, rootRange[1]);
        let oldTmp = oldString;
        let newTmp = newString;
        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);
        }
        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--;
        }
        if (oldTmp !== newTmp) {
            editor.replaceRange(newTmp, changeFrom, changeTo);
        }
        editor.setSelections(root.getSelections());
        // TODO: lines could be different because of deletetion
        for (let l = fromLine; l <= toLine; l++) {
            const line = root.getListUnderLine(l);
            if (line && line.isFoldRoot()) {
                editor.foldCode(l);
            }
        }
    }
    getDefaultIndentChars() {
        const { useTab, tabSize } = this.obsidianService.getObsidianTabsSettigns();
        return useTab ? "\t" : new Array(tabSize).fill(" ").join("");
    }
    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 LoggerService {
    constructor(settingsService) {
        this.settingsService = settingsService;
    }
    log(method, ...args) {
        if (!this.settingsService.debug) {
            return;
        }
        console.info(method, ...args);
    }
    bind(method) {
        return (...args) => this.log(method, ...args);
    }
}

const STATUS_BAR_TEXT = `Outliner styles only work with four-space tabs. Please check Obsidian settings.`;
class ListsStylesFeature {
    constructor(plugin, settingsService, obsidianService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.obsidianService = obsidianService;
        this.onStyleListsSettingChange = (styleLists) => {
            if (styleLists) {
                this.addListsStyles();
            }
            else {
                this.removeListsStyles();
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.settingsService.styleLists) {
                this.addListsStyles();
            }
            this.settingsService.onChange("styleLists", this.onStyleListsSettingChange);
            this.addStatusBarText();
            this.startStatusBarInterval();
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            clearInterval(this.interval);
            if (this.statusBarText.parentElement) {
                this.statusBarText.parentElement.removeChild(this.statusBarText);
            }
            this.settingsService.removeCallback("styleLists", this.onStyleListsSettingChange);
            this.removeListsStyles();
        });
    }
    startStatusBarInterval() {
        let visible = false;
        this.interval = window.setInterval(() => {
            const { useTab, tabSize } = this.obsidianService.getObsidianTabsSettigns();
            const shouldBeVisible = this.settingsService.styleLists &&
                !(useTab && tabSize === 4) &&
                !this.settingsService.hideWarning;
            if (shouldBeVisible && !visible) {
                this.statusBarText.style.display = "block";
                visible = true;
            }
            else if (!shouldBeVisible && visible) {
                this.statusBarText.style.display = "none";
                visible = false;
            }
        }, 1000);
    }
    addStatusBarText() {
        this.statusBarText = this.plugin.addStatusBarItem();
        this.statusBarText.style.color = "red";
        this.statusBarText.style.display = "none";
        this.statusBarText.setText(STATUS_BAR_TEXT);
    }
    addListsStyles() {
        document.body.classList.add("outliner-plugin-bls");
    }
    removeListsStyles() {
        document.body.classList.remove("outliner-plugin-bls");
    }
}

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 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();
    }
}

function isEnter$1(e) {
    return ((e.keyCode === 13 || e.code === "Enter") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
class EnterOutdentIfLineIsEmptyFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, e) => {
            if (!this.settingsService.betterEnter ||
                !isEnter$1(e) ||
                this.imeService.isIMEOpened()) {
                return;
            }
            const { shouldStopPropagation } = this.listsService.performOperation((root) => new OutdentIfLineIsEmptyOperation(root), cm);
            if (shouldStopPropagation) {
                e.preventDefault();
                e.stopPropagation();
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

class CreateNewItemOperation {
    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 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 a = line.text.slice(0, cursor.ch - line.from.ch);
                const b = line.text.slice(cursor.ch - line.from.ch);
                acc.oldLines.push(a);
                acc.newLines.push(b);
            }
            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 endPos = list.getLastLineContentEnd();
        const onChildLevel = !list.isEmpty() && cursor.line === endPos.line && cursor.ch === endPos.ch;
        const indent = onChildLevel
            ? list.getChildren()[0].getFirstLineIndent()
            : list.getFirstLineIndent();
        const bullet = onChildLevel
            ? list.getChildren()[0].getBullet()
            : list.getBullet();
        const prefix = oldLines[0].match(/^\[[ x]\]/) ? "[ ] " : "";
        const newList = new List(list.getRoot(), indent, bullet, 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 {
            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);
    }
}

function isEnter(e) {
    return ((e.keyCode === 13 || e.code === "Enter") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
class EnterShouldCreateNewItemFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, e) => {
            if (!this.settingsService.betterEnter ||
                !isEnter(e) ||
                this.imeService.isIMEOpened()) {
                return;
            }
            const { shouldStopPropagation } = this.listsService.performOperation((root) => new CreateNewItemOperation(root), cm);
            if (shouldStopPropagation) {
                e.preventDefault();
                e.stopPropagation();
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

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 && 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()) {
            let foldRoot = prev;
            while (!foldRoot.isFoldRoot()) {
                foldRoot = foldRoot.getParent();
            }
            const firstLineEnd = foldRoot.getLinesInfo()[0].to;
            root.replaceCursor(firstLineEnd);
        }
        else {
            root.replaceCursor(prev.getLastLineContentEnd());
        }
    }
}

function isArrowLeft(e) {
    return ((e.keyCode === 37 || e.code === "ArrowLeft") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
function isCtrlArrowLeft(e) {
    return ((e.keyCode === 37 || e.code === "ArrowLeft") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === true);
}
class MoveCursorToPreviousUnfoldedLineFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, event) => {
            if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {
                return;
            }
            if (isArrowLeft(event) || (!obsidian.Platform.isMacOS && isCtrlArrowLeft(event))) {
                const { shouldStopPropagation } = this.listsService.performOperation((root) => new MoveCursorToPreviousUnfoldedLineOperation(root), cm);
                if (shouldStopPropagation) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

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.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;
        }
        let foldRoot = list;
        while (!foldRoot.isFoldRoot()) {
            foldRoot = foldRoot.getParent();
        }
        const firstLineEnd = foldRoot.getLinesInfo()[0].to;
        if (cursor.line > firstLineEnd.line) {
            this.updated = true;
            root.replaceCursor(firstLineEnd);
        }
    }
}

class EnsureCursorInListContentFeature {
    constructor(plugin, settingsService, listsService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.handleCursorActivity = (cm) => {
            if (!this.settingsService.stickCursor) {
                return;
            }
            this.listsService.performOperation((root) => new EnsureCursorIsInUnfoldedLineOperation(root), cm);
            this.listsService.performOperation((root) => new EnsureCursorInListContentOperation(root), cm);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("cursorActivity", this.handleCursorActivity);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("cursorActivity", this.handleCursorActivity);
            });
        });
    }
}

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);
            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);
    }
}

function isBackspace(e) {
    return ((e.keyCode === 8 || e.code === "Backspace") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
function isCmdBackspace(e) {
    return ((e.keyCode === 8 || e.code === "Backspace") &&
        e.shiftKey === false &&
        e.metaKey === true &&
        e.altKey === false &&
        e.ctrlKey === false);
}
function isDelete(e) {
    return ((e.keyCode === 46 || e.code === "Delete") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
class DeleteShouldIgnoreBulletsFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, event) => {
            if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {
                return;
            }
            if (isBackspace(event)) {
                const { shouldStopPropagation } = this.listsService.performOperation((root) => new DeleteAndMergeWithPreviousLineOperation(root), cm);
                if (shouldStopPropagation) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            }
            if (obsidian.Platform.isMacOS && isCmdBackspace(event)) {
                const { shouldStopPropagation } = this.listsService.performOperation((root) => new DeleteTillLineStartOperation(root), cm);
                if (shouldStopPropagation) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            }
            if (isDelete(event)) {
                const { shouldStopPropagation } = this.listsService.performOperation((root) => new DeleteAndMergeWithNextLineOperation(root), cm);
                if (shouldStopPropagation) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

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 }]);
    }
}

function isCmdShiftLeft(e) {
    return ((e.keyCode === 37 || e.code === "ArrowLeft") &&
        e.shiftKey === true &&
        e.metaKey === true &&
        e.altKey === false &&
        e.ctrlKey === false);
}
class SelectionShouldIgnoreBulletsFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, event) => {
            if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {
                return;
            }
            if (obsidian.Platform.isMacOS && isCmdShiftLeft(event)) {
                const { shouldStopPropagation } = this.listsService.performOperation((root) => new SelectTillLineStartOperation(root), cm);
                if (shouldStopPropagation) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

function isCmdDotOrCmdShiftDot(e) {
    return ((e.keyCode === 190 || e.code === "Period") &&
        e.metaKey === true &&
        e.altKey === false &&
        e.ctrlKey === false);
}
function isCtrlDotOrCtrlShiftDot(e) {
    return ((e.keyCode === 190 || e.code === "Period") &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === true);
}
function isModDotOrModShiftDot(e) {
    return obsidian.Platform.isMacOS
        ? isCmdDotOrCmdShiftDot(e)
        : isCtrlDotOrCtrlShiftDot(e);
}
class ZoomFeature {
    constructor(plugin, settingsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, e) => {
            if (window.ObsidianZoomPlugin ||
                this.settingsService.disableZoomNotification ||
                !isModDotOrModShiftDot(e) ||
                this.imeService.isIMEOpened()) {
                return;
            }
            new obsidian.Notice(`Zooming support has been removed from the Obsidian Outliner plugin. Please install the Obsidian Zoom plugin.`, 5000);
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

class FoldFeature {
    constructor(plugin, obsidianService) {
        this.plugin = plugin;
        this.obsidianService = obsidianService;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.addCommand({
                id: "fold",
                name: "Fold the list",
                callback: this.obsidianService.createCommandCallback(this.fold.bind(this)),
                hotkeys: [
                    {
                        modifiers: ["Mod"],
                        key: "ArrowUp",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "unfold",
                name: "Unfold the list",
                callback: this.obsidianService.createCommandCallback(this.unfold.bind(this)),
                hotkeys: [
                    {
                        modifiers: ["Mod"],
                        key: "ArrowDown",
                    },
                ],
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
    setFold(editor, type) {
        if (!this.obsidianService.getObsidianFoldSettigns().foldIndent) {
            new obsidian.Notice(`Unable to ${type} because folding is disabled. Please enable "Fold indent" in Obsidian settings.`, 5000);
            return true;
        }
        editor.foldCode(editor.getCursor(), null, type);
        return true;
    }
    fold(editor) {
        return this.setFold(editor, "fold");
    }
    unfold(editor) {
        return this.setFold(editor, "unfold");
    }
}

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;
    }
}

function isCmdA(e) {
    return ((e.keyCode === 65 || e.code === "KeyA") &&
        e.shiftKey === false &&
        e.metaKey === true &&
        e.altKey === false &&
        e.ctrlKey === false);
}
function isCtrlA(e) {
    return ((e.keyCode === 65 || e.code === "KeyA") &&
        e.shiftKey === false &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === true);
}
function isSelectAll(e) {
    return obsidian.Platform.isMacOS ? isCmdA(e) : isCtrlA(e);
}
class SelectAllFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, event) => {
            if (!this.settingsService.selectAll ||
                !isSelectAll(event) ||
                this.imeService.isIMEOpened()) {
                return;
            }
            const { shouldStopPropagation } = this.listsService.performOperation((root) => new SelectAllOperation(root), cm);
            if (shouldStopPropagation) {
                event.preventDefault();
                event.stopPropagation();
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

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 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 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, obsidianService, listsService, imeService) {
        this.plugin = plugin;
        this.obsidianService = obsidianService;
        this.listsService = listsService;
        this.imeService = imeService;
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.addCommand({
                id: "move-list-item-up",
                name: "Move list and sublists up",
                callback: this.obsidianService.createCommandCallback(this.moveListElementUp.bind(this)),
                hotkeys: [
                    {
                        modifiers: ["Mod", "Shift"],
                        key: "ArrowUp",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "move-list-item-down",
                name: "Move list and sublists down",
                callback: this.obsidianService.createCommandCallback(this.moveListElementDown.bind(this)),
                hotkeys: [
                    {
                        modifiers: ["Mod", "Shift"],
                        key: "ArrowDown",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "indent-list",
                name: "Indent the list and sublists",
                callback: this.obsidianService.createCommandCallback(this.moveListElementRight.bind(this)),
                hotkeys: [
                    {
                        modifiers: [],
                        key: "Tab",
                    },
                ],
            });
            this.plugin.addCommand({
                id: "outdent-list",
                name: "Outdent the list and sublists",
                callback: this.obsidianService.createCommandCallback(this.moveListElementLeft.bind(this)),
                hotkeys: [
                    {
                        modifiers: ["Shift"],
                        key: "Tab",
                    },
                ],
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () { });
    }
    moveListElementDown(editor) {
        const { shouldStopPropagation } = this.listsService.performOperation((root) => new MoveDownOperation(root), editor);
        return shouldStopPropagation;
    }
    moveListElementUp(editor) {
        const { shouldStopPropagation } = this.listsService.performOperation((root) => new MoveUpOperation(root), editor);
        return shouldStopPropagation;
    }
    moveListElementRight(editor) {
        if (this.imeService.isIMEOpened()) {
            return true;
        }
        const { shouldStopPropagation } = this.listsService.performOperation((root) => new MoveRightOperation(root, this.listsService.getDefaultIndentChars()), editor);
        return shouldStopPropagation;
    }
    moveListElementLeft(editor) {
        if (this.imeService.isIMEOpened()) {
            return true;
        }
        const { shouldStopPropagation } = this.listsService.performOperation((root) => new MoveLeftOperation(root), editor);
        return shouldStopPropagation;
    }
}

class CreateNoteLineOperation {
    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;
        }
        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()) {
            const indent = list.isEmpty()
                ? list.getFirstLineIndent() + this.defaultIndentChars
                : list.getChildren()[0].getFirstLineIndent();
            list.setNotesIndent(indent);
        }
        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,
        });
    }
}

function isShiftEnter(e) {
    return ((e.keyCode === 13 || e.code === "Enter") &&
        e.shiftKey === true &&
        e.metaKey === false &&
        e.altKey === false &&
        e.ctrlKey === false);
}
class ShiftEnterShouldCreateNoteFeature {
    constructor(plugin, settingsService, listsService, imeService) {
        this.plugin = plugin;
        this.settingsService = settingsService;
        this.listsService = listsService;
        this.imeService = imeService;
        this.onKeyDown = (cm, e) => {
            if (!this.settingsService.betterEnter ||
                !isShiftEnter(e) ||
                this.imeService.isIMEOpened()) {
                return;
            }
            const { shouldStopPropagation } = this.listsService.performOperation((root) => new CreateNoteLineOperation(root, this.listsService.getDefaultIndentChars()), cm);
            if (shouldStopPropagation) {
                e.preventDefault();
                e.stopPropagation();
            }
        };
    }
    load() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.registerCodeMirror((cm) => {
                cm.on("keydown", this.onKeyDown);
            });
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.plugin.app.workspace.iterateCodeMirrors((cm) => {
                cm.off("keydown", this.onKeyDown);
            });
        });
    }
}

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;
    }
}

class ObsidianOutlinerPlugin extends obsidian.Plugin {
    onload() {
        return __awaiter(this, void 0, void 0, function* () {
            console.log(`Loading obsidian-outliner`);
            this.settingsService = new SettingsService(this);
            yield this.settingsService.load();
            this.loggerService = new LoggerService(this.settingsService);
            this.obsidianService = new ObsidianService(this.app);
            this.listsService = new ListsService(this.loggerService, this.obsidianService);
            this.imeService = new IMEService();
            yield this.imeService.load();
            this.addSettingTab(new ObsidianOutlinerPluginSettingTab(this.app, this, this.settingsService));
            this.features = [
                new ListsStylesFeature(this, this.settingsService, this.obsidianService),
                new EnterOutdentIfLineIsEmptyFeature(this, this.settingsService, this.listsService, this.imeService),
                new EnterShouldCreateNewItemFeature(this, this.settingsService, this.listsService, this.imeService),
                new EnsureCursorInListContentFeature(this, this.settingsService, this.listsService),
                new MoveCursorToPreviousUnfoldedLineFeature(this, this.settingsService, this.listsService, this.imeService),
                new DeleteShouldIgnoreBulletsFeature(this, this.settingsService, this.listsService, this.imeService),
                new SelectionShouldIgnoreBulletsFeature(this, this.settingsService, this.listsService, this.imeService),
                new ZoomFeature(this, this.settingsService, this.imeService),
                new FoldFeature(this, this.obsidianService),
                new SelectAllFeature(this, this.settingsService, this.listsService, this.imeService),
                new MoveItemsFeature(this, this.obsidianService, this.listsService, this.imeService),
                new ShiftEnterShouldCreateNoteFeature(this, this.settingsService, this.listsService, this.imeService),
            ];
            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.imeService.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/services/SettingsService.ts","src/services/ObsidianService.ts","src/root/index.ts","src/services/ListsService.ts","src/services/LoggerService.ts","src/features/ListsStylesFeature.ts","src/root/recalculateNumericBullets.ts","src/operations/MoveLeftOperation.ts","src/utils/isEmptyLineOrEmptyCheckbox.ts","src/operations/OutdentIfLineIsEmptyOperation.ts","src/features/EnterOutdentIfLineIsEmptyFeature.ts","src/operations/CreateNewItemOperation.ts","src/features/EnterShouldCreateNewItemOnChildLevelFeature.ts","src/operations/MoveCursorToPreviousUnfoldedLineOperation.ts","src/features/MoveCursorToPreviousUnfoldedLineFeature.ts","src/operations/EnsureCursorInListContentOperation.ts","src/operations/EnsureCursorIsInUnfoldedLineOperation.ts","src/features/EnsureCursorInListContentFeature.ts","src/operations/DeleteAndMergeWithPreviousLineOperation.ts","src/operations/DeleteAndMergeWithNextLineOperation.ts","src/operations/DeleteTillLineStartOperation.ts","src/features/DeleteShouldIgnoreBulletsFeature.ts","src/operations/SelectTillLineStartOperation.ts","src/features/SelectionShouldIgnoreBulletsFeature.ts","src/features/ZoomFeature.ts","src/features/FoldFeature.ts","src/operations/SelectAllOperation.ts","src/features/SelectAllFeature.ts","src/operations/MoveRightOperation.ts","src/operations/MoveDownOperation.ts","src/operations/MoveUpOperation.ts","src/features/MoveItemsFeature.ts","src/operations/CreateNoteLineOperation.ts","src/features/ShiftEnterShouldCreateNoteFeature.ts","src/services/IMEService.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    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\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) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\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","import { App, PluginSettingTab, Plugin_2, Setting } from \"obsidian\";\n\nexport interface ObsidianOutlinerPluginSettings {\n  styleLists: boolean;\n  debug: boolean;\n  stickCursor: boolean;\n  betterEnter: boolean;\n  selectAll: boolean;\n  disableZoomNotification: boolean;\n  hideWarning: boolean;\n}\n\nconst DEFAULT_SETTINGS: ObsidianOutlinerPluginSettings = {\n  styleLists: false,\n  debug: false,\n  stickCursor: true,\n  betterEnter: true,\n  selectAll: true,\n  disableZoomNotification: false,\n  hideWarning: false,\n};\n\nexport interface Storage {\n  loadData(): Promise<ObsidianOutlinerPluginSettings>;\n  saveData(settigns: ObsidianOutlinerPluginSettings): Promise<void>;\n}\n\ntype K = keyof ObsidianOutlinerPluginSettings;\ntype V<T extends K> = ObsidianOutlinerPluginSettings[T];\ntype Callback<T extends K> = (cb: V<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 selectAll() {\n    return this.values.selectAll;\n  }\n  set selectAll(value: boolean) {\n    this.set(\"selectAll\", value);\n  }\n\n  get disableZoomNotification() {\n    return this.values.disableZoomNotification;\n  }\n  set disableZoomNotification(value: boolean) {\n    this.set(\"disableZoomNotification\", value);\n  }\n\n  get hideWarning() {\n    return this.values.hideWarning;\n  }\n  set hideWarning(value: boolean) {\n    this.set(\"hideWarning\", 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, 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  private set<T extends K>(key: T, value: V<K>): 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\nexport class 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. Styles only work well with spaces or four-space tabs.\"\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(\"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 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(\"Disable notification about Obsidian Zoom plugin\")\n      .addToggle((toggle) => {\n        toggle\n          .setValue(this.settings.disableZoomNotification)\n          .onChange(async (value) => {\n            this.settings.disableZoomNotification = value;\n            await this.settings.save();\n          });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Hide the warning about four-space tabs\")\n      .addToggle((toggle) => {\n        toggle.setValue(this.settings.hideWarning).onChange(async (value) => {\n          this.settings.hideWarning = 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","import { App, MarkdownView } from \"obsidian\";\n\nexport interface IObsidianTabsSettigns {\n  useTab: boolean;\n  tabSize: number;\n}\n\nexport interface IObsidianFoldSettigns {\n  foldIndent: boolean;\n}\n\nexport class ObsidianService {\n  constructor(private app: App) {}\n\n  getObsidianTabsSettigns(): IObsidianTabsSettigns {\n    return {\n      useTab: true,\n      tabSize: 4,\n      ...(this.app.vault as any).config,\n    };\n  }\n\n  getObsidianFoldSettigns(): IObsidianFoldSettigns {\n    return {\n      foldIndent: false,\n      ...(this.app.vault as any).config,\n    };\n  }\n\n  getActiveLeafDisplayText() {\n    return this.app.workspace.activeLeaf.getDisplayText();\n  }\n\n  createCommandCallback(cb: (editor: CodeMirror.Editor) => boolean) {\n    return () => {\n      const view = this.app.workspace.getActiveViewOfType(MarkdownView);\n\n      if (!view) {\n        return;\n      }\n\n      const editor = view.sourceMode.cmEditor;\n\n      const shouldStopPropagation = cb(editor);\n\n      if (\n        !shouldStopPropagation &&\n        window.event &&\n        window.event.type === \"keydown\"\n      ) {\n        (editor as any).triggerOnKeyDown(window.event);\n      }\n    };\n  }\n}\n","export function cmpPos(a: IPosition, b: IPosition) {\n  return a.line - b.line || a.ch - b.ch;\n}\n\nexport function maxPos(a: IPosition, b: IPosition) {\n  return cmpPos(a, b) < 0 ? b : a;\n}\n\nexport function minPos(a: IPosition, b: IPosition) {\n  return cmpPos(a, b) < 0 ? a : b;\n}\n\nexport interface IPosition {\n  ch: number;\n  line: number;\n}\n\nexport interface IListLine {\n  text: string;\n  from: IPosition;\n  to: IPosition;\n}\n\nexport interface IRange {\n  anchor: IPosition;\n  head: IPosition;\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    firstLine: string,\n    private folded: 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(): IListLine[] {\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.folded) {\n      return true;\n    }\n\n    if (this.parent) {\n      return this.parent.isFolded();\n    }\n\n    return false;\n  }\n\n  isFoldRoot() {\n    let parent = this.getParent();\n\n    while (parent) {\n      if (parent.folded) {\n        return false;\n      }\n\n      parent = parent.getParent();\n    }\n\n    return this.folded;\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  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 += i === 0 ? this.indent + this.bullet + \" \" : 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, \"\", \"\", \"\", false);\n  private selections: IRange[] = [];\n\n  constructor(\n    private start: IPosition,\n    private end: IPosition,\n    selections: IRange[]\n  ) {\n    this.replaceSelections(selections);\n  }\n\n  getRootList() {\n    return this.rootList;\n  }\n\n  getRange(): [IPosition, IPosition] {\n    return [{ ...this.start }, { ...this.end }];\n  }\n\n  getSelections(): IRange[] {\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  getCursor() {\n    return { ...this.selections[this.selections.length - 1].head };\n  }\n\n  replaceCursor(cursor: IPosition) {\n    this.selections = [{ anchor: cursor, head: cursor }];\n  }\n\n  replaceSelections(selections: IRange[]) {\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 { LoggerService } from \"./LoggerService\";\nimport { ObsidianService } from \"./ObsidianService\";\nimport { List, Root } from \"../root\";\nimport { IOperation } from \"../operations/IOperation\";\n\nconst bulletSign = `(?:[-*+]|\\\\d+\\\\.)`;\n\nconst listItemWithoutSpacesRe = new RegExp(`^${bulletSign} `);\nconst listItemRe = new RegExp(`^[ \\t]*${bulletSign} `);\nconst stringWithSpacesRe = new RegExp(`^[ \\t]+`);\nconst parseListItemRe = new RegExp(`^([ \\t]*)(${bulletSign}) (.*)$`);\n\nexport interface IApplyChangesList {\n  isFoldRoot(): boolean;\n}\n\nexport interface IApplyChangesRoot {\n  getRange(): [CodeMirror.Position, CodeMirror.Position];\n  getSelections(): { anchor: CodeMirror.Position; head: CodeMirror.Position }[];\n  print(): string;\n  getListUnderLine(l: number): IApplyChangesList;\n}\n\ninterface IParseListList {\n  getFirstLineIndent(): string;\n  setNotesIndent(notesIndent: string): void;\n  getNotesIndent(): string | null;\n  addLine(text: string): void;\n  getParent(): IParseListList | null;\n  addAfterAll(list: IParseListList): void;\n}\n\nexport class ListsService {\n  constructor(\n    private loggerService: LoggerService,\n    private obsidianService: ObsidianService\n  ) {}\n\n  evalOperation(root: Root, op: IOperation, editor: CodeMirror.Editor) {\n    op.perform();\n\n    if (op.shouldUpdate()) {\n      this.applyChanges(editor, root);\n    }\n\n    return {\n      shouldUpdate: op.shouldUpdate(),\n      shouldStopPropagation: op.shouldStopPropagation(),\n    };\n  }\n\n  performOperation(\n    cb: (root: Root) => IOperation,\n    editor: CodeMirror.Editor,\n    cursor = editor.getCursor()\n  ) {\n    const root = this.parseList(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  parseList(\n    editor: CodeMirror.Editor,\n    cursor = editor.getCursor()\n  ): Root | null {\n    const d = this.loggerService.bind(\"parseList\");\n    const error = (msg: string): null => {\n      d(msg);\n      return null;\n    };\n\n    const line = editor.getLine(cursor.line);\n\n    let listLookingPos: number | null = null;\n\n    if (this.isListItem(line)) {\n      listLookingPos = cursor.line;\n    } else if (this.isLineWithIndent(line)) {\n      let listLookingPosSearch = cursor.line - 1;\n      while (listLookingPosSearch >= editor.firstLine()) {\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 >= editor.firstLine()) {\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      }\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      listEndLineLookup++;\n    }\n\n    if (listStartLine > cursor.line || listEndLine < cursor.line) {\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: IParseListList = root.getRootList();\n    let currentList: IParseListList | null = null;\n    let currentIndent = \"\";\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, content] = 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 folded = !!(editor as any).isFolded({\n          line: Math.min(l + 1, listEndLine),\n          ch: 0,\n        });\n\n        currentList = new List(root, indent, bullet, content, folded);\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            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 applyChanges(editor: CodeMirror.Editor, root: IApplyChangesRoot) {\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 as any).foldCode(l, null, \"unfold\");\n    }\n\n    let changeFrom = { ...rootRange[0] };\n    let changeTo = { ...rootRange[1] };\n    let oldTmp = oldString;\n    let newTmp = newString;\n\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    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\n    if (oldTmp !== newTmp) {\n      editor.replaceRange(newTmp, changeFrom, changeTo);\n    }\n\n    editor.setSelections(root.getSelections());\n\n    // TODO: lines could be different because of deletetion\n    for (let l = fromLine; l <= toLine; l++) {\n      const line = root.getListUnderLine(l);\n      if (line && line.isFoldRoot()) {\n        (editor as any).foldCode(l);\n      }\n    }\n  }\n\n  getDefaultIndentChars() {\n    const { useTab, tabSize } = this.obsidianService.getObsidianTabsSettigns();\n\n    return useTab ? \"\\t\" : new Array(tabSize).fill(\" \").join(\"\");\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 { SettingsService } from \"./SettingsService\";\n\nexport class LoggerService {\n  constructor(private settingsService: SettingsService) {}\n\n  log(method: string, ...args: any[]) {\n    if (!this.settingsService.debug) {\n      return;\n    }\n\n    console.info(method, ...args);\n  }\n\n  bind(method: string) {\n    return (...args: any[]) => this.log(method, ...args);\n  }\n}\n","import { SettingsService } from \"../services/SettingsService\";\nimport { Plugin_2 } from \"obsidian\";\nimport { IFeature } from \"./IFeature\";\nimport { ObsidianService } from \"../services/ObsidianService\";\n\nconst STATUS_BAR_TEXT = `Outliner styles only work with four-space tabs. Please check Obsidian settings.`;\n\nexport class ListsStylesFeature implements IFeature {\n  private statusBarText: HTMLElement;\n  private interval: number;\n\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private obsidianService: ObsidianService\n  ) {}\n\n  async load() {\n    if (this.settingsService.styleLists) {\n      this.addListsStyles();\n    }\n\n    this.settingsService.onChange(\"styleLists\", this.onStyleListsSettingChange);\n\n    this.addStatusBarText();\n    this.startStatusBarInterval();\n  }\n\n  async unload() {\n    clearInterval(this.interval);\n    if (this.statusBarText.parentElement) {\n      this.statusBarText.parentElement.removeChild(this.statusBarText);\n    }\n    this.settingsService.removeCallback(\n      \"styleLists\",\n      this.onStyleListsSettingChange\n    );\n    this.removeListsStyles();\n  }\n\n  private startStatusBarInterval() {\n    let visible: boolean = false;\n\n    this.interval = window.setInterval(() => {\n      const { useTab, tabSize } =\n        this.obsidianService.getObsidianTabsSettigns();\n\n      const shouldBeVisible =\n        this.settingsService.styleLists &&\n        !(useTab && tabSize === 4) &&\n        !this.settingsService.hideWarning;\n\n      if (shouldBeVisible && !visible) {\n        this.statusBarText.style.display = \"block\";\n        visible = true;\n      } else if (!shouldBeVisible && visible) {\n        this.statusBarText.style.display = \"none\";\n        visible = false;\n      }\n    }, 1000);\n  }\n\n  private onStyleListsSettingChange = (styleLists: boolean) => {\n    if (styleLists) {\n      this.addListsStyles();\n    } else {\n      this.removeListsStyles();\n    }\n  };\n\n  private addStatusBarText() {\n    this.statusBarText = this.plugin.addStatusBarItem();\n    this.statusBarText.style.color = \"red\";\n    this.statusBarText.style.display = \"none\";\n    this.statusBarText.setText(STATUS_BAR_TEXT);\n  }\n\n  private addListsStyles() {\n    document.body.classList.add(\"outliner-plugin-bls\");\n  }\n\n  private removeListsStyles() {\n    document.body.classList.remove(\"outliner-plugin-bls\");\n  }\n}\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 { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class MoveLeftOperation implements IOperation {\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 { Root } from \"../root\";\nimport { MoveLeftOperation } from \"./MoveLeftOperation\";\nimport { IOperation } from \"./IOperation\";\nimport { isEmptyLineOrEmptyCheckbox } from \"../utils/isEmptyLineOrEmptyCheckbox\";\n\nexport class OutdentIfLineIsEmptyOperation implements IOperation {\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\";\nimport { OutdentIfLineIsEmptyOperation } from \"../operations/OutdentIfLineIsEmptyOperation\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isEnter(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 13 || e.code === \"Enter\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nexport class EnterOutdentIfLineIsEmptyFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, e: KeyboardEvent) => {\n    if (\n      !this.settingsService.betterEnter ||\n      !isEnter(e) ||\n      this.imeService.isIMEOpened()\n    ) {\n      return;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new OutdentIfLineIsEmptyOperation(root),\n      cm\n    );\n\n    if (shouldStopPropagation) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  };\n}\n","import { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { isEmptyLineOrEmptyCheckbox } from \"src/utils/isEmptyLineOrEmptyCheckbox\";\nimport { List, Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class CreateNewItemOperation implements IOperation {\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 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 a = line.text.slice(0, cursor.ch - line.from.ch);\n          const b = line.text.slice(cursor.ch - line.from.ch);\n          acc.oldLines.push(a);\n          acc.newLines.push(b);\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 endPos = list.getLastLineContentEnd();\n    const onChildLevel =\n      !list.isEmpty() && cursor.line === endPos.line && cursor.ch === endPos.ch;\n\n    const indent = onChildLevel\n      ? list.getChildren()[0].getFirstLineIndent()\n      : list.getFirstLineIndent();\n\n    const bullet = onChildLevel\n      ? list.getChildren()[0].getBullet()\n      : list.getBullet();\n\n    const prefix = oldLines[0].match(/^\\[[ x]\\]/) ? \"[ ] \" : \"\";\n\n    const newList = new List(\n      list.getRoot(),\n      indent,\n      bullet,\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      const children = list.getChildren();\n      for (const child of children) {\n        list.removeChild(child);\n        newList.addAfterAll(child);\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\";\nimport { CreateNewItemOperation } from \"../operations/CreateNewItemOperation\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isEnter(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 13 || e.code === \"Enter\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nexport class EnterShouldCreateNewItemFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, e: KeyboardEvent) => {\n    if (\n      !this.settingsService.betterEnter ||\n      !isEnter(e) ||\n      this.imeService.isIMEOpened()\n    ) {\n      return;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new CreateNewItemOperation(root),\n      cm\n    );\n\n    if (shouldStopPropagation) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  };\n}\n","import { IListLine, Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class MoveCursorToPreviousUnfoldedLineOperation implements IOperation {\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) => cursor.ch === l.from.ch && 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: IListLine[],\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: IPosition) {\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      let foldRoot = prev;\n      while (!foldRoot.isFoldRoot()) {\n        foldRoot = foldRoot.getParent();\n      }\n\n      const firstLineEnd = foldRoot.getLinesInfo()[0].to;\n      root.replaceCursor(firstLineEnd);\n    } else {\n      root.replaceCursor(prev.getLastLineContentEnd());\n    }\n  }\n}\n","import { Platform, Plugin_2 } from \"obsidian\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { MoveCursorToPreviousUnfoldedLineOperation } from \"../operations/MoveCursorToPreviousUnfoldedLineOperation\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isArrowLeft(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 37 || e.code === \"ArrowLeft\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nfunction isCtrlArrowLeft(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 37 || e.code === \"ArrowLeft\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === true\n  );\n}\n\nexport class MoveCursorToPreviousUnfoldedLineFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, event: KeyboardEvent) => {\n    if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {\n      return;\n    }\n\n    if (isArrowLeft(event) || (!Platform.isMacOS && isCtrlArrowLeft(event))) {\n      const { shouldStopPropagation } = this.listsService.performOperation(\n        (root) => new MoveCursorToPreviousUnfoldedLineOperation(root),\n        cm\n      );\n\n      if (shouldStopPropagation) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    }\n  };\n}\n","import { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class EnsureCursorInListContentOperation implements IOperation {\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\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 { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class EnsureCursorIsInUnfoldedLineOperation implements IOperation {\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    let foldRoot = list;\n    while (!foldRoot.isFoldRoot()) {\n      foldRoot = foldRoot.getParent();\n    }\n\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\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { EnsureCursorInListContentOperation } from \"../operations/EnsureCursorInListContentOperation\";\nimport { EnsureCursorIsInUnfoldedLineOperation } from \"../operations/EnsureCursorIsInUnfoldedLineOperation\";\nimport { SettingsService } from \"../services/SettingsService\";\n\nexport class EnsureCursorInListContentFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"cursorActivity\", this.handleCursorActivity);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"cursorActivity\", this.handleCursorActivity);\n    });\n  }\n\n  private handleCursorActivity = (cm: CodeMirror.Editor) => {\n    if (!this.settingsService.stickCursor) {\n      return;\n    }\n\n    this.listsService.performOperation(\n      (root) => new EnsureCursorIsInUnfoldedLineOperation(root),\n      cm\n    );\n\n    this.listsService.performOperation(\n      (root) => new EnsureCursorInListContentOperation(root),\n      cm\n    );\n  };\n}\n","import { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { IListLine, List, Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class DeleteAndMergeWithPreviousLineOperation implements IOperation {\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: IPosition,\n    list: List,\n    lines: IListLine[],\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: IPosition, 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 { Root } from \"../root\";\nimport { DeleteAndMergeWithPreviousLineOperation } from \"./DeleteAndMergeWithPreviousLineOperation\";\nimport { IOperation } from \"./IOperation\";\n\nexport class DeleteAndMergeWithNextLineOperation implements IOperation {\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      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 { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class DeleteTillLineStartOperation implements IOperation {\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 { Platform, Plugin_2 } from \"obsidian\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { DeleteAndMergeWithNextLineOperation } from \"../operations/DeleteAndMergeWithNextLineOperation\";\nimport { DeleteAndMergeWithPreviousLineOperation } from \"../operations/DeleteAndMergeWithPreviousLineOperation\";\nimport { DeleteTillLineStartOperation } from \"../operations/DeleteTillLineStartOperation\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isBackspace(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 8 || e.code === \"Backspace\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nfunction isCmdBackspace(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 8 || e.code === \"Backspace\") &&\n    e.shiftKey === false &&\n    e.metaKey === true &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nfunction isDelete(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 46 || e.code === \"Delete\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nexport class DeleteShouldIgnoreBulletsFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, event: KeyboardEvent) => {\n    if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {\n      return;\n    }\n\n    if (isBackspace(event)) {\n      const { shouldStopPropagation } = this.listsService.performOperation(\n        (root) => new DeleteAndMergeWithPreviousLineOperation(root),\n        cm\n      );\n\n      if (shouldStopPropagation) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    }\n\n    if (Platform.isMacOS && isCmdBackspace(event)) {\n      const { shouldStopPropagation } = this.listsService.performOperation(\n        (root) => new DeleteTillLineStartOperation(root),\n        cm\n      );\n\n      if (shouldStopPropagation) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    }\n\n    if (isDelete(event)) {\n      const { shouldStopPropagation } = this.listsService.performOperation(\n        (root) => new DeleteAndMergeWithNextLineOperation(root),\n        cm\n      );\n\n      if (shouldStopPropagation) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    }\n  };\n}\n","import { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class SelectTillLineStartOperation implements IOperation {\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 { Platform, Plugin_2 } from \"obsidian\";\nimport { ListsService } from \"../services/ListsService\";\nimport { SelectTillLineStartOperation } from \"../operations/SelectTillLineStartOperation\";\nimport { IFeature } from \"./IFeature\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isCmdShiftLeft(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 37 || e.code === \"ArrowLeft\") &&\n    e.shiftKey === true &&\n    e.metaKey === true &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nexport class SelectionShouldIgnoreBulletsFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, event: KeyboardEvent) => {\n    if (!this.settingsService.stickCursor || this.imeService.isIMEOpened()) {\n      return;\n    }\n\n    if (Platform.isMacOS && isCmdShiftLeft(event)) {\n      const { shouldStopPropagation } = this.listsService.performOperation(\n        (root) => new SelectTillLineStartOperation(root),\n        cm\n      );\n\n      if (shouldStopPropagation) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    }\n  };\n}\n","import { Notice, Platform, Plugin_2 } from \"obsidian\";\nimport { IMEService } from \"src/services/IMEService\";\nimport { SettingsService } from \"src/services/SettingsService\";\nimport { IFeature } from \"./IFeature\";\n\nfunction isCmdDotOrCmdShiftDot(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 190 || e.code === \"Period\") &&\n    e.metaKey === true &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nfunction isCtrlDotOrCtrlShiftDot(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 190 || e.code === \"Period\") &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === true\n  );\n}\n\nfunction isModDotOrModShiftDot(e: KeyboardEvent) {\n  return Platform.isMacOS\n    ? isCmdDotOrCmdShiftDot(e)\n    : isCtrlDotOrCtrlShiftDot(e);\n}\n\nexport class ZoomFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, e: KeyboardEvent) => {\n    if (\n      (window as any).ObsidianZoomPlugin ||\n      this.settingsService.disableZoomNotification ||\n      !isModDotOrModShiftDot(e) ||\n      this.imeService.isIMEOpened()\n    ) {\n      return;\n    }\n\n    new Notice(\n      `Zooming support has been removed from the Obsidian Outliner plugin. Please install the Obsidian Zoom plugin.`,\n      5000\n    );\n  };\n}\n","import { Notice, Plugin_2 } from \"obsidian\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { IFeature } from \"./IFeature\";\n\nexport class FoldFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private obsidianService: ObsidianService\n  ) {}\n\n  async load() {\n    this.plugin.addCommand({\n      id: \"fold\",\n      name: \"Fold the list\",\n      callback: this.obsidianService.createCommandCallback(\n        this.fold.bind(this)\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\"],\n          key: \"ArrowUp\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"unfold\",\n      name: \"Unfold the list\",\n      callback: this.obsidianService.createCommandCallback(\n        this.unfold.bind(this)\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\"],\n          key: \"ArrowDown\",\n        },\n      ],\n    });\n  }\n\n  async unload() {}\n\n  private setFold(editor: CodeMirror.Editor, type: \"fold\" | \"unfold\") {\n    if (!this.obsidianService.getObsidianFoldSettigns().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    (editor as any).foldCode(editor.getCursor(), null, type);\n\n    return true;\n  }\n\n  private fold(editor: CodeMirror.Editor) {\n    return this.setFold(editor, \"fold\");\n  }\n\n  private unfold(editor: CodeMirror.Editor) {\n    return this.setFold(editor, \"unfold\");\n  }\n}\n","import { maxPos, minPos, Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class SelectAllOperation implements IOperation {\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 { Platform, Plugin_2 } from \"obsidian\";\nimport { ListsService } from \"../services/ListsService\";\nimport { SelectAllOperation } from \"../operations/SelectAllOperation\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IFeature } from \"./IFeature\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isCmdA(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 65 || e.code === \"KeyA\") &&\n    e.shiftKey === false &&\n    e.metaKey === true &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nfunction isCtrlA(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 65 || e.code === \"KeyA\") &&\n    e.shiftKey === false &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === true\n  );\n}\n\nfunction isSelectAll(e: KeyboardEvent) {\n  return Platform.isMacOS ? isCmdA(e) : isCtrlA(e);\n}\n\nexport class SelectAllFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, event: KeyboardEvent) => {\n    if (\n      !this.settingsService.selectAll ||\n      !isSelectAll(event) ||\n      this.imeService.isIMEOpened()\n    ) {\n      return;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new SelectAllOperation(root),\n      cm\n    );\n\n    if (shouldStopPropagation) {\n      event.preventDefault();\n      event.stopPropagation();\n    }\n  };\n}\n","import { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class MoveRightOperation implements IOperation {\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 { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class MoveDownOperation implements IOperation {\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 { recalculateNumericBullets } from \"src/root/recalculateNumericBullets\";\nimport { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class MoveUpOperation implements IOperation {\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\";\nimport { ListsService } from \"../services/ListsService\";\nimport { MoveLeftOperation } from \"../operations/MoveLeftOperation\";\nimport { ObsidianService } from \"../services/ObsidianService\";\nimport { IFeature } from \"./IFeature\";\nimport { MoveRightOperation } from \"../operations/MoveRightOperation\";\nimport { MoveDownOperation } from \"../operations/MoveDownOperation\";\nimport { MoveUpOperation } from \"../operations/MoveUpOperation\";\nimport { IMEService } from \"src/services/IMEService\";\n\nexport class MoveItemsFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private obsidianService: ObsidianService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.addCommand({\n      id: \"move-list-item-up\",\n      name: \"Move list and sublists up\",\n      callback: this.obsidianService.createCommandCallback(\n        this.moveListElementUp.bind(this)\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      name: \"Move list and sublists down\",\n      callback: this.obsidianService.createCommandCallback(\n        this.moveListElementDown.bind(this)\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Mod\", \"Shift\"],\n          key: \"ArrowDown\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"indent-list\",\n      name: \"Indent the list and sublists\",\n      callback: this.obsidianService.createCommandCallback(\n        this.moveListElementRight.bind(this)\n      ),\n      hotkeys: [\n        {\n          modifiers: [],\n          key: \"Tab\",\n        },\n      ],\n    });\n\n    this.plugin.addCommand({\n      id: \"outdent-list\",\n      name: \"Outdent the list and sublists\",\n      callback: this.obsidianService.createCommandCallback(\n        this.moveListElementLeft.bind(this)\n      ),\n      hotkeys: [\n        {\n          modifiers: [\"Shift\"],\n          key: \"Tab\",\n        },\n      ],\n    });\n  }\n\n  async unload() {}\n\n  private moveListElementDown(editor: CodeMirror.Editor) {\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new MoveDownOperation(root),\n      editor\n    );\n    return shouldStopPropagation;\n  }\n\n  private moveListElementUp(editor: CodeMirror.Editor) {\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new MoveUpOperation(root),\n      editor\n    );\n    return shouldStopPropagation;\n  }\n\n  private moveListElementRight(editor: CodeMirror.Editor) {\n    if (this.imeService.isIMEOpened()) {\n      return true;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) =>\n        new MoveRightOperation(root, this.listsService.getDefaultIndentChars()),\n      editor\n    );\n    return shouldStopPropagation;\n  }\n\n  private moveListElementLeft(editor: CodeMirror.Editor) {\n    if (this.imeService.isIMEOpened()) {\n      return true;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) => new MoveLeftOperation(root),\n      editor\n    );\n    return shouldStopPropagation;\n  }\n}\n","import { Root } from \"../root\";\nimport { IOperation } from \"./IOperation\";\n\nexport class CreateNoteLineOperation implements IOperation {\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    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      const indent = list.isEmpty()\n        ? list.getFirstLineIndent() + this.defaultIndentChars\n        : list.getChildren()[0].getFirstLineIndent();\n\n      list.setNotesIndent(indent);\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\";\nimport { CreateNoteLineOperation } from \"../operations/CreateNoteLineOperation\";\nimport { IFeature } from \"./IFeature\";\nimport { ListsService } from \"../services/ListsService\";\nimport { SettingsService } from \"../services/SettingsService\";\nimport { IMEService } from \"src/services/IMEService\";\n\nfunction isShiftEnter(e: KeyboardEvent) {\n  return (\n    (e.keyCode === 13 || e.code === \"Enter\") &&\n    e.shiftKey === true &&\n    e.metaKey === false &&\n    e.altKey === false &&\n    e.ctrlKey === false\n  );\n}\n\nexport class ShiftEnterShouldCreateNoteFeature implements IFeature {\n  constructor(\n    private plugin: Plugin_2,\n    private settingsService: SettingsService,\n    private listsService: ListsService,\n    private imeService: IMEService\n  ) {}\n\n  async load() {\n    this.plugin.registerCodeMirror((cm) => {\n      cm.on(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  async unload() {\n    this.plugin.app.workspace.iterateCodeMirrors((cm) => {\n      cm.off(\"keydown\", this.onKeyDown);\n    });\n  }\n\n  private onKeyDown = (cm: CodeMirror.Editor, e: KeyboardEvent) => {\n    if (\n      !this.settingsService.betterEnter ||\n      !isShiftEnter(e) ||\n      this.imeService.isIMEOpened()\n    ) {\n      return;\n    }\n\n    const { shouldStopPropagation } = this.listsService.performOperation(\n      (root) =>\n        new CreateNoteLineOperation(\n          root,\n          this.listsService.getDefaultIndentChars()\n        ),\n      cm\n    );\n\n    if (shouldStopPropagation) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  };\n}\n","export 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;\n  }\n\n  private onCompositionStart = () => {\n    this.composition = true;\n  };\n\n  private onCompositionEnd = () => {\n    this.composition = false;\n  };\n}\n","import { Plugin } from \"obsidian\";\r\nimport {\r\n  ObsidianOutlinerPluginSettingTab,\r\n  SettingsService,\r\n} from \"./services/SettingsService\";\r\nimport { IFeature } from \"./features/IFeature\";\r\nimport { ObsidianService } from \"./services/ObsidianService\";\r\nimport { ListsService } from \"./services/ListsService\";\r\nimport { LoggerService } from \"./services/LoggerService\";\r\nimport { ListsStylesFeature } from \"./features/ListsStylesFeature\";\r\nimport { EnterOutdentIfLineIsEmptyFeature } from \"./features/EnterOutdentIfLineIsEmptyFeature\";\r\nimport { EnterShouldCreateNewItemFeature } from \"./features/EnterShouldCreateNewItemOnChildLevelFeature\";\r\nimport { MoveCursorToPreviousUnfoldedLineFeature } from \"./features/MoveCursorToPreviousUnfoldedLineFeature\";\r\nimport { EnsureCursorInListContentFeature } from \"./features/EnsureCursorInListContentFeature\";\r\nimport { DeleteShouldIgnoreBulletsFeature } from \"./features/DeleteShouldIgnoreBulletsFeature\";\r\nimport { SelectionShouldIgnoreBulletsFeature } from \"./features/SelectionShouldIgnoreBulletsFeature\";\r\nimport { ZoomFeature } from \"./features/ZoomFeature\";\r\nimport { FoldFeature } from \"./features/FoldFeature\";\r\nimport { SelectAllFeature } from \"./features/SelectAllFeature\";\r\nimport { MoveItemsFeature } from \"./features/MoveItemsFeature\";\r\nimport { ShiftEnterShouldCreateNoteFeature } from \"./features/ShiftEnterShouldCreateNoteFeature\";\r\nimport { IMEService } from \"./services/IMEService\";\r\n\r\nexport default class ObsidianOutlinerPlugin extends Plugin {\r\n  private features: IFeature[];\r\n  protected settingsService: SettingsService;\r\n  private loggerService: LoggerService;\r\n  private obsidianService: ObsidianService;\r\n  private listsService: ListsService;\r\n  private imeService: IMEService;\r\n\r\n  async onload() {\r\n    console.log(`Loading obsidian-outliner`);\r\n\r\n    this.settingsService = new SettingsService(this);\r\n    await this.settingsService.load();\r\n\r\n    this.loggerService = new LoggerService(this.settingsService);\r\n\r\n    this.obsidianService = new ObsidianService(this.app);\r\n    this.listsService = new ListsService(\r\n      this.loggerService,\r\n      this.obsidianService\r\n    );\r\n\r\n    this.imeService = new IMEService();\r\n    await this.imeService.load();\r\n\r\n    this.addSettingTab(\r\n      new ObsidianOutlinerPluginSettingTab(this.app, this, this.settingsService)\r\n    );\r\n\r\n    this.features = [\r\n      new ListsStylesFeature(this, this.settingsService, this.obsidianService),\r\n      new EnterOutdentIfLineIsEmptyFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new EnterShouldCreateNewItemFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new EnsureCursorInListContentFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService\r\n      ),\r\n      new MoveCursorToPreviousUnfoldedLineFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new DeleteShouldIgnoreBulletsFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new SelectionShouldIgnoreBulletsFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new ZoomFeature(this, this.settingsService, this.imeService),\r\n      new FoldFeature(this, this.obsidianService),\r\n      new SelectAllFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new MoveItemsFeature(\r\n        this,\r\n        this.obsidianService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n      new ShiftEnterShouldCreateNoteFeature(\r\n        this,\r\n        this.settingsService,\r\n        this.listsService,\r\n        this.imeService\r\n      ),\r\n    ];\r\n\r\n    for (const feature of this.features) {\r\n      await feature.load();\r\n    }\r\n  }\r\n\r\n  async onunload() {\r\n    console.log(`Unloading obsidian-outliner`);\r\n\r\n    await this.imeService.unload();\r\n\r\n    for (const feature of this.features) {\r\n      await feature.unload();\r\n    }\r\n  }\r\n}\r\n"],"names":["PluginSettingTab","Setting","MarkdownView","isEnter","Platform","Notice","Plugin"],"mappings":"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"}