/*
THIS IS A GENERATED/BUNDLED FILE BY ROLLUP
if you want to view the source visit the plugins github repository
*/

'use strict';

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

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

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

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

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

// Dashes
const dashRules = [
    // en dash
    {
        trigger: "-",
        from: "--",
        to: "–",
        contextMatch: /-$/,
    },
    // em dash
    {
        trigger: "-",
        from: "–-",
        to: "—",
        contextMatch: /–$/,
    },
    // tripple dash
    {
        trigger: "-",
        from: "—-",
        to: "---",
        contextMatch: /—$/,
    },
];
const dashRulesSansEnDash = [
    // em dash
    {
        trigger: "-",
        from: "--",
        to: "—",
        contextMatch: /-$/,
    },
    // tripple dash
    {
        trigger: "-",
        from: "—-",
        to: "---",
        contextMatch: /—$/,
    },
];
// Ellipsis
const ellipsisRules = [
    {
        trigger: ".",
        from: "...",
        to: "…",
        contextMatch: /\.\.$/,
    },
];
// Quotes
const smartQuoteRules = [
    // Open double
    {
        trigger: '"',
        from: '"',
        to: (settings) => settings.openDouble,
        contextMatch: /[\s\{\[\(\<'"\u2018\u201C]$/,
    },
    // Close double
    {
        trigger: '"',
        from: '"',
        to: (settings) => settings.closeDouble,
        contextMatch: /.*$/,
    },
    // Paired double
    {
        trigger: '""',
        from: '""',
        to: (settings) => settings.openDouble + settings.closeDouble,
        contextMatch: /.*$/,
    },
    // Open single
    {
        trigger: "'",
        from: "'",
        to: (settings) => settings.openSingle,
        contextMatch: /[\s\{\[\(\<'"\u2018\u201C]$/,
    },
    // Close single
    {
        trigger: "'",
        from: "'",
        to: (settings) => settings.closeSingle,
        contextMatch: /.*$/,
    },
    // Paired single
    {
        trigger: "''",
        from: "''",
        to: (settings) => settings.openSingle + settings.closeSingle,
        contextMatch: /.*$/,
    },
];
// Arrows
const arrowRules = [
    {
        trigger: "-",
        from: "<-",
        to: (settings) => settings.leftArrow,
        contextMatch: /<$/,
    },
    {
        trigger: ">",
        from: "->",
        to: (settings) => settings.rightArrow,
        contextMatch: /-$/,
    },
];
// Guillemet
const guillemetRules = [
    {
        trigger: "<",
        from: "<<",
        to: (settings) => settings.openGuillemet,
        contextMatch: /<$/,
    },
    {
        trigger: ">",
        from: ">>",
        to: (settings) => settings.closeGuillemet,
        contextMatch: />$/,
    },
];
// Comparisons
const comparisonRules = [
    {
        trigger: "=",
        from: ">=",
        to: "≥",
        contextMatch: />$/,
    },
    {
        trigger: "=",
        from: "<=",
        to: "≤",
        contextMatch: /<$/,
    },
    {
        trigger: "=",
        from: "/=",
        to: "≠",
        contextMatch: /\/$/,
    },
];
// Fractions
const fractionRules = [
    {
        trigger: "2",
        from: "1/2",
        to: "½",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "3",
        from: "1/3",
        to: "⅓",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "3",
        from: "2/3",
        to: "⅔",
        contextMatch: /(?:^|\s)2\/$/,
    },
    {
        trigger: "4",
        from: "1/4",
        to: "¼",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "4",
        from: "3/4",
        to: "¾",
        contextMatch: /(?:^|\s)3\/$/,
    },
    {
        trigger: "5",
        from: "1/5",
        to: "⅕",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "5",
        from: "2/5",
        to: "⅖",
        contextMatch: /(?:^|\s)2\/$/,
    },
    {
        trigger: "5",
        from: "3/5",
        to: "⅗",
        contextMatch: /(?:^|\s)3\/$/,
    },
    {
        trigger: "5",
        from: "4/5",
        to: "⅘",
        contextMatch: /(?:^|\s)4\/$/,
    },
    {
        trigger: "6",
        from: "1/6",
        to: "⅙",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "6",
        from: "5/6",
        to: "⅚",
        contextMatch: /(?:^|\s)5\/$/,
    },
    {
        trigger: "7",
        from: "1/7",
        to: "⅐",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "8",
        from: "1/8",
        to: "⅛",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "8",
        from: "3/8",
        to: "⅜",
        contextMatch: /(?:^|\s)3\/$/,
    },
    {
        trigger: "8",
        from: "5/8",
        to: "⅝",
        contextMatch: /(?:^|\s)5\/$/,
    },
    {
        trigger: "8",
        from: "7/8",
        to: "⅞",
        contextMatch: /(?:^|\s)7\/$/,
    },
    {
        trigger: "9",
        from: "1/9",
        to: "⅑",
        contextMatch: /(?:^|\s)1\/$/,
    },
    {
        trigger: "0",
        from: "1/10",
        to: "⅒",
        contextMatch: /(?:^|\s)1\/1$/,
    },
];

const dashChar = "-";
const enDashChar = "–";
const emDashChar = "—";
const enDash = {
    matchTrigger: dashChar,
    matchRegExp: /--$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            enDashChar,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === enDashChar) {
            delta.update(delta.from, delta.to, [dashChar + dashChar]);
        }
    },
};
const emDash = {
    matchTrigger: dashChar,
    matchRegExp: /–-$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            emDashChar,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === emDashChar) {
            delta.update(delta.from, delta.to, [enDashChar + dashChar]);
        }
    },
};
const trippleDash = {
    matchTrigger: dashChar,
    matchRegExp: /—-$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            dashChar + dashChar + dashChar,
        ]);
    },
    performRevert: (instance, delta, settings) => { },
};
const ellipsis = {
    matchTrigger: ".",
    matchRegExp: /\.\.\.$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 2 }, delta.to, [
            "…",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "…") {
            delta.update(delta.from, delta.to, ["..."]);
        }
    },
};
const openDoubleQuote = {
    matchTrigger: '"',
    matchRegExp: /(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [settings.openDouble]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.openDouble) {
            delta.update(delta.from, delta.to, ['"']);
        }
    },
};
const closeDoubleQuote = {
    matchTrigger: '"',
    matchRegExp: /"$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [settings.closeDouble]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.closeDouble) {
            delta.update(delta.from, delta.to, ['"']);
        }
    },
};
const pairedDoubleQuote = {
    matchTrigger: '""',
    matchRegExp: /""$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [
            settings.openDouble + settings.closeDouble,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.openDouble) {
            delta.update(delta.from, Object.assign(Object.assign({}, delta.to), { ch: delta.to.ch + 1 }), ['""']);
            setTimeout(() => instance.setCursor(Object.assign(Object.assign({}, delta.from), { ch: delta.from.ch + 1 })));
        }
    },
};
const wrappedDoubleQuote = {
    matchTrigger: /^".*"$/,
    matchRegExp: false,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [
            settings.openDouble + delta.text[0].slice(1, -1) + settings.closeDouble,
        ]);
    },
    performRevert: false,
};
const openSingleQuote = {
    matchTrigger: "'",
    matchRegExp: /(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [settings.openSingle]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.openSingle) {
            delta.update(delta.from, delta.to, ["'"]);
        }
    },
};
const closeSingleQuote = {
    matchTrigger: "'",
    matchRegExp: /'$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [settings.closeSingle]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.closeSingle) {
            delta.update(delta.from, delta.to, ["'"]);
        }
    },
};
const pairedSingleQuote = {
    matchTrigger: "''",
    matchRegExp: /''$/,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [
            settings.openSingle + settings.closeSingle,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.openSingle) {
            delta.update(delta.from, Object.assign(Object.assign({}, delta.to), { ch: delta.to.ch + 1 }), ["''"]);
            setTimeout(() => instance.setCursor(Object.assign(Object.assign({}, delta.from), { ch: delta.from.ch + 1 })));
        }
    },
};
const wrappedSingleQuote = {
    matchTrigger: /^'.*'$/,
    matchRegExp: false,
    performUpdate: (instance, delta, settings) => {
        delta.update(delta.from, delta.to, [
            settings.openSingle + delta.text[0].slice(1, -1) + settings.closeSingle,
        ]);
    },
    performRevert: false,
};
const rightArrow = {
    matchTrigger: ">",
    matchRegExp: /->$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            settings.rightArrow,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.rightArrow) {
            delta.update(delta.from, delta.to, ["->"]);
        }
    },
};
const leftArrow = {
    matchTrigger: "-",
    matchRegExp: /<-$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            settings.leftArrow,
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === settings.leftArrow) {
            delta.update(delta.from, delta.to, ["<-"]);
        }
    },
};
const greaterThanOrEqualTo = {
    matchTrigger: "=",
    matchRegExp: />=$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            "≥",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "≥") {
            delta.update(delta.from, delta.to, [">="]);
        }
    },
};
const lessThanOrEqualTo = {
    matchTrigger: "=",
    matchRegExp: /<=$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            "≤",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "≤") {
            delta.update(delta.from, delta.to, ["<="]);
        }
    },
};
const notEqualTo = {
    matchTrigger: "=",
    matchRegExp: /\/=$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            "≠",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "≠") {
            delta.update(delta.from, delta.to, ["/="]);
        }
    },
};
const rightGuillemet = {
    matchTrigger: ">",
    matchRegExp: />>$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            "»",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "»") {
            delta.update(delta.from, delta.to, [">>"]);
        }
    },
};
const leftGuillemet = {
    matchTrigger: "<",
    matchRegExp: /<<$/,
    performUpdate: (instance, delta, settings) => {
        delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [
            "«",
        ]);
    },
    performRevert: (instance, delta, settings) => {
        if (instance.getRange(delta.from, delta.to) === "«") {
            delta.update(delta.from, delta.to, ["<<"]);
        }
    },
};
const legacyDashRules = [enDash, emDash, trippleDash];
const legacyEllipsisRules = [ellipsis];
const legacySmartQuoteRules = [
    openDoubleQuote,
    closeDoubleQuote,
    pairedDoubleQuote,
    wrappedDoubleQuote,
    openSingleQuote,
    closeSingleQuote,
    pairedSingleQuote,
    wrappedSingleQuote,
];
const legacyComparisonRules = [
    lessThanOrEqualTo,
    greaterThanOrEqualTo,
    notEqualTo,
];
const legacyArrowRules = [leftArrow, rightArrow];
const legacyGuillemetRules = [leftGuillemet, rightGuillemet];

