diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json
index 1b54d97..2485229 100644
--- a/.obsidian/community-plugins.json
+++ b/.obsidian/community-plugins.json
@@ -1,5 +1,6 @@
 [
   "obsidian-full-calendar",
   "obsidian-icon-folder",
-  "obsidian-git"
+  "obsidian-git",
+  "obsidian-smart-typography"
 ]
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-smart-typography/main.js b/.obsidian/plugins/obsidian-smart-typography/main.js
new file mode 100644
index 0000000..6bdad05
--- /dev/null
+++ b/.obsidian/plugins/obsidian-smart-typography/main.js
@@ -0,0 +1,1062 @@
+/*
+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 */
\ No newline at end of file
diff --git a/.obsidian/plugins/obsidian-smart-typography/manifest.json b/.obsidian/plugins/obsidian-smart-typography/manifest.json
new file mode 100644
index 0000000..bbbb76b
--- /dev/null
+++ b/.obsidian/plugins/obsidian-smart-typography/manifest.json
@@ -0,0 +1,10 @@
+{
+	"id": "obsidian-smart-typography",
+	"name": "Smart Typography",
+	"version": "1.0.18",
+	"minAppVersion": "0.15.0",
+	"description": "Converts quotes to curly quotes, dashes to em dashes, and periods to ellipses",
+	"author": "mgmeyers",
+	"authorUrl": "https://github.com/mgmeyers/obsidian-smart-typography",
+	"isDesktopOnly": false
+}
diff --git a/WORK & PROJECTS/Mol/Серверы/Alfa cloud readme.md b/WORK & PROJECTS/Mol/Серверы/Alfa cloud readme.md
index 0e99236..75798e7 100644
--- a/WORK & PROJECTS/Mol/Серверы/Alfa cloud readme.md	
+++ b/WORK & PROJECTS/Mol/Серверы/Alfa cloud readme.md	
@@ -1 +1,4 @@
-Серверный API, который пре
\ No newline at end of file
+Alfa Cloud — серверный API, который предоставляет доступ к управлению контейнерами и конфигурацией облаков с поддержкой нескольких облачных серверов.
+
+
+