const DEFAULT_SETTINGS = {
    curlyQuotes: true,
    emDash: true,
    ellipsis: true,
    arrows: true,
    comparisons: true,
    fractions: false,
    guillemets: false,
    skipEnDash: false,
    openSingle: "‘",
    closeSingle: "’",
    openDouble: "“",
    closeDouble: "”",
    openGuillemet: "«",
    closeGuillemet: "»",
    leftArrow: "←",
    rightArrow: "→",
};
class SmartTypography extends obsidian.Plugin {
    constructor() {
        super(...arguments);
        this.beforeChangeHandler = (instance, delta) => {
            if (this.legacyLastUpdate.has(instance) && delta.origin === "+delete") {
                const revert = this.legacyLastUpdate.get(instance).performRevert;
                if (revert) {
                    revert(instance, delta, this.settings);
                    this.legacyLastUpdate.delete(instance);
                }
                return;
            }
            if (delta.origin === undefined && delta.text.length === 1) {
                const input = delta.text[0];
                for (let rule of this.legacyInputRules) {
                    if (!(rule.matchTrigger instanceof RegExp)) {
                        continue;
                    }
                    if (rule.matchTrigger.test(input)) {
                        rule.performUpdate(instance, delta, this.settings);
                        return;
                    }
                }
                return;
            }
            if (delta.origin === "+input" && delta.text.length === 1) {
                const input = delta.text[0];
                const rules = this.legacyInputRules.filter((r) => {
                    return typeof r.matchTrigger === "string" && r.matchTrigger === input;
                });
                if (rules.length === 0) {
                    if (this.legacyLastUpdate.has(instance)) {
                        this.legacyLastUpdate.delete(instance);
                    }
                    return;
                }
                let str = input;
                if (delta.to.ch > 0) {
                    str = `${instance.getRange({ line: delta.to.line, ch: 0 }, delta.to)}${str}`;
                }
                for (let rule of rules) {
                    if (rule.matchRegExp && rule.matchRegExp.test(str)) {
                        if (shouldCheckTextAtPos(instance, delta.from) &&
                            shouldCheckTextAtPos(instance, delta.to)) {
                            this.legacyLastUpdate.set(instance, rule);
                            rule.performUpdate(instance, delta, this.settings);
                        }
                        return;
                    }
                }
            }
            if (this.legacyLastUpdate.has(instance)) {
                this.legacyLastUpdate.delete(instance);
            }
        };
    }
    buildInputRules() {
        this.legacyInputRules = [];
        this.inputRules = [];
        this.inputRuleMap = {};
        if (this.settings.emDash) {
            if (this.settings.skipEnDash) {
                this.inputRules.push(...dashRulesSansEnDash);
            }
            else {
                this.inputRules.push(...dashRules);
            }
            this.legacyInputRules.push(...legacyDashRules);
        }
        if (this.settings.ellipsis) {
            this.inputRules.push(...ellipsisRules);
            this.legacyInputRules.push(...legacyEllipsisRules);
        }
        if (this.settings.curlyQuotes) {
            this.inputRules.push(...smartQuoteRules);
            this.legacyInputRules.push(...legacySmartQuoteRules);
        }
        if (this.settings.arrows) {
            this.inputRules.push(...arrowRules);
            this.legacyInputRules.push(...legacyArrowRules);
        }
        if (this.settings.guillemets) {
            this.inputRules.push(...guillemetRules);
            this.legacyInputRules.push(...legacyGuillemetRules);
        }
        if (this.settings.comparisons) {
            this.inputRules.push(...comparisonRules);
            this.legacyInputRules.push(...legacyComparisonRules);
        }
        if (this.settings.fractions) {
            this.inputRules.push(...fractionRules);
        }
        this.inputRules.forEach((rule) => {
            if (this.inputRuleMap[rule.trigger] === undefined) {
                this.inputRuleMap[rule.trigger] = [];
            }
            this.inputRuleMap[rule.trigger].push(rule);
        });
    }
    onload() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.loadSettings();
            this.addSettingTab(new SmartTypographySettingTab(this.app, this));
            // Codemirror 6
            //
            // When smart typography overrides changes, we want to keep a record
            // so we can undo them when the user presses backspace
            const storeTransaction = state.StateEffect.define();
            const prevTransactionState = state.StateField.define({
                create() {
                    return null;
                },
                update(oldVal, tr) {
                    for (let e of tr.effects) {
                        if (e.is(storeTransaction)) {
                            return e.value;
                        }
                    }
                    if (!oldVal ||
                        tr.isUserEvent("input") ||
                        tr.isUserEvent("delete.forward") ||
                        tr.isUserEvent("delete.cut") ||
                        tr.isUserEvent("move") ||
                        tr.isUserEvent("select") ||
                        tr.isUserEvent("undo")) {
                        return null;
                    }
                    return oldVal;
                },
            });
            this.registerEditorExtension([
                prevTransactionState,
                state.EditorState.transactionFilter.of((tr) => {
                    // Revert any stored changes on delete
                    if (tr.isUserEvent("delete.backward") ||
                        tr.isUserEvent("delete.selection")) {
                        return tr.startState.field(prevTransactionState, false) || tr;
                    }
                    // If the user hasn't typed, or the doc hasn't changed, return early
                    if (!tr.isUserEvent("input.type") || !tr.docChanged) {
                        return tr;
                    }
                    // Cache the syntax tree if we end up accessing it
                    let tree = null;
                    // Memoize any positions we check so we can avoid some work
                    const seenPositions = {};
                    const canPerformReplacement = (pos) => {
                        if (seenPositions[pos] !== undefined) {
                            return seenPositions[pos];
                        }
                        if (!tree)
                            tree = language.syntaxTree(tr.state);
                        const nodeProps = tree
                            .resolveInner(pos, 1)
                            .type.prop(language.tokenClassNodeProp);
                        if (nodeProps && ignoreListRegEx.test(nodeProps)) {
                            seenPositions[pos] = false;
                        }
                        else {
                            seenPositions[pos] = true;
                        }
                        return seenPositions[pos];
                    };
                    // Store a list of changes and specs to revert these changes
                    const changes = [];
                    const reverts = [];
                    const registerChange = (change, revert) => {
                        changes.push(change);
                        reverts.push(revert);
                    };
                    const contextCache = {};
                    let newSelection = tr.selection;
                    tr.changes.iterChanges((fromA, toA, fromB, toB, inserted) => {
                        const insertedText = inserted.sliceString(0, 0 + inserted.length);
                        const matchedRules = this.inputRuleMap[insertedText];
                        if (!matchedRules) {
                            return;
                        }
                        for (let rule of matchedRules) {
                            // If we're in a codeblock, etc, return early, no need to continue checking
                            if (!canPerformReplacement(fromA))
                                return;
                            // Grab and cache three chars before the one being inserted
                            if (contextCache[fromA] === undefined) {
                                contextCache[fromA] = tr.newDoc.sliceString(fromB - 3, fromB);
                            }
                            const context = contextCache[fromA];
                            if (!rule.contextMatch.test(context)) {
                                continue;
                            }
                            const insert = typeof rule.to === "string" ? rule.to : rule.to(this.settings);
                            const replacementLength = rule.from.length - rule.trigger.length;
                            const insertionPoint = fromA - replacementLength;
                            const reversionPoint = fromB - replacementLength;
                            registerChange({
                                from: insertionPoint,
                                to: insertionPoint + replacementLength,
                                insert,
                            }, {
                                from: reversionPoint,
                                to: reversionPoint + insert.length,
                                insert: rule.from,
                            });
                            const selectionAdjustment = rule.from.length - insert.length;
                            newSelection = state.EditorSelection.create(newSelection.ranges.map((r) => state.EditorSelection.range(r.anchor - selectionAdjustment, r.head - selectionAdjustment)));
                            return;
                        }
                    }, false);
                    // If we have any changes, construct a transaction spec
                    if (changes.length) {
                        return [
                            {
                                effects: storeTransaction.of({
                                    effects: storeTransaction.of(null),
                                    selection: tr.selection,
                                    scrollIntoView: tr.scrollIntoView,
                                    changes: reverts,
                                }),
                                selection: newSelection,
                                scrollIntoView: tr.scrollIntoView,
                                changes,
                            },
                        ];
                    }
                    return tr;
                }),
            ]);
            // Codemirror 5
            this.legacyLastUpdate = new WeakMap();
            this.registerCodeMirror((cm) => {
                cm.on("beforeChange", this.beforeChangeHandler);
            });
        });
    }
    onunload() {
        this.legacyLastUpdate = null;
        this.app.workspace.iterateCodeMirrors((cm) => {
            cm.off("beforeChange", this.beforeChangeHandler);
        });
    }
    loadSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
            this.buildInputRules();
        });
    }
    saveSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            this.buildInputRules();
            yield this.saveData(this.settings);
        });
    }
}
class SmartTypographySettingTab extends obsidian.PluginSettingTab {
    constructor(app, plugin) {
        super(app, plugin);
        this.plugin = plugin;
    }
    display() {
        let { containerEl } = this;
        containerEl.empty();
        new obsidian.Setting(containerEl)
            .setName("Curly Quotes")
            .setDesc("Double and single quotes will be converted to curly quotes (“” & ‘’)")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.curlyQuotes)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.curlyQuotes = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Open double quote character")
            .addText((text) => {
            text
                .setValue(this.plugin.settings.openDouble)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.openDouble = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Close double quote character")
            .addText((text) => {
            text
                .setValue(this.plugin.settings.closeDouble)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.closeDouble = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Open single quote character")
            .addText((text) => {
            text
                .setValue(this.plugin.settings.openSingle)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.openSingle = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Close single quote character")
            .addText((text) => {
            text
                .setValue(this.plugin.settings.closeSingle)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.closeSingle = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Dashes")
            .setDesc("Two dashes (--) will be converted to an en-dash (–). And en-dash followed by a dash will be converted to and em-dash (—). An em-dash followed by a dash will be converted into three dashes (---)")
            .addToggle((toggle) => {
            toggle.setValue(this.plugin.settings.emDash).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.emDash = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Skip en-dash")
            .setDesc("When enabled, two dashes will be converted to an em-dash rather than an en-dash.")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.skipEnDash)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.skipEnDash = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Ellipsis")
            .setDesc("Three periods (...) will be converted to an ellipses (…)")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.ellipsis)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.ellipsis = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Guillemets")
            .setDesc("<< | >> will be converted to « | »")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.guillemets)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.guillemets = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl).setName("Open guillemet").addText((text) => {
            text
                .setValue(this.plugin.settings.openGuillemet)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                this.plugin.settings.openGuillemet = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl).setName("Close guillemet").addText((text) => {
            text
                .setValue(this.plugin.settings.closeGuillemet)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                this.plugin.settings.closeGuillemet = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Arrows")
            .setDesc("<- | -> will be converted to ← | →")
            .addToggle((toggle) => {
            toggle.setValue(this.plugin.settings.arrows).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.arrows = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl).setName("Left arrow character").addText((text) => {
            text.setValue(this.plugin.settings.leftArrow).onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.leftArrow = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Right arrow character")
            .addText((text) => {
            text
                .setValue(this.plugin.settings.rightArrow)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                if (!value)
                    return;
                if (value.length > 1) {
                    text.setValue(value[0]);
                    return;
                }
                this.plugin.settings.rightArrow = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Comparison")
            .setDesc("<= | >= | /= will be converted to ≤ | ≥ | ≠")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.comparisons)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.comparisons = value;
                yield this.plugin.saveSettings();
            }));
        });
        new obsidian.Setting(containerEl)
            .setName("Fractions")
            .setDesc("1/2 will be converted to ½. Supported UTF-8 fractions: ½, ⅓, ⅔, ¼, ¾, ⅕, ⅖, ⅗, ⅘, ⅙, ⅚, ⅐, ⅛, ⅜, ⅝, ⅞, ⅑, ⅒")
            .addToggle((toggle) => {
            toggle
                .setValue(this.plugin.settings.fractions)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.fractions = value;
                yield this.plugin.saveSettings();
            }));
        });
    }
}
const ignoreListRegEx = /frontmatter|code|math|templater|hashtag/;
function shouldCheckTextAtPos(instance, pos) {
    // Empty line
    if (!instance.getLine(pos.line)) {
        return true;
    }
    const tokens = instance.getTokenTypeAt(pos);
    // Plain text line
    if (!tokens) {
        return true;
    }
    // Not codeblock or frontmatter
    if (!ignoreListRegEx.test(tokens)) {
        return true;
    }
    return false;
}

module.exports = SmartTypography;

/* nosourcemap */