pyegeria 5.4.0.15__py3-none-any.whl → 5.4.0.17__py3-none-any.whl

md_processing/dr_egeria_outbox/.obsidian/plugins/calendar/main.js

@@ -0,0 +1,4459 @@
+'use strict';
+
+var obsidian = require('obsidian');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var obsidian__default = /*#__PURE__*/_interopDefaultLegacy(obsidian);
+
+const DEFAULT_WEEK_FORMAT = "gggg-[W]ww";
+const DEFAULT_WORDS_PER_DOT = 250;
+const VIEW_TYPE_CALENDAR = "calendar";
+const TRIGGER_ON_OPEN = "calendar:open";
+
+const DEFAULT_DAILY_NOTE_FORMAT = "YYYY-MM-DD";
+const DEFAULT_WEEKLY_NOTE_FORMAT = "gggg-[W]ww";
+const DEFAULT_MONTHLY_NOTE_FORMAT = "YYYY-MM";
+
+function shouldUsePeriodicNotesSettings(periodicity) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const periodicNotes = window.app.plugins.getPlugin("periodic-notes");
+    return periodicNotes && periodicNotes.settings?.[periodicity]?.enabled;
+}
+/**
+ * Read the user settings for the `daily-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getDailyNoteSettings() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { internalPlugins, plugins } = window.app;
+        if (shouldUsePeriodicNotesSettings("daily")) {
+            const { format, folder, template } = plugins.getPlugin("periodic-notes")?.settings?.daily || {};
+            return {
+                format: format || DEFAULT_DAILY_NOTE_FORMAT,
+                folder: folder?.trim() || "",
+                template: template?.trim() || "",
+            };
+        }
+        const { folder, format, template } = internalPlugins.getPluginById("daily-notes")?.instance?.options || {};
+        return {
+            format: format || DEFAULT_DAILY_NOTE_FORMAT,
+            folder: folder?.trim() || "",
+            template: template?.trim() || "",
+        };
+    }
+    catch (err) {
+        console.info("No custom daily note settings found!", err);
+    }
+}
+/**
+ * Read the user settings for the `weekly-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getWeeklyNoteSettings() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const pluginManager = window.app.plugins;
+        const calendarSettings = pluginManager.getPlugin("calendar")?.options;
+        const periodicNotesSettings = pluginManager.getPlugin("periodic-notes")
+            ?.settings?.weekly;
+        if (shouldUsePeriodicNotesSettings("weekly")) {
+            return {
+                format: periodicNotesSettings.format || DEFAULT_WEEKLY_NOTE_FORMAT,
+                folder: periodicNotesSettings.folder?.trim() || "",
+                template: periodicNotesSettings.template?.trim() || "",
+            };
+        }
+        const settings = calendarSettings || {};
+        return {
+            format: settings.weeklyNoteFormat || DEFAULT_WEEKLY_NOTE_FORMAT,
+            folder: settings.weeklyNoteFolder?.trim() || "",
+            template: settings.weeklyNoteTemplate?.trim() || "",
+        };
+    }
+    catch (err) {
+        console.info("No custom weekly note settings found!", err);
+    }
+}
+/**
+ * Read the user settings for the `periodic-notes` plugin
+ * to keep behavior of creating a new note in-sync.
+ */
+function getMonthlyNoteSettings() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const pluginManager = window.app.plugins;
+    try {
+        const settings = (shouldUsePeriodicNotesSettings("monthly") &&
+            pluginManager.getPlugin("periodic-notes")?.settings?.monthly) ||
+            {};
+        return {
+            format: settings.format || DEFAULT_MONTHLY_NOTE_FORMAT,
+            folder: settings.folder?.trim() || "",
+            template: settings.template?.trim() || "",
+        };
+    }
+    catch (err) {
+        console.info("No custom monthly note settings found!", err);
+    }
+}
+
+/**
+ * dateUID is a way of weekly identifying daily/weekly/monthly notes.
+ * They are prefixed with the granularity to avoid ambiguity.
+ */
+function getDateUID$1(date, granularity = "day") {
+    const ts = date.clone().startOf(granularity).format();
+    return `${granularity}-${ts}`;
+}
+function removeEscapedCharacters(format) {
+    return format.replace(/\[[^\]]*\]/g, ""); // remove everything within brackets
+}
+/**
+ * XXX: When parsing dates that contain both week numbers and months,
+ * Moment choses to ignore the week numbers. For the week dateUID, we
+ * want the opposite behavior. Strip the MMM from the format to patch.
+ */
+function isFormatAmbiguous(format, granularity) {
+    if (granularity === "week") {
+        const cleanFormat = removeEscapedCharacters(format);
+        return (/w{1,2}/i.test(cleanFormat) &&
+            (/M{1,4}/.test(cleanFormat) || /D{1,4}/.test(cleanFormat)));
+    }
+    return false;
+}
+function getDateFromFile(file, granularity) {
+    const getSettings = {
+        day: getDailyNoteSettings,
+        week: getWeeklyNoteSettings,
+        month: getMonthlyNoteSettings,
+    };
+    const format = getSettings[granularity]().format.split("/").pop();
+    const noteDate = window.moment(file.basename, format, true);
+    if (!noteDate.isValid()) {
+        return null;
+    }
+    if (isFormatAmbiguous(format, granularity)) {
+        if (granularity === "week") {
+            const cleanFormat = removeEscapedCharacters(format);
+            if (/w{1,2}/i.test(cleanFormat)) {
+                return window.moment(file.basename, 
+                // If format contains week, remove day & month formatting
+                format.replace(/M{1,4}/g, "").replace(/D{1,4}/g, ""), false);
+            }
+        }
+    }
+    return noteDate;
+}
+
+// Credit: @creationix/path.js
+function join(...partSegments) {
+    // Split the inputs into a list of path commands.
+    let parts = [];
+    for (let i = 0, l = partSegments.length; i < l; i++) {
+        parts = parts.concat(partSegments[i].split("/"));
+    }
+    // Interpret the path commands to get the new resolved path.
+    const newParts = [];
+    for (let i = 0, l = parts.length; i < l; i++) {
+        const part = parts[i];
+        // Remove leading and trailing slashes
+        // Also remove "." segments
+        if (!part || part === ".")
+            continue;
+        // Push new path segments.
+        else
+            newParts.push(part);
+    }
+    // Preserve the initial slash if there was one.
+    if (parts[0] === "")
+        newParts.unshift("");
+    // Turn back into a single string path.
+    return newParts.join("/");
+}
+async function ensureFolderExists(path) {
+    const dirs = path.replace(/\\/g, "/").split("/");
+    dirs.pop(); // remove basename
+    if (dirs.length) {
+        const dir = join(...dirs);
+        if (!window.app.vault.getAbstractFileByPath(dir)) {
+            await window.app.vault.createFolder(dir);
+        }
+    }
+}
+async function getNotePath(directory, filename) {
+    if (!filename.endsWith(".md")) {
+        filename += ".md";
+    }
+    const path = obsidian__default['default'].normalizePath(join(directory, filename));
+    await ensureFolderExists(path);
+    return path;
+}
+async function getTemplateInfo(template) {
+    const { metadataCache, vault } = window.app;
+    const templatePath = obsidian__default['default'].normalizePath(template);
+    if (templatePath === "/") {
+        return Promise.resolve(["", null]);
+    }
+    try {
+        const templateFile = metadataCache.getFirstLinkpathDest(templatePath, "");
+        const contents = await vault.cachedRead(templateFile);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const IFoldInfo = window.app.foldManager.load(templateFile);
+        return [contents, IFoldInfo];
+    }
+    catch (err) {
+        console.error(`Failed to read the daily note template '${templatePath}'`, err);
+        new obsidian__default['default'].Notice("Failed to read the daily note template");
+        return ["", null];
+    }
+}
+
+class DailyNotesFolderMissingError extends Error {
+}
+/**
+ * This function mimics the behavior of the daily-notes plugin
+ * so it will replace {{date}}, {{title}}, and {{time}} with the
+ * formatted timestamp.
+ *
+ * Note: it has an added bonus that it's not 'today' specific.
+ */
+async function createDailyNote(date) {
+    const app = window.app;
+    const { vault } = app;
+    const moment = window.moment;
+    const { template, format, folder } = getDailyNoteSettings();
+    const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+    const filename = date.format(format);
+    const normalizedPath = await getNotePath(folder, filename);
+    try {
+        const createdFile = await vault.create(normalizedPath, templateContents
+            .replace(/{{\s*date\s*}}/gi, filename)
+            .replace(/{{\s*time\s*}}/gi, moment().format("HH:mm"))
+            .replace(/{{\s*title\s*}}/gi, filename)
+            .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+            const now = moment();
+            const currentDate = date.clone().set({
+                hour: now.get("hour"),
+                minute: now.get("minute"),
+                second: now.get("second"),
+            });
+            if (calc) {
+                currentDate.add(parseInt(timeDelta, 10), unit);
+            }
+            if (momentFormat) {
+                return currentDate.format(momentFormat.substring(1).trim());
+            }
+            return currentDate.format(format);
+        })
+            .replace(/{{\s*yesterday\s*}}/gi, date.clone().subtract(1, "day").format(format))
+            .replace(/{{\s*tomorrow\s*}}/gi, date.clone().add(1, "d").format(format)));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        app.foldManager.save(createdFile, IFoldInfo);
+        return createdFile;
+    }
+    catch (err) {
+        console.error(`Failed to create file: '${normalizedPath}'`, err);
+        new obsidian__default['default'].Notice("Unable to create new file.");
+    }
+}
+function getDailyNote(date, dailyNotes) {
+    return dailyNotes[getDateUID$1(date, "day")] ?? null;
+}
+function getAllDailyNotes() {
+    /**
+     * Find all daily notes in the daily note folder
+     */
+    const { vault } = window.app;
+    const { folder } = getDailyNoteSettings();
+    const dailyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+    if (!dailyNotesFolder) {
+        throw new DailyNotesFolderMissingError("Failed to find daily notes folder");
+    }
+    const dailyNotes = {};
+    obsidian__default['default'].Vault.recurseChildren(dailyNotesFolder, (note) => {
+        if (note instanceof obsidian__default['default'].TFile) {
+            const date = getDateFromFile(note, "day");
+            if (date) {
+                const dateString = getDateUID$1(date, "day");
+                dailyNotes[dateString] = note;
+            }
+        }
+    });
+    return dailyNotes;
+}
+
+class WeeklyNotesFolderMissingError extends Error {
+}
+function getDaysOfWeek$1() {
+    const { moment } = window;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let weekStart = moment.localeData()._week.dow;
+    const daysOfWeek = [
+        "sunday",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+    ];
+    while (weekStart) {
+        daysOfWeek.push(daysOfWeek.shift());
+        weekStart--;
+    }
+    return daysOfWeek;
+}
+function getDayOfWeekNumericalValue(dayOfWeekName) {
+    return getDaysOfWeek$1().indexOf(dayOfWeekName.toLowerCase());
+}
+async function createWeeklyNote(date) {
+    const { vault } = window.app;
+    const { template, format, folder } = getWeeklyNoteSettings();
+    const [templateContents, IFoldInfo] = await getTemplateInfo(template);
+    const filename = date.format(format);
+    const normalizedPath = await getNotePath(folder, filename);
+    try {
+        const createdFile = await vault.create(normalizedPath, templateContents
+            .replace(/{{\s*(date|time)\s*(([+-]\d+)([yqmwdhs]))?\s*(:.+?)?}}/gi, (_, _timeOrDate, calc, timeDelta, unit, momentFormat) => {
+            const now = window.moment();
+            const currentDate = date.clone().set({
+                hour: now.get("hour"),
+                minute: now.get("minute"),
+                second: now.get("second"),
+            });
+            if (calc) {
+                currentDate.add(parseInt(timeDelta, 10), unit);
+            }
+            if (momentFormat) {
+                return currentDate.format(momentFormat.substring(1).trim());
+            }
+            return currentDate.format(format);
+        })
+            .replace(/{{\s*title\s*}}/gi, filename)
+            .replace(/{{\s*time\s*}}/gi, window.moment().format("HH:mm"))
+            .replace(/{{\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s*:(.*?)}}/gi, (_, dayOfWeek, momentFormat) => {
+            const day = getDayOfWeekNumericalValue(dayOfWeek);
+            return date.weekday(day).format(momentFormat.trim());
+        }));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        window.app.foldManager.save(createdFile, IFoldInfo);
+        return createdFile;
+    }
+    catch (err) {
+        console.error(`Failed to create file: '${normalizedPath}'`, err);
+        new obsidian__default['default'].Notice("Unable to create new file.");
+    }
+}
+function getWeeklyNote(date, weeklyNotes) {
+    return weeklyNotes[getDateUID$1(date, "week")] ?? null;
+}
+function getAllWeeklyNotes() {
+    const { vault } = window.app;
+    const { folder } = getWeeklyNoteSettings();
+    const weeklyNotesFolder = vault.getAbstractFileByPath(obsidian__default['default'].normalizePath(folder));
+    if (!weeklyNotesFolder) {
+        throw new WeeklyNotesFolderMissingError("Failed to find weekly notes folder");
+    }
+    const weeklyNotes = {};
+    obsidian__default['default'].Vault.recurseChildren(weeklyNotesFolder, (note) => {
+        if (note instanceof obsidian__default['default'].TFile) {
+            const date = getDateFromFile(note, "week");
+            if (date) {
+                const dateString = getDateUID$1(date, "week");
+                weeklyNotes[dateString] = note;
+            }
+        }
+    });
+    return weeklyNotes;
+}
+
+function appHasDailyNotesPluginLoaded() {
+    const { app } = window;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const dailyNotesPlugin = app.internalPlugins.plugins["daily-notes"];
+    if (dailyNotesPlugin && dailyNotesPlugin.enabled) {
+        return true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const periodicNotes = app.plugins.getPlugin("periodic-notes");
+    return periodicNotes && periodicNotes.settings?.daily?.enabled;
+}
+var appHasDailyNotesPluginLoaded_1 = appHasDailyNotesPluginLoaded;
+var createDailyNote_1 = createDailyNote;
+var createWeeklyNote_1 = createWeeklyNote;
+var getAllDailyNotes_1 = getAllDailyNotes;
+var getAllWeeklyNotes_1 = getAllWeeklyNotes;
+var getDailyNote_1 = getDailyNote;
+var getDailyNoteSettings_1 = getDailyNoteSettings;
+var getDateFromFile_1 = getDateFromFile;
+var getDateUID_1$1 = getDateUID$1;
+var getWeeklyNote_1 = getWeeklyNote;
+var getWeeklyNoteSettings_1 = getWeeklyNoteSettings;
+
+function noop$1() { }
+function run$1(fn) {
+    return fn();
+}
+function blank_object$1() {
+    return Object.create(null);
+}
+function run_all$1(fns) {
+    fns.forEach(run$1);
+}
+function is_function$1(thing) {
+    return typeof thing === 'function';
+}
+function safe_not_equal$1(a, b) {
+    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+}
+function not_equal$1(a, b) {
+    return a != a ? b == b : a !== b;
+}
+function is_empty$1(obj) {
+    return Object.keys(obj).length === 0;
+}
+function subscribe(store, ...callbacks) {
+    if (store == null) {
+        return noop$1;
+    }
+    const unsub = store.subscribe(...callbacks);
+    return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
+}
+function get_store_value(store) {
+    let value;
+    subscribe(store, _ => value = _)();
+    return value;
+}
+function component_subscribe(component, store, callback) {
+    component.$$.on_destroy.push(subscribe(store, callback));
+}
+function detach$1(node) {
+    node.parentNode.removeChild(node);
+}
+function children$1(element) {
+    return Array.from(element.childNodes);
+}
+
+let current_component$1;
+function set_current_component$1(component) {
+    current_component$1 = component;
+}
+function get_current_component$1() {
+    if (!current_component$1)
+        throw new Error('Function called outside component initialization');
+    return current_component$1;
+}
+function onDestroy(fn) {
+    get_current_component$1().$$.on_destroy.push(fn);
+}
+
+const dirty_components$1 = [];
+const binding_callbacks$1 = [];
+const render_callbacks$1 = [];
+const flush_callbacks$1 = [];
+const resolved_promise$1 = Promise.resolve();
+let update_scheduled$1 = false;
+function schedule_update$1() {
+    if (!update_scheduled$1) {
+        update_scheduled$1 = true;
+        resolved_promise$1.then(flush$1);
+    }
+}
+function add_render_callback$1(fn) {
+    render_callbacks$1.push(fn);
+}
+function add_flush_callback(fn) {
+    flush_callbacks$1.push(fn);
+}
+let flushing$1 = false;
+const seen_callbacks$1 = new Set();
+function flush$1() {
+    if (flushing$1)
+        return;
+    flushing$1 = true;
+    do {
+        // first, call beforeUpdate functions
+        // and update components
+        for (let i = 0; i < dirty_components$1.length; i += 1) {
+            const component = dirty_components$1[i];
+            set_current_component$1(component);
+            update$1(component.$$);
+        }
+        set_current_component$1(null);
+        dirty_components$1.length = 0;
+        while (binding_callbacks$1.length)
+            binding_callbacks$1.pop()();
+        // then, once components are updated, call
+        // afterUpdate functions. This may cause
+        // subsequent updates...
+        for (let i = 0; i < render_callbacks$1.length; i += 1) {
+            const callback = render_callbacks$1[i];
+            if (!seen_callbacks$1.has(callback)) {
+                // ...so guard against infinite loops
+                seen_callbacks$1.add(callback);
+                callback();
+            }
+        }
+        render_callbacks$1.length = 0;
+    } while (dirty_components$1.length);
+    while (flush_callbacks$1.length) {
+        flush_callbacks$1.pop()();
+    }
+    update_scheduled$1 = false;
+    flushing$1 = false;
+    seen_callbacks$1.clear();
+}
+function update$1($$) {
+    if ($$.fragment !== null) {
+        $$.update();
+        run_all$1($$.before_update);
+        const dirty = $$.dirty;
+        $$.dirty = [-1];
+        $$.fragment && $$.fragment.p($$.ctx, dirty);
+        $$.after_update.forEach(add_render_callback$1);
+    }
+}
+const outroing$1 = new Set();
+let outros$1;
+function transition_in$1(block, local) {
+    if (block && block.i) {
+        outroing$1.delete(block);
+        block.i(local);
+    }
+}
+function transition_out$1(block, local, detach, callback) {
+    if (block && block.o) {
+        if (outroing$1.has(block))
+            return;
+        outroing$1.add(block);
+        outros$1.c.push(() => {
+            outroing$1.delete(block);
+            if (callback) {
+                if (detach)
+                    block.d(1);
+                callback();
+            }
+        });
+        block.o(local);
+    }
+}
+
+function bind(component, name, callback) {
+    const index = component.$$.props[name];
+    if (index !== undefined) {
+        component.$$.bound[index] = callback;
+        callback(component.$$.ctx[index]);
+    }
+}
+function create_component$1(block) {
+    block && block.c();
+}
+function mount_component$1(component, target, anchor, customElement) {
+    const { fragment, on_mount, on_destroy, after_update } = component.$$;
+    fragment && fragment.m(target, anchor);
+    if (!customElement) {
+        // onMount happens before the initial afterUpdate
+        add_render_callback$1(() => {
+            const new_on_destroy = on_mount.map(run$1).filter(is_function$1);
+            if (on_destroy) {
+                on_destroy.push(...new_on_destroy);
+            }
+            else {
+                // Edge case - component was destroyed immediately,
+                // most likely as a result of a binding initialising
+                run_all$1(new_on_destroy);
+            }
+            component.$$.on_mount = [];
+        });
+    }
+    after_update.forEach(add_render_callback$1);
+}
+function destroy_component$1(component, detaching) {
+    const $$ = component.$$;
+    if ($$.fragment !== null) {
+        run_all$1($$.on_destroy);
+        $$.fragment && $$.fragment.d(detaching);
+        // TODO null out other refs, including component.$$ (but need to
+        // preserve final state?)
+        $$.on_destroy = $$.fragment = null;
+        $$.ctx = [];
+    }
+}
+function make_dirty$1(component, i) {
+    if (component.$$.dirty[0] === -1) {
+        dirty_components$1.push(component);
+        schedule_update$1();
+        component.$$.dirty.fill(0);
+    }
+    component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
+}
+function init$1(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
+    const parent_component = current_component$1;
+    set_current_component$1(component);
+    const $$ = component.$$ = {
+        fragment: null,
+        ctx: null,
+        // state
+        props,
+        update: noop$1,
+        not_equal,
+        bound: blank_object$1(),
+        // lifecycle
+        on_mount: [],
+        on_destroy: [],
+        on_disconnect: [],
+        before_update: [],
+        after_update: [],
+        context: new Map(parent_component ? parent_component.$$.context : []),
+        // everything else
+        callbacks: blank_object$1(),
+        dirty,
+        skip_bound: false
+    };
+    let ready = false;
+    $$.ctx = instance
+        ? instance(component, options.props || {}, (i, ret, ...rest) => {
+            const value = rest.length ? rest[0] : ret;
+            if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+                if (!$$.skip_bound && $$.bound[i])
+                    $$.bound[i](value);
+                if (ready)
+                    make_dirty$1(component, i);
+            }
+            return ret;
+        })
+        : [];
+    $$.update();
+    ready = true;
+    run_all$1($$.before_update);
+    // `false` as a special case of no DOM component
+    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
+    if (options.target) {
+        if (options.hydrate) {
+            const nodes = children$1(options.target);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            $$.fragment && $$.fragment.l(nodes);
+            nodes.forEach(detach$1);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            $$.fragment && $$.fragment.c();
+        }
+        if (options.intro)
+            transition_in$1(component.$$.fragment);
+        mount_component$1(component, options.target, options.anchor, options.customElement);
+        flush$1();
+    }
+    set_current_component$1(parent_component);
+}
+/**
+ * Base class for Svelte components. Used when dev=false.
+ */
+class SvelteComponent$1 {
+    $destroy() {
+        destroy_component$1(this, 1);
+        this.$destroy = noop$1;
+    }
+    $on(type, callback) {
+        const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
+        callbacks.push(callback);
+        return () => {
+            const index = callbacks.indexOf(callback);
+            if (index !== -1)
+                callbacks.splice(index, 1);
+        };
+    }
+    $set($$props) {
+        if (this.$$set && !is_empty$1($$props)) {
+            this.$$.skip_bound = true;
+            this.$$set($$props);
+            this.$$.skip_bound = false;
+        }
+    }
+}
+
+const subscriber_queue = [];
+/**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+function writable(value, start = noop$1) {
+    let stop;
+    const subscribers = [];
+    function set(new_value) {
+        if (safe_not_equal$1(value, new_value)) {
+            value = new_value;
+            if (stop) { // store is ready
+                const run_queue = !subscriber_queue.length;
+                for (let i = 0; i < subscribers.length; i += 1) {
+                    const s = subscribers[i];
+                    s[1]();
+                    subscriber_queue.push(s, value);
+                }
+                if (run_queue) {
+                    for (let i = 0; i < subscriber_queue.length; i += 2) {
+                        subscriber_queue[i][0](subscriber_queue[i + 1]);
+                    }
+                    subscriber_queue.length = 0;
+                }
+            }
+        }
+    }
+    function update(fn) {
+        set(fn(value));
+    }
+    function subscribe(run, invalidate = noop$1) {
+        const subscriber = [run, invalidate];
+        subscribers.push(subscriber);
+        if (subscribers.length === 1) {
+            stop = start(set) || noop$1;
+        }
+        run(value);
+        return () => {
+            const index = subscribers.indexOf(subscriber);
+            if (index !== -1) {
+                subscribers.splice(index, 1);
+            }
+            if (subscribers.length === 0) {
+                stop();
+                stop = null;
+            }
+        };
+    }
+    return { set, update, subscribe };
+}
+
+const weekdays$1 = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+];
+const defaultSettings = Object.freeze({
+    shouldConfirmBeforeCreate: true,
+    weekStart: "locale",
+    wordsPerDot: DEFAULT_WORDS_PER_DOT,
+    showWeeklyNote: false,
+    weeklyNoteFormat: "",
+    weeklyNoteTemplate: "",
+    weeklyNoteFolder: "",
+    localeOverride: "system-default",
+});
+function appHasPeriodicNotesPluginLoaded() {
+    var _a, _b;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const periodicNotes = window.app.plugins.getPlugin("periodic-notes");
+    return periodicNotes && ((_b = (_a = periodicNotes.settings) === null || _a === void 0 ? void 0 : _a.weekly) === null || _b === void 0 ? void 0 : _b.enabled);
+}
+class CalendarSettingsTab extends obsidian.PluginSettingTab {
+    constructor(app, plugin) {
+        super(app, plugin);
+        this.plugin = plugin;
+    }
+    display() {
+        this.containerEl.empty();
+        if (!appHasDailyNotesPluginLoaded_1()) {
+            this.containerEl.createDiv("settings-banner", (banner) => {
+                banner.createEl("h3", {
+                    text: "⚠️ Daily Notes plugin not enabled",
+                });
+                banner.createEl("p", {
+                    cls: "setting-item-description",
+                    text: "The calendar is best used in conjunction with either the Daily Notes plugin or the Periodic Notes plugin (available in the Community Plugins catalog).",
+                });
+            });
+        }
+        this.containerEl.createEl("h3", {
+            text: "General Settings",
+        });
+        this.addDotThresholdSetting();
+        this.addWeekStartSetting();
+        this.addConfirmCreateSetting();
+        this.addShowWeeklyNoteSetting();
+        if (this.plugin.options.showWeeklyNote &&
+            !appHasPeriodicNotesPluginLoaded()) {
+            this.containerEl.createEl("h3", {
+                text: "Weekly Note Settings",
+            });
+            this.containerEl.createEl("p", {
+                cls: "setting-item-description",
+                text: "Note: Weekly Note settings are moving. You are encouraged to install the 'Periodic Notes' plugin to keep the functionality in the future.",
+            });
+            this.addWeeklyNoteFormatSetting();
+            this.addWeeklyNoteTemplateSetting();
+            this.addWeeklyNoteFolderSetting();
+        }
+        this.containerEl.createEl("h3", {
+            text: "Advanced Settings",
+        });
+        this.addLocaleOverrideSetting();
+    }
+    addDotThresholdSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Words per dot")
+            .setDesc("How many words should be represented by a single dot?")
+            .addText((textfield) => {
+            textfield.setPlaceholder(String(DEFAULT_WORDS_PER_DOT));
+            textfield.inputEl.type = "number";
+            textfield.setValue(String(this.plugin.options.wordsPerDot));
+            textfield.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({
+                    wordsPerDot: value !== "" ? Number(value) : undefined,
+                }));
+            });
+        });
+    }
+    addWeekStartSetting() {
+        const { moment } = window;
+        const localizedWeekdays = moment.weekdays();
+        const localeWeekStartNum = window._bundledLocaleWeekSpec.dow;
+        const localeWeekStart = moment.weekdays()[localeWeekStartNum];
+        new obsidian.Setting(this.containerEl)
+            .setName("Start week on:")
+            .setDesc("Choose what day of the week to start. Select 'Locale default' to use the default specified by moment.js")
+            .addDropdown((dropdown) => {
+            dropdown.addOption("locale", `Locale default (${localeWeekStart})`);
+            localizedWeekdays.forEach((day, i) => {
+                dropdown.addOption(weekdays$1[i], day);
+            });
+            dropdown.setValue(this.plugin.options.weekStart);
+            dropdown.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({
+                    weekStart: value,
+                }));
+            });
+        });
+    }
+    addConfirmCreateSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Confirm before creating new note")
+            .setDesc("Show a confirmation modal before creating a new note")
+            .addToggle((toggle) => {
+            toggle.setValue(this.plugin.options.shouldConfirmBeforeCreate);
+            toggle.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({
+                    shouldConfirmBeforeCreate: value,
+                }));
+            });
+        });
+    }
+    addShowWeeklyNoteSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Show week number")
+            .setDesc("Enable this to add a column with the week number")
+            .addToggle((toggle) => {
+            toggle.setValue(this.plugin.options.showWeeklyNote);
+            toggle.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({ showWeeklyNote: value }));
+                this.display(); // show/hide weekly settings
+            });
+        });
+    }
+    addWeeklyNoteFormatSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Weekly note format")
+            .setDesc("For more syntax help, refer to format reference")
+            .addText((textfield) => {
+            textfield.setValue(this.plugin.options.weeklyNoteFormat);
+            textfield.setPlaceholder(DEFAULT_WEEK_FORMAT);
+            textfield.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({ weeklyNoteFormat: value }));
+            });
+        });
+    }
+    addWeeklyNoteTemplateSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Weekly note template")
+            .setDesc("Choose the file you want to use as the template for your weekly notes")
+            .addText((textfield) => {
+            textfield.setValue(this.plugin.options.weeklyNoteTemplate);
+            textfield.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({ weeklyNoteTemplate: value }));
+            });
+        });
+    }
+    addWeeklyNoteFolderSetting() {
+        new obsidian.Setting(this.containerEl)
+            .setName("Weekly note folder")
+            .setDesc("New weekly notes will be placed here")
+            .addText((textfield) => {
+            textfield.setValue(this.plugin.options.weeklyNoteFolder);
+            textfield.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({ weeklyNoteFolder: value }));
+            });
+        });
+    }
+    addLocaleOverrideSetting() {
+        var _a;
+        const { moment } = window;
+        const sysLocale = (_a = navigator.language) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        new obsidian.Setting(this.containerEl)
+            .setName("Override locale:")
+            .setDesc("Set this if you want to use a locale different from the default")
+            .addDropdown((dropdown) => {
+            dropdown.addOption("system-default", `Same as system (${sysLocale})`);
+            moment.locales().forEach((locale) => {
+                dropdown.addOption(locale, locale);
+            });
+            dropdown.setValue(this.plugin.options.localeOverride);
+            dropdown.onChange(async (value) => {
+                this.plugin.writeOptions(() => ({
+                    localeOverride: value,
+                }));
+            });
+        });
+    }
+}
+
+const classList = (obj) => {
+    return Object.entries(obj)
+        .filter(([_k, v]) => !!v)
+        .map(([k, _k]) => k);
+};
+function clamp(num, lowerBound, upperBound) {
+    return Math.min(Math.max(lowerBound, num), upperBound);
+}
+function partition(arr, predicate) {
+    const pass = [];
+    const fail = [];
+    arr.forEach((elem) => {
+        if (predicate(elem)) {
+            pass.push(elem);
+        }
+        else {
+            fail.push(elem);
+        }
+    });
+    return [pass, fail];
+}
+/**
+ * Lookup the dateUID for a given file. It compares the filename
+ * to the daily and weekly note formats to find a match.
+ *
+ * @param file
+ */
+function getDateUIDFromFile(file) {
+    if (!file) {
+        return null;
+    }
+    // TODO: I'm not checking the path!
+    let date = getDateFromFile_1(file, "day");
+    if (date) {
+        return getDateUID_1$1(date, "day");
+    }
+    date = getDateFromFile_1(file, "week");
+    if (date) {
+        return getDateUID_1$1(date, "week");
+    }
+    return null;
+}
+function getWordCount(text) {
+    const spaceDelimitedChars = /A-Za-z\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC/
+        .source;
+    const nonSpaceDelimitedWords = /\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u4E00-\u9FD5/
+        .source;
+    const pattern = new RegExp([
+        `(?:[0-9]+(?:(?:,|\\.)[0-9]+)*|[\\-${spaceDelimitedChars}])+`,
+        nonSpaceDelimitedWords,
+    ].join("|"), "g");
+    return (text.match(pattern) || []).length;
+}
+
+function createDailyNotesStore() {
+    let hasError = false;
+    const store = writable(null);
+    return Object.assign({ reindex: () => {
+            try {
+                const dailyNotes = getAllDailyNotes_1();
+                store.set(dailyNotes);
+                hasError = false;
+            }
+            catch (err) {
+                if (!hasError) {
+                    // Avoid error being shown multiple times
+                    console.log("[Calendar] Failed to find daily notes folder", err);
+                }
+                store.set({});
+                hasError = true;
+            }
+        } }, store);
+}
+function createWeeklyNotesStore() {
+    let hasError = false;
+    const store = writable(null);
+    return Object.assign({ reindex: () => {
+            try {
+                const weeklyNotes = getAllWeeklyNotes_1();
+                store.set(weeklyNotes);
+                hasError = false;
+            }
+            catch (err) {
+                if (!hasError) {
+                    // Avoid error being shown multiple times
+                    console.log("[Calendar] Failed to find weekly notes folder", err);
+                }
+                store.set({});
+                hasError = true;
+            }
+        } }, store);
+}
+const settings = writable(defaultSettings);
+const dailyNotes = createDailyNotesStore();
+const weeklyNotes = createWeeklyNotesStore();
+function createSelectedFileStore() {
+    const store = writable(null);
+    return Object.assign({ setFile: (file) => {
+            const id = getDateUIDFromFile(file);
+            store.set(id);
+        } }, store);
+}
+const activeFile = createSelectedFileStore();
+
+class ConfirmationModal extends obsidian.Modal {
+    constructor(app, config) {
+        super(app);
+        const { cta, onAccept, text, title } = config;
+        this.contentEl.createEl("h2", { text: title });
+        this.contentEl.createEl("p", { text });
+        this.contentEl.createDiv("modal-button-container", (buttonsEl) => {
+            buttonsEl
+                .createEl("button", { text: "Never mind" })
+                .addEventListener("click", () => this.close());
+            buttonsEl
+                .createEl("button", {
+                cls: "mod-cta",
+                text: cta,
+            })
+                .addEventListener("click", async (e) => {
+                await onAccept(e);
+                this.close();
+            });
+        });
+    }
+}
+function createConfirmationDialog({ cta, onAccept, text, title, }) {
+    new ConfirmationModal(window.app, { cta, onAccept, text, title }).open();
+}
+
+/**
+ * Create a Daily Note for a given date.
+ */
+async function tryToCreateDailyNote(date, inNewSplit, settings, cb) {
+    const { workspace } = window.app;
+    const { format } = getDailyNoteSettings_1();
+    const filename = date.format(format);
+    const createFile = async () => {
+        const dailyNote = await createDailyNote_1(date);
+        const leaf = inNewSplit
+            ? workspace.splitActiveLeaf()
+            : workspace.getUnpinnedLeaf();
+        await leaf.openFile(dailyNote);
+        cb === null || cb === void 0 ? void 0 : cb(dailyNote);
+    };
+    if (settings.shouldConfirmBeforeCreate) {
+        createConfirmationDialog({
+            cta: "Create",
+            onAccept: createFile,
+            text: `File ${filename} does not exist. Would you like to create it?`,
+            title: "New Daily Note",
+        });
+    }
+    else {
+        await createFile();
+    }
+}
+
+/**
+ * Create a Weekly Note for a given date.
+ */
+async function tryToCreateWeeklyNote(date, inNewSplit, settings, cb) {
+    const { workspace } = window.app;
+    const { format } = getWeeklyNoteSettings_1();
+    const filename = date.format(format);
+    const createFile = async () => {
+        const dailyNote = await createWeeklyNote_1(date);
+        const leaf = inNewSplit
+            ? workspace.splitActiveLeaf()
+            : workspace.getUnpinnedLeaf();
+        await leaf.openFile(dailyNote);
+        cb === null || cb === void 0 ? void 0 : cb(dailyNote);
+    };
+    if (settings.shouldConfirmBeforeCreate) {
+        createConfirmationDialog({
+            cta: "Create",
+            onAccept: createFile,
+            text: `File ${filename} does not exist. Would you like to create it?`,
+            title: "New Weekly Note",
+        });
+    }
+    else {
+        await createFile();
+    }
+}
+
+function noop() { }
+function assign(tar, src) {
+    // @ts-ignore
+    for (const k in src)
+        tar[k] = src[k];
+    return tar;
+}
+function is_promise(value) {
+    return value && typeof value === 'object' && typeof value.then === 'function';
+}
+function run(fn) {
+    return fn();
+}
+function blank_object() {
+    return Object.create(null);
+}
+function run_all(fns) {
+    fns.forEach(run);
+}
+function is_function(thing) {
+    return typeof thing === 'function';
+}
+function safe_not_equal(a, b) {
+    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+}
+function not_equal(a, b) {
+    return a != a ? b == b : a !== b;
+}
+function is_empty(obj) {
+    return Object.keys(obj).length === 0;
+}
+function create_slot(definition, ctx, $$scope, fn) {
+    if (definition) {
+        const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
+        return definition[0](slot_ctx);
+    }
+}
+function get_slot_context(definition, ctx, $$scope, fn) {
+    return definition[1] && fn
+        ? assign($$scope.ctx.slice(), definition[1](fn(ctx)))
+        : $$scope.ctx;
+}
+function get_slot_changes(definition, $$scope, dirty, fn) {
+    if (definition[2] && fn) {
+        const lets = definition[2](fn(dirty));
+        if ($$scope.dirty === undefined) {
+            return lets;
+        }
+        if (typeof lets === 'object') {
+            const merged = [];
+            const len = Math.max($$scope.dirty.length, lets.length);
+            for (let i = 0; i < len; i += 1) {
+                merged[i] = $$scope.dirty[i] | lets[i];
+            }
+            return merged;
+        }
+        return $$scope.dirty | lets;
+    }
+    return $$scope.dirty;
+}
+function update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {
+    const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);
+    if (slot_changes) {
+        const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
+        slot.p(slot_context, slot_changes);
+    }
+}
+function null_to_empty(value) {
+    return value == null ? '' : value;
+}
+
+function append(target, node) {
+    target.appendChild(node);
+}
+function insert(target, node, anchor) {
+    target.insertBefore(node, anchor || null);
+}
+function detach(node) {
+    node.parentNode.removeChild(node);
+}
+function destroy_each(iterations, detaching) {
+    for (let i = 0; i < iterations.length; i += 1) {
+        if (iterations[i])
+            iterations[i].d(detaching);
+    }
+}
+function element(name) {
+    return document.createElement(name);
+}
+function svg_element(name) {
+    return document.createElementNS('http://www.w3.org/2000/svg', name);
+}
+function text(data) {
+    return document.createTextNode(data);
+}
+function space() {
+    return text(' ');
+}
+function empty() {
+    return text('');
+}
+function listen(node, event, handler, options) {
+    node.addEventListener(event, handler, options);
+    return () => node.removeEventListener(event, handler, options);
+}
+function attr(node, attribute, value) {
+    if (value == null)
+        node.removeAttribute(attribute);
+    else if (node.getAttribute(attribute) !== value)
+        node.setAttribute(attribute, value);
+}
+function set_attributes(node, attributes) {
+    // @ts-ignore
+    const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
+    for (const key in attributes) {
+        if (attributes[key] == null) {
+            node.removeAttribute(key);
+        }
+        else if (key === 'style') {
+            node.style.cssText = attributes[key];
+        }
+        else if (key === '__value') {
+            node.value = node[key] = attributes[key];
+        }
+        else if (descriptors[key] && descriptors[key].set) {
+            node[key] = attributes[key];
+        }
+        else {
+            attr(node, key, attributes[key]);
+        }
+    }
+}
+function children(element) {
+    return Array.from(element.childNodes);
+}
+function set_data(text, data) {
+    data = '' + data;
+    if (text.wholeText !== data)
+        text.data = data;
+}
+function toggle_class(element, name, toggle) {
+    element.classList[toggle ? 'add' : 'remove'](name);
+}
+
+let current_component;
+function set_current_component(component) {
+    current_component = component;
+}
+function get_current_component() {
+    if (!current_component)
+        throw new Error('Function called outside component initialization');
+    return current_component;
+}
+
+const dirty_components = [];
+const binding_callbacks = [];
+const render_callbacks = [];
+const flush_callbacks = [];
+const resolved_promise = Promise.resolve();
+let update_scheduled = false;
+function schedule_update() {
+    if (!update_scheduled) {
+        update_scheduled = true;
+        resolved_promise.then(flush);
+    }
+}
+function add_render_callback(fn) {
+    render_callbacks.push(fn);
+}
+let flushing = false;
+const seen_callbacks = new Set();
+function flush() {
+    if (flushing)
+        return;
+    flushing = true;
+    do {
+        // first, call beforeUpdate functions
+        // and update components
+        for (let i = 0; i < dirty_components.length; i += 1) {
+            const component = dirty_components[i];
+            set_current_component(component);
+            update(component.$$);
+        }
+        set_current_component(null);
+        dirty_components.length = 0;
+        while (binding_callbacks.length)
+            binding_callbacks.pop()();
+        // then, once components are updated, call
+        // afterUpdate functions. This may cause
+        // subsequent updates...
+        for (let i = 0; i < render_callbacks.length; i += 1) {
+            const callback = render_callbacks[i];
+            if (!seen_callbacks.has(callback)) {
+                // ...so guard against infinite loops
+                seen_callbacks.add(callback);
+                callback();
+            }
+        }
+        render_callbacks.length = 0;
+    } while (dirty_components.length);
+    while (flush_callbacks.length) {
+        flush_callbacks.pop()();
+    }
+    update_scheduled = false;
+    flushing = false;
+    seen_callbacks.clear();
+}
+function update($$) {
+    if ($$.fragment !== null) {
+        $$.update();
+        run_all($$.before_update);
+        const dirty = $$.dirty;
+        $$.dirty = [-1];
+        $$.fragment && $$.fragment.p($$.ctx, dirty);
+        $$.after_update.forEach(add_render_callback);
+    }
+}
+const outroing = new Set();
+let outros;
+function group_outros() {
+    outros = {
+        r: 0,
+        c: [],
+        p: outros // parent group
+    };
+}
+function check_outros() {
+    if (!outros.r) {
+        run_all(outros.c);
+    }
+    outros = outros.p;
+}
+function transition_in(block, local) {
+    if (block && block.i) {
+        outroing.delete(block);
+        block.i(local);
+    }
+}
+function transition_out(block, local, detach, callback) {
+    if (block && block.o) {
+        if (outroing.has(block))
+            return;
+        outroing.add(block);
+        outros.c.push(() => {
+            outroing.delete(block);
+            if (callback) {
+                if (detach)
+                    block.d(1);
+                callback();
+            }
+        });
+        block.o(local);
+    }
+}
+
+function handle_promise(promise, info) {
+    const token = info.token = {};
+    function update(type, index, key, value) {
+        if (info.token !== token)
+            return;
+        info.resolved = value;
+        let child_ctx = info.ctx;
+        if (key !== undefined) {
+            child_ctx = child_ctx.slice();
+            child_ctx[key] = value;
+        }
+        const block = type && (info.current = type)(child_ctx);
+        let needs_flush = false;
+        if (info.block) {
+            if (info.blocks) {
+                info.blocks.forEach((block, i) => {
+                    if (i !== index && block) {
+                        group_outros();
+                        transition_out(block, 1, 1, () => {
+                            if (info.blocks[i] === block) {
+                                info.blocks[i] = null;
+                            }
+                        });
+                        check_outros();
+                    }
+                });
+            }
+            else {
+                info.block.d(1);
+            }
+            block.c();
+            transition_in(block, 1);
+            block.m(info.mount(), info.anchor);
+            needs_flush = true;
+        }
+        info.block = block;
+        if (info.blocks)
+            info.blocks[index] = block;
+        if (needs_flush) {
+            flush();
+        }
+    }
+    if (is_promise(promise)) {
+        const current_component = get_current_component();
+        promise.then(value => {
+            set_current_component(current_component);
+            update(info.then, 1, info.value, value);
+            set_current_component(null);
+        }, error => {
+            set_current_component(current_component);
+            update(info.catch, 2, info.error, error);
+            set_current_component(null);
+            if (!info.hasCatch) {
+                throw error;
+            }
+        });
+        // if we previously had a then/catch block, destroy it
+        if (info.current !== info.pending) {
+            update(info.pending, 0);
+            return true;
+        }
+    }
+    else {
+        if (info.current !== info.then) {
+            update(info.then, 1, info.value, promise);
+            return true;
+        }
+        info.resolved = promise;
+    }
+}
+function outro_and_destroy_block(block, lookup) {
+    transition_out(block, 1, 1, () => {
+        lookup.delete(block.key);
+    });
+}
+function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {
+    let o = old_blocks.length;
+    let n = list.length;
+    let i = o;
+    const old_indexes = {};
+    while (i--)
+        old_indexes[old_blocks[i].key] = i;
+    const new_blocks = [];
+    const new_lookup = new Map();
+    const deltas = new Map();
+    i = n;
+    while (i--) {
+        const child_ctx = get_context(ctx, list, i);
+        const key = get_key(child_ctx);
+        let block = lookup.get(key);
+        if (!block) {
+            block = create_each_block(key, child_ctx);
+            block.c();
+        }
+        else if (dynamic) {
+            block.p(child_ctx, dirty);
+        }
+        new_lookup.set(key, new_blocks[i] = block);
+        if (key in old_indexes)
+            deltas.set(key, Math.abs(i - old_indexes[key]));
+    }
+    const will_move = new Set();
+    const did_move = new Set();
+    function insert(block) {
+        transition_in(block, 1);
+        block.m(node, next);
+        lookup.set(block.key, block);
+        next = block.first;
+        n--;
+    }
+    while (o && n) {
+        const new_block = new_blocks[n - 1];
+        const old_block = old_blocks[o - 1];
+        const new_key = new_block.key;
+        const old_key = old_block.key;
+        if (new_block === old_block) {
+            // do nothing
+            next = new_block.first;
+            o--;
+            n--;
+        }
+        else if (!new_lookup.has(old_key)) {
+            // remove old block
+            destroy(old_block, lookup);
+            o--;
+        }
+        else if (!lookup.has(new_key) || will_move.has(new_key)) {
+            insert(new_block);
+        }
+        else if (did_move.has(old_key)) {
+            o--;
+        }
+        else if (deltas.get(new_key) > deltas.get(old_key)) {
+            did_move.add(new_key);
+            insert(new_block);
+        }
+        else {
+            will_move.add(old_key);
+            o--;
+        }
+    }
+    while (o--) {
+        const old_block = old_blocks[o];
+        if (!new_lookup.has(old_block.key))
+            destroy(old_block, lookup);
+    }
+    while (n)
+        insert(new_blocks[n - 1]);
+    return new_blocks;
+}
+
+function get_spread_update(levels, updates) {
+    const update = {};
+    const to_null_out = {};
+    const accounted_for = { $$scope: 1 };
+    let i = levels.length;
+    while (i--) {
+        const o = levels[i];
+        const n = updates[i];
+        if (n) {
+            for (const key in o) {
+                if (!(key in n))
+                    to_null_out[key] = 1;
+            }
+            for (const key in n) {
+                if (!accounted_for[key]) {
+                    update[key] = n[key];
+                    accounted_for[key] = 1;
+                }
+            }
+            levels[i] = n;
+        }
+        else {
+            for (const key in o) {
+                accounted_for[key] = 1;
+            }
+        }
+    }
+    for (const key in to_null_out) {
+        if (!(key in update))
+            update[key] = undefined;
+    }
+    return update;
+}
+function get_spread_object(spread_props) {
+    return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};
+}
+function create_component(block) {
+    block && block.c();
+}
+function mount_component(component, target, anchor, customElement) {
+    const { fragment, on_mount, on_destroy, after_update } = component.$$;
+    fragment && fragment.m(target, anchor);
+    if (!customElement) {
+        // onMount happens before the initial afterUpdate
+        add_render_callback(() => {
+            const new_on_destroy = on_mount.map(run).filter(is_function);
+            if (on_destroy) {
+                on_destroy.push(...new_on_destroy);
+            }
+            else {
+                // Edge case - component was destroyed immediately,
+                // most likely as a result of a binding initialising
+                run_all(new_on_destroy);
+            }
+            component.$$.on_mount = [];
+        });
+    }
+    after_update.forEach(add_render_callback);
+}
+function destroy_component(component, detaching) {
+    const $$ = component.$$;
+    if ($$.fragment !== null) {
+        run_all($$.on_destroy);
+        $$.fragment && $$.fragment.d(detaching);
+        // TODO null out other refs, including component.$$ (but need to
+        // preserve final state?)
+        $$.on_destroy = $$.fragment = null;
+        $$.ctx = [];
+    }
+}
+function make_dirty(component, i) {
+    if (component.$$.dirty[0] === -1) {
+        dirty_components.push(component);
+        schedule_update();
+        component.$$.dirty.fill(0);
+    }
+    component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
+}
+function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
+    const parent_component = current_component;
+    set_current_component(component);
+    const $$ = component.$$ = {
+        fragment: null,
+        ctx: null,
+        // state
+        props,
+        update: noop,
+        not_equal,
+        bound: blank_object(),
+        // lifecycle
+        on_mount: [],
+        on_destroy: [],
+        on_disconnect: [],
+        before_update: [],
+        after_update: [],
+        context: new Map(parent_component ? parent_component.$$.context : []),
+        // everything else
+        callbacks: blank_object(),
+        dirty,
+        skip_bound: false
+    };
+    let ready = false;
+    $$.ctx = instance
+        ? instance(component, options.props || {}, (i, ret, ...rest) => {
+            const value = rest.length ? rest[0] : ret;
+            if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+                if (!$$.skip_bound && $$.bound[i])
+                    $$.bound[i](value);
+                if (ready)
+                    make_dirty(component, i);
+            }
+            return ret;
+        })
+        : [];
+    $$.update();
+    ready = true;
+    run_all($$.before_update);
+    // `false` as a special case of no DOM component
+    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
+    if (options.target) {
+        if (options.hydrate) {
+            const nodes = children(options.target);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            $$.fragment && $$.fragment.l(nodes);
+            nodes.forEach(detach);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            $$.fragment && $$.fragment.c();
+        }
+        if (options.intro)
+            transition_in(component.$$.fragment);
+        mount_component(component, options.target, options.anchor, options.customElement);
+        flush();
+    }
+    set_current_component(parent_component);
+}
+/**
+ * Base class for Svelte components. Used when dev=false.
+ */
+class SvelteComponent {
+    $destroy() {
+        destroy_component(this, 1);
+        this.$destroy = noop;
+    }
+    $on(type, callback) {
+        const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
+        callbacks.push(callback);
+        return () => {
+            const index = callbacks.indexOf(callback);
+            if (index !== -1)
+                callbacks.splice(index, 1);
+        };
+    }
+    $set($$props) {
+        if (this.$$set && !is_empty($$props)) {
+            this.$$.skip_bound = true;
+            this.$$set($$props);
+            this.$$.skip_bound = false;
+        }
+    }
+}
+
+/**
+ * dateUID is a way of weekly identifying daily/weekly/monthly notes.
+ * They are prefixed with the granularity to avoid ambiguity.
+ */
+function getDateUID(date, granularity = "day") {
+    const ts = date.clone().startOf(granularity).format();
+    return `${granularity}-${ts}`;
+}
+var getDateUID_1 = getDateUID;
+
+/* src/components/Dot.svelte generated by Svelte v3.35.0 */
+
+function add_css$5() {
+	var style = element("style");
+	style.id = "svelte-1widvzq-style";
+	style.textContent = ".dot.svelte-1widvzq,.hollow.svelte-1widvzq{display:inline-block;height:6px;width:6px;margin:0 1px}.filled.svelte-1widvzq{fill:var(--color-dot)}.active.filled.svelte-1widvzq{fill:var(--text-on-accent)}.hollow.svelte-1widvzq{fill:none;stroke:var(--color-dot)}.active.hollow.svelte-1widvzq{fill:none;stroke:var(--text-on-accent)}";
+	append(document.head, style);
+}
+
+// (14:0) {:else}
+function create_else_block$1(ctx) {
+	let svg;
+	let circle;
+	let svg_class_value;
+
+	return {
+		c() {
+			svg = svg_element("svg");
+			circle = svg_element("circle");
+			attr(circle, "cx", "3");
+			attr(circle, "cy", "3");
+			attr(circle, "r", "2");
+			attr(svg, "class", svg_class_value = "" + (null_to_empty(`hollow ${/*className*/ ctx[0]}`) + " svelte-1widvzq"));
+			attr(svg, "viewBox", "0 0 6 6");
+			attr(svg, "xmlns", "http://www.w3.org/2000/svg");
+			toggle_class(svg, "active", /*isActive*/ ctx[2]);
+		},
+		m(target, anchor) {
+			insert(target, svg, anchor);
+			append(svg, circle);
+		},
+		p(ctx, dirty) {
+			if (dirty & /*className*/ 1 && svg_class_value !== (svg_class_value = "" + (null_to_empty(`hollow ${/*className*/ ctx[0]}`) + " svelte-1widvzq"))) {
+				attr(svg, "class", svg_class_value);
+			}
+
+			if (dirty & /*className, isActive*/ 5) {
+				toggle_class(svg, "active", /*isActive*/ ctx[2]);
+			}
+		},
+		d(detaching) {
+			if (detaching) detach(svg);
+		}
+	};
+}
+
+// (6:0) {#if isFilled}
+function create_if_block$2(ctx) {
+	let svg;
+	let circle;
+	let svg_class_value;
+
+	return {
+		c() {
+			svg = svg_element("svg");
+			circle = svg_element("circle");
+			attr(circle, "cx", "3");
+			attr(circle, "cy", "3");
+			attr(circle, "r", "2");
+			attr(svg, "class", svg_class_value = "" + (null_to_empty(`dot filled ${/*className*/ ctx[0]}`) + " svelte-1widvzq"));
+			attr(svg, "viewBox", "0 0 6 6");
+			attr(svg, "xmlns", "http://www.w3.org/2000/svg");
+			toggle_class(svg, "active", /*isActive*/ ctx[2]);
+		},
+		m(target, anchor) {
+			insert(target, svg, anchor);
+			append(svg, circle);
+		},
+		p(ctx, dirty) {
+			if (dirty & /*className*/ 1 && svg_class_value !== (svg_class_value = "" + (null_to_empty(`dot filled ${/*className*/ ctx[0]}`) + " svelte-1widvzq"))) {
+				attr(svg, "class", svg_class_value);
+			}
+
+			if (dirty & /*className, isActive*/ 5) {
+				toggle_class(svg, "active", /*isActive*/ ctx[2]);
+			}
+		},
+		d(detaching) {
+			if (detaching) detach(svg);
+		}
+	};
+}
+
+function create_fragment$6(ctx) {
+	let if_block_anchor;
+
+	function select_block_type(ctx, dirty) {
+		if (/*isFilled*/ ctx[1]) return create_if_block$2;
+		return create_else_block$1;
+	}
+
+	let current_block_type = select_block_type(ctx);
+	let if_block = current_block_type(ctx);
+
+	return {
+		c() {
+			if_block.c();
+			if_block_anchor = empty();
+		},
+		m(target, anchor) {
+			if_block.m(target, anchor);
+			insert(target, if_block_anchor, anchor);
+		},
+		p(ctx, [dirty]) {
+			if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
+				if_block.p(ctx, dirty);
+			} else {
+				if_block.d(1);
+				if_block = current_block_type(ctx);
+
+				if (if_block) {
+					if_block.c();
+					if_block.m(if_block_anchor.parentNode, if_block_anchor);
+				}
+			}
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if_block.d(detaching);
+			if (detaching) detach(if_block_anchor);
+		}
+	};
+}
+
+function instance$6($$self, $$props, $$invalidate) {
+	let { className = "" } = $$props;
+	let { isFilled } = $$props;
+	let { isActive } = $$props;
+
+	$$self.$$set = $$props => {
+		if ("className" in $$props) $$invalidate(0, className = $$props.className);
+		if ("isFilled" in $$props) $$invalidate(1, isFilled = $$props.isFilled);
+		if ("isActive" in $$props) $$invalidate(2, isActive = $$props.isActive);
+	};
+
+	return [className, isFilled, isActive];
+}
+
+class Dot extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-1widvzq-style")) add_css$5();
+		init(this, options, instance$6, create_fragment$6, safe_not_equal, { className: 0, isFilled: 1, isActive: 2 });
+	}
+}
+
+/* src/components/MetadataResolver.svelte generated by Svelte v3.35.0 */
+
+const get_default_slot_changes_1 = dirty => ({});
+const get_default_slot_context_1 = ctx => ({ metadata: null });
+const get_default_slot_changes = dirty => ({ metadata: dirty & /*metadata*/ 1 });
+const get_default_slot_context = ctx => ({ metadata: /*resolvedMeta*/ ctx[3] });
+
+// (11:0) {:else}
+function create_else_block(ctx) {
+	let current;
+	const default_slot_template = /*#slots*/ ctx[2].default;
+	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[1], get_default_slot_context_1);
+
+	return {
+		c() {
+			if (default_slot) default_slot.c();
+		},
+		m(target, anchor) {
+			if (default_slot) {
+				default_slot.m(target, anchor);
+			}
+
+			current = true;
+		},
+		p(ctx, dirty) {
+			if (default_slot) {
+				if (default_slot.p && dirty & /*$$scope*/ 2) {
+					update_slot(default_slot, default_slot_template, ctx, /*$$scope*/ ctx[1], dirty, get_default_slot_changes_1, get_default_slot_context_1);
+				}
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(default_slot, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(default_slot, local);
+			current = false;
+		},
+		d(detaching) {
+			if (default_slot) default_slot.d(detaching);
+		}
+	};
+}
+
+// (7:0) {#if metadata}
+function create_if_block$1(ctx) {
+	let await_block_anchor;
+	let promise;
+	let current;
+
+	let info = {
+		ctx,
+		current: null,
+		token: null,
+		hasCatch: false,
+		pending: create_pending_block,
+		then: create_then_block,
+		catch: create_catch_block,
+		value: 3,
+		blocks: [,,,]
+	};
+
+	handle_promise(promise = /*metadata*/ ctx[0], info);
+
+	return {
+		c() {
+			await_block_anchor = empty();
+			info.block.c();
+		},
+		m(target, anchor) {
+			insert(target, await_block_anchor, anchor);
+			info.block.m(target, info.anchor = anchor);
+			info.mount = () => await_block_anchor.parentNode;
+			info.anchor = await_block_anchor;
+			current = true;
+		},
+		p(new_ctx, dirty) {
+			ctx = new_ctx;
+			info.ctx = ctx;
+
+			if (dirty & /*metadata*/ 1 && promise !== (promise = /*metadata*/ ctx[0]) && handle_promise(promise, info)) ; else {
+				const child_ctx = ctx.slice();
+				child_ctx[3] = info.resolved;
+				info.block.p(child_ctx, dirty);
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(info.block);
+			current = true;
+		},
+		o(local) {
+			for (let i = 0; i < 3; i += 1) {
+				const block = info.blocks[i];
+				transition_out(block);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(await_block_anchor);
+			info.block.d(detaching);
+			info.token = null;
+			info = null;
+		}
+	};
+}
+
+// (1:0) <svelte:options immutable />  <script lang="ts">; export let metadata; </script>  {#if metadata}
+function create_catch_block(ctx) {
+	return {
+		c: noop,
+		m: noop,
+		p: noop,
+		i: noop,
+		o: noop,
+		d: noop
+	};
+}
+
+// (8:37)      <slot metadata="{resolvedMeta}
+function create_then_block(ctx) {
+	let current;
+	const default_slot_template = /*#slots*/ ctx[2].default;
+	const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[1], get_default_slot_context);
+
+	return {
+		c() {
+			if (default_slot) default_slot.c();
+		},
+		m(target, anchor) {
+			if (default_slot) {
+				default_slot.m(target, anchor);
+			}
+
+			current = true;
+		},
+		p(ctx, dirty) {
+			if (default_slot) {
+				if (default_slot.p && dirty & /*$$scope, metadata*/ 3) {
+					update_slot(default_slot, default_slot_template, ctx, /*$$scope*/ ctx[1], dirty, get_default_slot_changes, get_default_slot_context);
+				}
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(default_slot, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(default_slot, local);
+			current = false;
+		},
+		d(detaching) {
+			if (default_slot) default_slot.d(detaching);
+		}
+	};
+}
+
+// (1:0) <svelte:options immutable />  <script lang="ts">; export let metadata; </script>  {#if metadata}
+function create_pending_block(ctx) {
+	return {
+		c: noop,
+		m: noop,
+		p: noop,
+		i: noop,
+		o: noop,
+		d: noop
+	};
+}
+
+function create_fragment$5(ctx) {
+	let current_block_type_index;
+	let if_block;
+	let if_block_anchor;
+	let current;
+	const if_block_creators = [create_if_block$1, create_else_block];
+	const if_blocks = [];
+
+	function select_block_type(ctx, dirty) {
+		if (/*metadata*/ ctx[0]) return 0;
+		return 1;
+	}
+
+	current_block_type_index = select_block_type(ctx);
+	if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+
+	return {
+		c() {
+			if_block.c();
+			if_block_anchor = empty();
+		},
+		m(target, anchor) {
+			if_blocks[current_block_type_index].m(target, anchor);
+			insert(target, if_block_anchor, anchor);
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			let previous_block_index = current_block_type_index;
+			current_block_type_index = select_block_type(ctx);
+
+			if (current_block_type_index === previous_block_index) {
+				if_blocks[current_block_type_index].p(ctx, dirty);
+			} else {
+				group_outros();
+
+				transition_out(if_blocks[previous_block_index], 1, 1, () => {
+					if_blocks[previous_block_index] = null;
+				});
+
+				check_outros();
+				if_block = if_blocks[current_block_type_index];
+
+				if (!if_block) {
+					if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+					if_block.c();
+				} else {
+					if_block.p(ctx, dirty);
+				}
+
+				transition_in(if_block, 1);
+				if_block.m(if_block_anchor.parentNode, if_block_anchor);
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(if_block);
+			current = true;
+		},
+		o(local) {
+			transition_out(if_block);
+			current = false;
+		},
+		d(detaching) {
+			if_blocks[current_block_type_index].d(detaching);
+			if (detaching) detach(if_block_anchor);
+		}
+	};
+}
+
+function instance$5($$self, $$props, $$invalidate) {
+	let { $$slots: slots = {}, $$scope } = $$props;
+	
+	let { metadata } = $$props;
+
+	$$self.$$set = $$props => {
+		if ("metadata" in $$props) $$invalidate(0, metadata = $$props.metadata);
+		if ("$$scope" in $$props) $$invalidate(1, $$scope = $$props.$$scope);
+	};
+
+	return [metadata, $$scope, slots];
+}
+
+class MetadataResolver extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance$5, create_fragment$5, not_equal, { metadata: 0 });
+	}
+}
+
+function isMacOS() {
+    return navigator.appVersion.indexOf("Mac") !== -1;
+}
+function isMetaPressed(e) {
+    return isMacOS() ? e.metaKey : e.ctrlKey;
+}
+function getDaysOfWeek(..._args) {
+    return window.moment.weekdaysShort(true);
+}
+function isWeekend(date) {
+    return date.isoWeekday() === 6 || date.isoWeekday() === 7;
+}
+function getStartOfWeek(days) {
+    return days[0].weekday(0);
+}
+/**
+ * Generate a 2D array of daily information to power
+ * the calendar view.
+ */
+function getMonth(displayedMonth, ..._args) {
+    const locale = window.moment().locale();
+    const month = [];
+    let week;
+    const startOfMonth = displayedMonth.clone().locale(locale).date(1);
+    const startOffset = startOfMonth.weekday();
+    let date = startOfMonth.clone().subtract(startOffset, "days");
+    for (let _day = 0; _day < 42; _day++) {
+        if (_day % 7 === 0) {
+            week = {
+                days: [],
+                weekNum: date.week(),
+            };
+            month.push(week);
+        }
+        week.days.push(date);
+        date = date.clone().add(1, "days");
+    }
+    return month;
+}
+
+/* src/components/Day.svelte generated by Svelte v3.35.0 */
+
+function add_css$4() {
+	var style = element("style");
+	style.id = "svelte-q3wqg9-style";
+	style.textContent = ".day.svelte-q3wqg9{background-color:var(--color-background-day);border-radius:4px;color:var(--color-text-day);cursor:pointer;font-size:0.8em;height:100%;padding:4px;position:relative;text-align:center;transition:background-color 0.1s ease-in, color 0.1s ease-in;vertical-align:baseline}.day.svelte-q3wqg9:hover{background-color:var(--interactive-hover)}.day.active.svelte-q3wqg9:hover{background-color:var(--interactive-accent-hover)}.adjacent-month.svelte-q3wqg9{opacity:0.25}.today.svelte-q3wqg9{color:var(--color-text-today)}.day.svelte-q3wqg9:active,.active.svelte-q3wqg9,.active.today.svelte-q3wqg9{color:var(--text-on-accent);background-color:var(--interactive-accent)}.dot-container.svelte-q3wqg9{display:flex;flex-wrap:wrap;justify-content:center;line-height:6px;min-height:6px}";
+	append(document.head, style);
+}
+
+function get_each_context$2(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[11] = list[i];
+	return child_ctx;
+}
+
+// (36:8) {#each metadata.dots as dot}
+function create_each_block$2(ctx) {
+	let dot;
+	let current;
+	const dot_spread_levels = [/*dot*/ ctx[11]];
+	let dot_props = {};
+
+	for (let i = 0; i < dot_spread_levels.length; i += 1) {
+		dot_props = assign(dot_props, dot_spread_levels[i]);
+	}
+
+	dot = new Dot({ props: dot_props });
+
+	return {
+		c() {
+			create_component(dot.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(dot, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const dot_changes = (dirty & /*metadata*/ 128)
+			? get_spread_update(dot_spread_levels, [get_spread_object(/*dot*/ ctx[11])])
+			: {};
+
+			dot.$set(dot_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(dot.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(dot.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(dot, detaching);
+		}
+	};
+}
+
+// (22:2) <MetadataResolver metadata="{metadata}" let:metadata>
+function create_default_slot$1(ctx) {
+	let div1;
+	let t0_value = /*date*/ ctx[0].format("D") + "";
+	let t0;
+	let t1;
+	let div0;
+	let div1_class_value;
+	let current;
+	let mounted;
+	let dispose;
+	let each_value = /*metadata*/ ctx[7].dots;
+	let each_blocks = [];
+
+	for (let i = 0; i < each_value.length; i += 1) {
+		each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i));
+	}
+
+	const out = i => transition_out(each_blocks[i], 1, 1, () => {
+		each_blocks[i] = null;
+	});
+
+	let div1_levels = [
+		{
+			class: div1_class_value = `day ${/*metadata*/ ctx[7].classes.join(" ")}`
+		},
+		/*metadata*/ ctx[7].dataAttributes || {}
+	];
+
+	let div1_data = {};
+
+	for (let i = 0; i < div1_levels.length; i += 1) {
+		div1_data = assign(div1_data, div1_levels[i]);
+	}
+
+	return {
+		c() {
+			div1 = element("div");
+			t0 = text(t0_value);
+			t1 = space();
+			div0 = element("div");
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].c();
+			}
+
+			attr(div0, "class", "dot-container svelte-q3wqg9");
+			set_attributes(div1, div1_data);
+			toggle_class(div1, "active", /*selectedId*/ ctx[6] === getDateUID_1(/*date*/ ctx[0], "day"));
+			toggle_class(div1, "adjacent-month", !/*date*/ ctx[0].isSame(/*displayedMonth*/ ctx[5], "month"));
+			toggle_class(div1, "today", /*date*/ ctx[0].isSame(/*today*/ ctx[4], "day"));
+			toggle_class(div1, "svelte-q3wqg9", true);
+		},
+		m(target, anchor) {
+			insert(target, div1, anchor);
+			append(div1, t0);
+			append(div1, t1);
+			append(div1, div0);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].m(div0, null);
+			}
+
+			current = true;
+
+			if (!mounted) {
+				dispose = [
+					listen(div1, "click", function () {
+						if (is_function(/*onClick*/ ctx[2] && /*click_handler*/ ctx[8])) (/*onClick*/ ctx[2] && /*click_handler*/ ctx[8]).apply(this, arguments);
+					}),
+					listen(div1, "contextmenu", function () {
+						if (is_function(/*onContextMenu*/ ctx[3] && /*contextmenu_handler*/ ctx[9])) (/*onContextMenu*/ ctx[3] && /*contextmenu_handler*/ ctx[9]).apply(this, arguments);
+					}),
+					listen(div1, "pointerover", function () {
+						if (is_function(/*onHover*/ ctx[1] && /*pointerover_handler*/ ctx[10])) (/*onHover*/ ctx[1] && /*pointerover_handler*/ ctx[10]).apply(this, arguments);
+					})
+				];
+
+				mounted = true;
+			}
+		},
+		p(new_ctx, dirty) {
+			ctx = new_ctx;
+			if ((!current || dirty & /*date*/ 1) && t0_value !== (t0_value = /*date*/ ctx[0].format("D") + "")) set_data(t0, t0_value);
+
+			if (dirty & /*metadata*/ 128) {
+				each_value = /*metadata*/ ctx[7].dots;
+				let i;
+
+				for (i = 0; i < each_value.length; i += 1) {
+					const child_ctx = get_each_context$2(ctx, each_value, i);
+
+					if (each_blocks[i]) {
+						each_blocks[i].p(child_ctx, dirty);
+						transition_in(each_blocks[i], 1);
+					} else {
+						each_blocks[i] = create_each_block$2(child_ctx);
+						each_blocks[i].c();
+						transition_in(each_blocks[i], 1);
+						each_blocks[i].m(div0, null);
+					}
+				}
+
+				group_outros();
+
+				for (i = each_value.length; i < each_blocks.length; i += 1) {
+					out(i);
+				}
+
+				check_outros();
+			}
+
+			set_attributes(div1, div1_data = get_spread_update(div1_levels, [
+				(!current || dirty & /*metadata*/ 128 && div1_class_value !== (div1_class_value = `day ${/*metadata*/ ctx[7].classes.join(" ")}`)) && { class: div1_class_value },
+				dirty & /*metadata*/ 128 && (/*metadata*/ ctx[7].dataAttributes || {})
+			]));
+
+			toggle_class(div1, "active", /*selectedId*/ ctx[6] === getDateUID_1(/*date*/ ctx[0], "day"));
+			toggle_class(div1, "adjacent-month", !/*date*/ ctx[0].isSame(/*displayedMonth*/ ctx[5], "month"));
+			toggle_class(div1, "today", /*date*/ ctx[0].isSame(/*today*/ ctx[4], "day"));
+			toggle_class(div1, "svelte-q3wqg9", true);
+		},
+		i(local) {
+			if (current) return;
+
+			for (let i = 0; i < each_value.length; i += 1) {
+				transition_in(each_blocks[i]);
+			}
+
+			current = true;
+		},
+		o(local) {
+			each_blocks = each_blocks.filter(Boolean);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				transition_out(each_blocks[i]);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(div1);
+			destroy_each(each_blocks, detaching);
+			mounted = false;
+			run_all(dispose);
+		}
+	};
+}
+
+function create_fragment$4(ctx) {
+	let td;
+	let metadataresolver;
+	let current;
+
+	metadataresolver = new MetadataResolver({
+			props: {
+				metadata: /*metadata*/ ctx[7],
+				$$slots: {
+					default: [
+						create_default_slot$1,
+						({ metadata }) => ({ 7: metadata }),
+						({ metadata }) => metadata ? 128 : 0
+					]
+				},
+				$$scope: { ctx }
+			}
+		});
+
+	return {
+		c() {
+			td = element("td");
+			create_component(metadataresolver.$$.fragment);
+		},
+		m(target, anchor) {
+			insert(target, td, anchor);
+			mount_component(metadataresolver, td, null);
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			const metadataresolver_changes = {};
+			if (dirty & /*metadata*/ 128) metadataresolver_changes.metadata = /*metadata*/ ctx[7];
+
+			if (dirty & /*$$scope, metadata, selectedId, date, displayedMonth, today, onClick, onContextMenu, onHover*/ 16639) {
+				metadataresolver_changes.$$scope = { dirty, ctx };
+			}
+
+			metadataresolver.$set(metadataresolver_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(metadataresolver.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(metadataresolver.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(td);
+			destroy_component(metadataresolver);
+		}
+	};
+}
+
+function instance$4($$self, $$props, $$invalidate) {
+	
+	
+	let { date } = $$props;
+	let { metadata } = $$props;
+	let { onHover } = $$props;
+	let { onClick } = $$props;
+	let { onContextMenu } = $$props;
+	let { today } = $$props;
+	let { displayedMonth = null } = $$props;
+	let { selectedId = null } = $$props;
+	const click_handler = e => onClick(date, isMetaPressed(e));
+	const contextmenu_handler = e => onContextMenu(date, e);
+	const pointerover_handler = e => onHover(date, e.target, isMetaPressed(e));
+
+	$$self.$$set = $$props => {
+		if ("date" in $$props) $$invalidate(0, date = $$props.date);
+		if ("metadata" in $$props) $$invalidate(7, metadata = $$props.metadata);
+		if ("onHover" in $$props) $$invalidate(1, onHover = $$props.onHover);
+		if ("onClick" in $$props) $$invalidate(2, onClick = $$props.onClick);
+		if ("onContextMenu" in $$props) $$invalidate(3, onContextMenu = $$props.onContextMenu);
+		if ("today" in $$props) $$invalidate(4, today = $$props.today);
+		if ("displayedMonth" in $$props) $$invalidate(5, displayedMonth = $$props.displayedMonth);
+		if ("selectedId" in $$props) $$invalidate(6, selectedId = $$props.selectedId);
+	};
+
+	return [
+		date,
+		onHover,
+		onClick,
+		onContextMenu,
+		today,
+		displayedMonth,
+		selectedId,
+		metadata,
+		click_handler,
+		contextmenu_handler,
+		pointerover_handler
+	];
+}
+
+class Day extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-q3wqg9-style")) add_css$4();
+
+		init(this, options, instance$4, create_fragment$4, not_equal, {
+			date: 0,
+			metadata: 7,
+			onHover: 1,
+			onClick: 2,
+			onContextMenu: 3,
+			today: 4,
+			displayedMonth: 5,
+			selectedId: 6
+		});
+	}
+}
+
+/* src/components/Arrow.svelte generated by Svelte v3.35.0 */
+
+function add_css$3() {
+	var style = element("style");
+	style.id = "svelte-156w7na-style";
+	style.textContent = ".arrow.svelte-156w7na.svelte-156w7na{align-items:center;cursor:pointer;display:flex;justify-content:center;width:24px}.arrow.is-mobile.svelte-156w7na.svelte-156w7na{width:32px}.right.svelte-156w7na.svelte-156w7na{transform:rotate(180deg)}.arrow.svelte-156w7na svg.svelte-156w7na{color:var(--color-arrow);height:16px;width:16px}";
+	append(document.head, style);
+}
+
+function create_fragment$3(ctx) {
+	let div;
+	let svg;
+	let path;
+	let mounted;
+	let dispose;
+
+	return {
+		c() {
+			div = element("div");
+			svg = svg_element("svg");
+			path = svg_element("path");
+			attr(path, "fill", "currentColor");
+			attr(path, "d", "M34.52 239.03L228.87 44.69c9.37-9.37 24.57-9.37 33.94 0l22.67 22.67c9.36 9.36 9.37 24.52.04 33.9L131.49 256l154.02 154.75c9.34 9.38 9.32 24.54-.04 33.9l-22.67 22.67c-9.37 9.37-24.57 9.37-33.94 0L34.52 272.97c-9.37-9.37-9.37-24.57 0-33.94z");
+			attr(svg, "focusable", "false");
+			attr(svg, "role", "img");
+			attr(svg, "xmlns", "http://www.w3.org/2000/svg");
+			attr(svg, "viewBox", "0 0 320 512");
+			attr(svg, "class", "svelte-156w7na");
+			attr(div, "class", "arrow svelte-156w7na");
+			attr(div, "aria-label", /*tooltip*/ ctx[1]);
+			toggle_class(div, "is-mobile", /*isMobile*/ ctx[3]);
+			toggle_class(div, "right", /*direction*/ ctx[2] === "right");
+		},
+		m(target, anchor) {
+			insert(target, div, anchor);
+			append(div, svg);
+			append(svg, path);
+
+			if (!mounted) {
+				dispose = listen(div, "click", function () {
+					if (is_function(/*onClick*/ ctx[0])) /*onClick*/ ctx[0].apply(this, arguments);
+				});
+
+				mounted = true;
+			}
+		},
+		p(new_ctx, [dirty]) {
+			ctx = new_ctx;
+
+			if (dirty & /*tooltip*/ 2) {
+				attr(div, "aria-label", /*tooltip*/ ctx[1]);
+			}
+
+			if (dirty & /*direction*/ 4) {
+				toggle_class(div, "right", /*direction*/ ctx[2] === "right");
+			}
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if (detaching) detach(div);
+			mounted = false;
+			dispose();
+		}
+	};
+}
+
+function instance$3($$self, $$props, $$invalidate) {
+	let { onClick } = $$props;
+	let { tooltip } = $$props;
+	let { direction } = $$props;
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let isMobile = window.app.isMobile;
+
+	$$self.$$set = $$props => {
+		if ("onClick" in $$props) $$invalidate(0, onClick = $$props.onClick);
+		if ("tooltip" in $$props) $$invalidate(1, tooltip = $$props.tooltip);
+		if ("direction" in $$props) $$invalidate(2, direction = $$props.direction);
+	};
+
+	return [onClick, tooltip, direction, isMobile];
+}
+
+class Arrow extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-156w7na-style")) add_css$3();
+		init(this, options, instance$3, create_fragment$3, safe_not_equal, { onClick: 0, tooltip: 1, direction: 2 });
+	}
+}
+
+/* src/components/Nav.svelte generated by Svelte v3.35.0 */
+
+function add_css$2() {
+	var style = element("style");
+	style.id = "svelte-1vwr9dd-style";
+	style.textContent = ".nav.svelte-1vwr9dd.svelte-1vwr9dd{align-items:center;display:flex;margin:0.6em 0 1em;padding:0 8px;width:100%}.nav.is-mobile.svelte-1vwr9dd.svelte-1vwr9dd{padding:0}.title.svelte-1vwr9dd.svelte-1vwr9dd{color:var(--color-text-title);font-size:1.5em;margin:0}.is-mobile.svelte-1vwr9dd .title.svelte-1vwr9dd{font-size:1.3em}.month.svelte-1vwr9dd.svelte-1vwr9dd{font-weight:500;text-transform:capitalize}.year.svelte-1vwr9dd.svelte-1vwr9dd{color:var(--interactive-accent)}.right-nav.svelte-1vwr9dd.svelte-1vwr9dd{display:flex;justify-content:center;margin-left:auto}.reset-button.svelte-1vwr9dd.svelte-1vwr9dd{cursor:pointer;border-radius:4px;color:var(--text-muted);font-size:0.7em;font-weight:600;letter-spacing:1px;margin:0 4px;padding:0px 4px;text-transform:uppercase}.is-mobile.svelte-1vwr9dd .reset-button.svelte-1vwr9dd{display:none}";
+	append(document.head, style);
+}
+
+function create_fragment$2(ctx) {
+	let div2;
+	let h3;
+	let span0;
+	let t0_value = /*displayedMonth*/ ctx[0].format("MMM") + "";
+	let t0;
+	let t1;
+	let span1;
+	let t2_value = /*displayedMonth*/ ctx[0].format("YYYY") + "";
+	let t2;
+	let t3;
+	let div1;
+	let arrow0;
+	let t4;
+	let div0;
+	let t6;
+	let arrow1;
+	let current;
+	let mounted;
+	let dispose;
+
+	arrow0 = new Arrow({
+			props: {
+				direction: "left",
+				onClick: /*decrementDisplayedMonth*/ ctx[3],
+				tooltip: "Previous Month"
+			}
+		});
+
+	arrow1 = new Arrow({
+			props: {
+				direction: "right",
+				onClick: /*incrementDisplayedMonth*/ ctx[2],
+				tooltip: "Next Month"
+			}
+		});
+
+	return {
+		c() {
+			div2 = element("div");
+			h3 = element("h3");
+			span0 = element("span");
+			t0 = text(t0_value);
+			t1 = space();
+			span1 = element("span");
+			t2 = text(t2_value);
+			t3 = space();
+			div1 = element("div");
+			create_component(arrow0.$$.fragment);
+			t4 = space();
+			div0 = element("div");
+			div0.textContent = `${/*todayDisplayStr*/ ctx[4]}`;
+			t6 = space();
+			create_component(arrow1.$$.fragment);
+			attr(span0, "class", "month svelte-1vwr9dd");
+			attr(span1, "class", "year svelte-1vwr9dd");
+			attr(h3, "class", "title svelte-1vwr9dd");
+			attr(div0, "class", "reset-button svelte-1vwr9dd");
+			attr(div1, "class", "right-nav svelte-1vwr9dd");
+			attr(div2, "class", "nav svelte-1vwr9dd");
+			toggle_class(div2, "is-mobile", /*isMobile*/ ctx[5]);
+		},
+		m(target, anchor) {
+			insert(target, div2, anchor);
+			append(div2, h3);
+			append(h3, span0);
+			append(span0, t0);
+			append(h3, t1);
+			append(h3, span1);
+			append(span1, t2);
+			append(div2, t3);
+			append(div2, div1);
+			mount_component(arrow0, div1, null);
+			append(div1, t4);
+			append(div1, div0);
+			append(div1, t6);
+			mount_component(arrow1, div1, null);
+			current = true;
+
+			if (!mounted) {
+				dispose = [
+					listen(h3, "click", function () {
+						if (is_function(/*resetDisplayedMonth*/ ctx[1])) /*resetDisplayedMonth*/ ctx[1].apply(this, arguments);
+					}),
+					listen(div0, "click", function () {
+						if (is_function(/*resetDisplayedMonth*/ ctx[1])) /*resetDisplayedMonth*/ ctx[1].apply(this, arguments);
+					})
+				];
+
+				mounted = true;
+			}
+		},
+		p(new_ctx, [dirty]) {
+			ctx = new_ctx;
+			if ((!current || dirty & /*displayedMonth*/ 1) && t0_value !== (t0_value = /*displayedMonth*/ ctx[0].format("MMM") + "")) set_data(t0, t0_value);
+			if ((!current || dirty & /*displayedMonth*/ 1) && t2_value !== (t2_value = /*displayedMonth*/ ctx[0].format("YYYY") + "")) set_data(t2, t2_value);
+			const arrow0_changes = {};
+			if (dirty & /*decrementDisplayedMonth*/ 8) arrow0_changes.onClick = /*decrementDisplayedMonth*/ ctx[3];
+			arrow0.$set(arrow0_changes);
+			const arrow1_changes = {};
+			if (dirty & /*incrementDisplayedMonth*/ 4) arrow1_changes.onClick = /*incrementDisplayedMonth*/ ctx[2];
+			arrow1.$set(arrow1_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(arrow0.$$.fragment, local);
+			transition_in(arrow1.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(arrow0.$$.fragment, local);
+			transition_out(arrow1.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(div2);
+			destroy_component(arrow0);
+			destroy_component(arrow1);
+			mounted = false;
+			run_all(dispose);
+		}
+	};
+}
+
+function instance$2($$self, $$props, $$invalidate) {
+	
+	let { displayedMonth } = $$props;
+	let { today } = $$props;
+	let { resetDisplayedMonth } = $$props;
+	let { incrementDisplayedMonth } = $$props;
+	let { decrementDisplayedMonth } = $$props;
+
+	// Get the word 'Today' but localized to the current language
+	const todayDisplayStr = today.calendar().split(/\d|\s/)[0];
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let isMobile = window.app.isMobile;
+
+	$$self.$$set = $$props => {
+		if ("displayedMonth" in $$props) $$invalidate(0, displayedMonth = $$props.displayedMonth);
+		if ("today" in $$props) $$invalidate(6, today = $$props.today);
+		if ("resetDisplayedMonth" in $$props) $$invalidate(1, resetDisplayedMonth = $$props.resetDisplayedMonth);
+		if ("incrementDisplayedMonth" in $$props) $$invalidate(2, incrementDisplayedMonth = $$props.incrementDisplayedMonth);
+		if ("decrementDisplayedMonth" in $$props) $$invalidate(3, decrementDisplayedMonth = $$props.decrementDisplayedMonth);
+	};
+
+	return [
+		displayedMonth,
+		resetDisplayedMonth,
+		incrementDisplayedMonth,
+		decrementDisplayedMonth,
+		todayDisplayStr,
+		isMobile,
+		today
+	];
+}
+
+class Nav extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-1vwr9dd-style")) add_css$2();
+
+		init(this, options, instance$2, create_fragment$2, safe_not_equal, {
+			displayedMonth: 0,
+			today: 6,
+			resetDisplayedMonth: 1,
+			incrementDisplayedMonth: 2,
+			decrementDisplayedMonth: 3
+		});
+	}
+}
+
+/* src/components/WeekNum.svelte generated by Svelte v3.35.0 */
+
+function add_css$1() {
+	var style = element("style");
+	style.id = "svelte-egt0yd-style";
+	style.textContent = "td.svelte-egt0yd{border-right:1px solid var(--background-modifier-border)}.week-num.svelte-egt0yd{background-color:var(--color-background-weeknum);border-radius:4px;color:var(--color-text-weeknum);cursor:pointer;font-size:0.65em;height:100%;padding:4px;text-align:center;transition:background-color 0.1s ease-in, color 0.1s ease-in;vertical-align:baseline}.week-num.svelte-egt0yd:hover{background-color:var(--interactive-hover)}.week-num.active.svelte-egt0yd:hover{background-color:var(--interactive-accent-hover)}.active.svelte-egt0yd{color:var(--text-on-accent);background-color:var(--interactive-accent)}.dot-container.svelte-egt0yd{display:flex;flex-wrap:wrap;justify-content:center;line-height:6px;min-height:6px}";
+	append(document.head, style);
+}
+
+function get_each_context$1(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[11] = list[i];
+	return child_ctx;
+}
+
+// (35:8) {#each metadata.dots as dot}
+function create_each_block$1(ctx) {
+	let dot;
+	let current;
+	const dot_spread_levels = [/*dot*/ ctx[11]];
+	let dot_props = {};
+
+	for (let i = 0; i < dot_spread_levels.length; i += 1) {
+		dot_props = assign(dot_props, dot_spread_levels[i]);
+	}
+
+	dot = new Dot({ props: dot_props });
+
+	return {
+		c() {
+			create_component(dot.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(dot, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const dot_changes = (dirty & /*metadata*/ 64)
+			? get_spread_update(dot_spread_levels, [get_spread_object(/*dot*/ ctx[11])])
+			: {};
+
+			dot.$set(dot_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(dot.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(dot.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(dot, detaching);
+		}
+	};
+}
+
+// (24:2) <MetadataResolver metadata="{metadata}" let:metadata>
+function create_default_slot(ctx) {
+	let div1;
+	let t0;
+	let t1;
+	let div0;
+	let div1_class_value;
+	let current;
+	let mounted;
+	let dispose;
+	let each_value = /*metadata*/ ctx[6].dots;
+	let each_blocks = [];
+
+	for (let i = 0; i < each_value.length; i += 1) {
+		each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i));
+	}
+
+	const out = i => transition_out(each_blocks[i], 1, 1, () => {
+		each_blocks[i] = null;
+	});
+
+	return {
+		c() {
+			div1 = element("div");
+			t0 = text(/*weekNum*/ ctx[0]);
+			t1 = space();
+			div0 = element("div");
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].c();
+			}
+
+			attr(div0, "class", "dot-container svelte-egt0yd");
+			attr(div1, "class", div1_class_value = "" + (null_to_empty(`week-num ${/*metadata*/ ctx[6].classes.join(" ")}`) + " svelte-egt0yd"));
+			toggle_class(div1, "active", /*selectedId*/ ctx[5] === getDateUID_1(/*days*/ ctx[1][0], "week"));
+		},
+		m(target, anchor) {
+			insert(target, div1, anchor);
+			append(div1, t0);
+			append(div1, t1);
+			append(div1, div0);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].m(div0, null);
+			}
+
+			current = true;
+
+			if (!mounted) {
+				dispose = [
+					listen(div1, "click", function () {
+						if (is_function(/*onClick*/ ctx[3] && /*click_handler*/ ctx[8])) (/*onClick*/ ctx[3] && /*click_handler*/ ctx[8]).apply(this, arguments);
+					}),
+					listen(div1, "contextmenu", function () {
+						if (is_function(/*onContextMenu*/ ctx[4] && /*contextmenu_handler*/ ctx[9])) (/*onContextMenu*/ ctx[4] && /*contextmenu_handler*/ ctx[9]).apply(this, arguments);
+					}),
+					listen(div1, "pointerover", function () {
+						if (is_function(/*onHover*/ ctx[2] && /*pointerover_handler*/ ctx[10])) (/*onHover*/ ctx[2] && /*pointerover_handler*/ ctx[10]).apply(this, arguments);
+					})
+				];
+
+				mounted = true;
+			}
+		},
+		p(new_ctx, dirty) {
+			ctx = new_ctx;
+			if (!current || dirty & /*weekNum*/ 1) set_data(t0, /*weekNum*/ ctx[0]);
+
+			if (dirty & /*metadata*/ 64) {
+				each_value = /*metadata*/ ctx[6].dots;
+				let i;
+
+				for (i = 0; i < each_value.length; i += 1) {
+					const child_ctx = get_each_context$1(ctx, each_value, i);
+
+					if (each_blocks[i]) {
+						each_blocks[i].p(child_ctx, dirty);
+						transition_in(each_blocks[i], 1);
+					} else {
+						each_blocks[i] = create_each_block$1(child_ctx);
+						each_blocks[i].c();
+						transition_in(each_blocks[i], 1);
+						each_blocks[i].m(div0, null);
+					}
+				}
+
+				group_outros();
+
+				for (i = each_value.length; i < each_blocks.length; i += 1) {
+					out(i);
+				}
+
+				check_outros();
+			}
+
+			if (!current || dirty & /*metadata*/ 64 && div1_class_value !== (div1_class_value = "" + (null_to_empty(`week-num ${/*metadata*/ ctx[6].classes.join(" ")}`) + " svelte-egt0yd"))) {
+				attr(div1, "class", div1_class_value);
+			}
+
+			if (dirty & /*metadata, selectedId, getDateUID, days*/ 98) {
+				toggle_class(div1, "active", /*selectedId*/ ctx[5] === getDateUID_1(/*days*/ ctx[1][0], "week"));
+			}
+		},
+		i(local) {
+			if (current) return;
+
+			for (let i = 0; i < each_value.length; i += 1) {
+				transition_in(each_blocks[i]);
+			}
+
+			current = true;
+		},
+		o(local) {
+			each_blocks = each_blocks.filter(Boolean);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				transition_out(each_blocks[i]);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(div1);
+			destroy_each(each_blocks, detaching);
+			mounted = false;
+			run_all(dispose);
+		}
+	};
+}
+
+function create_fragment$1(ctx) {
+	let td;
+	let metadataresolver;
+	let current;
+
+	metadataresolver = new MetadataResolver({
+			props: {
+				metadata: /*metadata*/ ctx[6],
+				$$slots: {
+					default: [
+						create_default_slot,
+						({ metadata }) => ({ 6: metadata }),
+						({ metadata }) => metadata ? 64 : 0
+					]
+				},
+				$$scope: { ctx }
+			}
+		});
+
+	return {
+		c() {
+			td = element("td");
+			create_component(metadataresolver.$$.fragment);
+			attr(td, "class", "svelte-egt0yd");
+		},
+		m(target, anchor) {
+			insert(target, td, anchor);
+			mount_component(metadataresolver, td, null);
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			const metadataresolver_changes = {};
+			if (dirty & /*metadata*/ 64) metadataresolver_changes.metadata = /*metadata*/ ctx[6];
+
+			if (dirty & /*$$scope, metadata, selectedId, days, onClick, startOfWeek, onContextMenu, onHover, weekNum*/ 16639) {
+				metadataresolver_changes.$$scope = { dirty, ctx };
+			}
+
+			metadataresolver.$set(metadataresolver_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(metadataresolver.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(metadataresolver.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(td);
+			destroy_component(metadataresolver);
+		}
+	};
+}
+
+function instance$1($$self, $$props, $$invalidate) {
+	
+	
+	let { weekNum } = $$props;
+	let { days } = $$props;
+	let { metadata } = $$props;
+	let { onHover } = $$props;
+	let { onClick } = $$props;
+	let { onContextMenu } = $$props;
+	let { selectedId = null } = $$props;
+	let startOfWeek;
+	const click_handler = e => onClick(startOfWeek, isMetaPressed(e));
+	const contextmenu_handler = e => onContextMenu(days[0], e);
+	const pointerover_handler = e => onHover(startOfWeek, e.target, isMetaPressed(e));
+
+	$$self.$$set = $$props => {
+		if ("weekNum" in $$props) $$invalidate(0, weekNum = $$props.weekNum);
+		if ("days" in $$props) $$invalidate(1, days = $$props.days);
+		if ("metadata" in $$props) $$invalidate(6, metadata = $$props.metadata);
+		if ("onHover" in $$props) $$invalidate(2, onHover = $$props.onHover);
+		if ("onClick" in $$props) $$invalidate(3, onClick = $$props.onClick);
+		if ("onContextMenu" in $$props) $$invalidate(4, onContextMenu = $$props.onContextMenu);
+		if ("selectedId" in $$props) $$invalidate(5, selectedId = $$props.selectedId);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*days*/ 2) {
+			$$invalidate(7, startOfWeek = getStartOfWeek(days));
+		}
+	};
+
+	return [
+		weekNum,
+		days,
+		onHover,
+		onClick,
+		onContextMenu,
+		selectedId,
+		metadata,
+		startOfWeek,
+		click_handler,
+		contextmenu_handler,
+		pointerover_handler
+	];
+}
+
+class WeekNum extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-egt0yd-style")) add_css$1();
+
+		init(this, options, instance$1, create_fragment$1, not_equal, {
+			weekNum: 0,
+			days: 1,
+			metadata: 6,
+			onHover: 2,
+			onClick: 3,
+			onContextMenu: 4,
+			selectedId: 5
+		});
+	}
+}
+
+async function metadataReducer(promisedMetadata) {
+    const meta = {
+        dots: [],
+        classes: [],
+        dataAttributes: {},
+    };
+    const metas = await Promise.all(promisedMetadata);
+    return metas.reduce((acc, meta) => ({
+        classes: [...acc.classes, ...(meta.classes || [])],
+        dataAttributes: Object.assign(acc.dataAttributes, meta.dataAttributes),
+        dots: [...acc.dots, ...(meta.dots || [])],
+    }), meta);
+}
+function getDailyMetadata(sources, date, ..._args) {
+    return metadataReducer(sources.map((source) => source.getDailyMetadata(date)));
+}
+function getWeeklyMetadata(sources, date, ..._args) {
+    return metadataReducer(sources.map((source) => source.getWeeklyMetadata(date)));
+}
+
+/* src/components/Calendar.svelte generated by Svelte v3.35.0 */
+
+function add_css() {
+	var style = element("style");
+	style.id = "svelte-pcimu8-style";
+	style.textContent = ".container.svelte-pcimu8{--color-background-heading:transparent;--color-background-day:transparent;--color-background-weeknum:transparent;--color-background-weekend:transparent;--color-dot:var(--text-muted);--color-arrow:var(--text-muted);--color-button:var(--text-muted);--color-text-title:var(--text-normal);--color-text-heading:var(--text-muted);--color-text-day:var(--text-normal);--color-text-today:var(--interactive-accent);--color-text-weeknum:var(--text-muted)}.container.svelte-pcimu8{padding:0 8px}.container.is-mobile.svelte-pcimu8{padding:0}th.svelte-pcimu8{text-align:center}.weekend.svelte-pcimu8{background-color:var(--color-background-weekend)}.calendar.svelte-pcimu8{border-collapse:collapse;width:100%}th.svelte-pcimu8{background-color:var(--color-background-heading);color:var(--color-text-heading);font-size:0.6em;letter-spacing:1px;padding:4px;text-transform:uppercase}";
+	append(document.head, style);
+}
+
+function get_each_context(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[18] = list[i];
+	return child_ctx;
+}
+
+function get_each_context_1(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[21] = list[i];
+	return child_ctx;
+}
+
+function get_each_context_2(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[24] = list[i];
+	return child_ctx;
+}
+
+function get_each_context_3(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[27] = list[i];
+	return child_ctx;
+}
+
+// (55:6) {#if showWeekNums}
+function create_if_block_2(ctx) {
+	let col;
+
+	return {
+		c() {
+			col = element("col");
+		},
+		m(target, anchor) {
+			insert(target, col, anchor);
+		},
+		d(detaching) {
+			if (detaching) detach(col);
+		}
+	};
+}
+
+// (58:6) {#each month[1].days as date}
+function create_each_block_3(ctx) {
+	let col;
+
+	return {
+		c() {
+			col = element("col");
+			attr(col, "class", "svelte-pcimu8");
+			toggle_class(col, "weekend", isWeekend(/*date*/ ctx[27]));
+		},
+		m(target, anchor) {
+			insert(target, col, anchor);
+		},
+		p(ctx, dirty) {
+			if (dirty & /*isWeekend, month*/ 16384) {
+				toggle_class(col, "weekend", isWeekend(/*date*/ ctx[27]));
+			}
+		},
+		d(detaching) {
+			if (detaching) detach(col);
+		}
+	};
+}
+
+// (64:8) {#if showWeekNums}
+function create_if_block_1(ctx) {
+	let th;
+
+	return {
+		c() {
+			th = element("th");
+			th.textContent = "W";
+			attr(th, "class", "svelte-pcimu8");
+		},
+		m(target, anchor) {
+			insert(target, th, anchor);
+		},
+		d(detaching) {
+			if (detaching) detach(th);
+		}
+	};
+}
+
+// (67:8) {#each daysOfWeek as dayOfWeek}
+function create_each_block_2(ctx) {
+	let th;
+	let t_value = /*dayOfWeek*/ ctx[24] + "";
+	let t;
+
+	return {
+		c() {
+			th = element("th");
+			t = text(t_value);
+			attr(th, "class", "svelte-pcimu8");
+		},
+		m(target, anchor) {
+			insert(target, th, anchor);
+			append(th, t);
+		},
+		p(ctx, dirty) {
+			if (dirty & /*daysOfWeek*/ 32768 && t_value !== (t_value = /*dayOfWeek*/ ctx[24] + "")) set_data(t, t_value);
+		},
+		d(detaching) {
+			if (detaching) detach(th);
+		}
+	};
+}
+
+// (75:10) {#if showWeekNums}
+function create_if_block(ctx) {
+	let weeknum;
+	let current;
+
+	const weeknum_spread_levels = [
+		/*week*/ ctx[18],
+		{
+			metadata: getWeeklyMetadata(/*sources*/ ctx[8], /*week*/ ctx[18].days[0], /*today*/ ctx[10])
+		},
+		{ onClick: /*onClickWeek*/ ctx[7] },
+		{
+			onContextMenu: /*onContextMenuWeek*/ ctx[5]
+		},
+		{ onHover: /*onHoverWeek*/ ctx[3] },
+		{ selectedId: /*selectedId*/ ctx[9] }
+	];
+
+	let weeknum_props = {};
+
+	for (let i = 0; i < weeknum_spread_levels.length; i += 1) {
+		weeknum_props = assign(weeknum_props, weeknum_spread_levels[i]);
+	}
+
+	weeknum = new WeekNum({ props: weeknum_props });
+
+	return {
+		c() {
+			create_component(weeknum.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(weeknum, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const weeknum_changes = (dirty & /*month, getWeeklyMetadata, sources, today, onClickWeek, onContextMenuWeek, onHoverWeek, selectedId*/ 18344)
+			? get_spread_update(weeknum_spread_levels, [
+					dirty & /*month*/ 16384 && get_spread_object(/*week*/ ctx[18]),
+					dirty & /*getWeeklyMetadata, sources, month, today*/ 17664 && {
+						metadata: getWeeklyMetadata(/*sources*/ ctx[8], /*week*/ ctx[18].days[0], /*today*/ ctx[10])
+					},
+					dirty & /*onClickWeek*/ 128 && { onClick: /*onClickWeek*/ ctx[7] },
+					dirty & /*onContextMenuWeek*/ 32 && {
+						onContextMenu: /*onContextMenuWeek*/ ctx[5]
+					},
+					dirty & /*onHoverWeek*/ 8 && { onHover: /*onHoverWeek*/ ctx[3] },
+					dirty & /*selectedId*/ 512 && { selectedId: /*selectedId*/ ctx[9] }
+				])
+			: {};
+
+			weeknum.$set(weeknum_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(weeknum.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(weeknum.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(weeknum, detaching);
+		}
+	};
+}
+
+// (85:10) {#each week.days as day (day.format())}
+function create_each_block_1(key_1, ctx) {
+	let first;
+	let day;
+	let current;
+
+	day = new Day({
+			props: {
+				date: /*day*/ ctx[21],
+				today: /*today*/ ctx[10],
+				displayedMonth: /*displayedMonth*/ ctx[0],
+				onClick: /*onClickDay*/ ctx[6],
+				onContextMenu: /*onContextMenuDay*/ ctx[4],
+				onHover: /*onHoverDay*/ ctx[2],
+				metadata: getDailyMetadata(/*sources*/ ctx[8], /*day*/ ctx[21], /*today*/ ctx[10]),
+				selectedId: /*selectedId*/ ctx[9]
+			}
+		});
+
+	return {
+		key: key_1,
+		first: null,
+		c() {
+			first = empty();
+			create_component(day.$$.fragment);
+			this.first = first;
+		},
+		m(target, anchor) {
+			insert(target, first, anchor);
+			mount_component(day, target, anchor);
+			current = true;
+		},
+		p(new_ctx, dirty) {
+			ctx = new_ctx;
+			const day_changes = {};
+			if (dirty & /*month*/ 16384) day_changes.date = /*day*/ ctx[21];
+			if (dirty & /*today*/ 1024) day_changes.today = /*today*/ ctx[10];
+			if (dirty & /*displayedMonth*/ 1) day_changes.displayedMonth = /*displayedMonth*/ ctx[0];
+			if (dirty & /*onClickDay*/ 64) day_changes.onClick = /*onClickDay*/ ctx[6];
+			if (dirty & /*onContextMenuDay*/ 16) day_changes.onContextMenu = /*onContextMenuDay*/ ctx[4];
+			if (dirty & /*onHoverDay*/ 4) day_changes.onHover = /*onHoverDay*/ ctx[2];
+			if (dirty & /*sources, month, today*/ 17664) day_changes.metadata = getDailyMetadata(/*sources*/ ctx[8], /*day*/ ctx[21], /*today*/ ctx[10]);
+			if (dirty & /*selectedId*/ 512) day_changes.selectedId = /*selectedId*/ ctx[9];
+			day.$set(day_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(day.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(day.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(first);
+			destroy_component(day, detaching);
+		}
+	};
+}
+
+// (73:6) {#each month as week (week.weekNum)}
+function create_each_block(key_1, ctx) {
+	let tr;
+	let t0;
+	let each_blocks = [];
+	let each_1_lookup = new Map();
+	let t1;
+	let current;
+	let if_block = /*showWeekNums*/ ctx[1] && create_if_block(ctx);
+	let each_value_1 = /*week*/ ctx[18].days;
+	const get_key = ctx => /*day*/ ctx[21].format();
+
+	for (let i = 0; i < each_value_1.length; i += 1) {
+		let child_ctx = get_each_context_1(ctx, each_value_1, i);
+		let key = get_key(child_ctx);
+		each_1_lookup.set(key, each_blocks[i] = create_each_block_1(key, child_ctx));
+	}
+
+	return {
+		key: key_1,
+		first: null,
+		c() {
+			tr = element("tr");
+			if (if_block) if_block.c();
+			t0 = space();
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].c();
+			}
+
+			t1 = space();
+			this.first = tr;
+		},
+		m(target, anchor) {
+			insert(target, tr, anchor);
+			if (if_block) if_block.m(tr, null);
+			append(tr, t0);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].m(tr, null);
+			}
+
+			append(tr, t1);
+			current = true;
+		},
+		p(new_ctx, dirty) {
+			ctx = new_ctx;
+
+			if (/*showWeekNums*/ ctx[1]) {
+				if (if_block) {
+					if_block.p(ctx, dirty);
+
+					if (dirty & /*showWeekNums*/ 2) {
+						transition_in(if_block, 1);
+					}
+				} else {
+					if_block = create_if_block(ctx);
+					if_block.c();
+					transition_in(if_block, 1);
+					if_block.m(tr, t0);
+				}
+			} else if (if_block) {
+				group_outros();
+
+				transition_out(if_block, 1, 1, () => {
+					if_block = null;
+				});
+
+				check_outros();
+			}
+
+			if (dirty & /*month, today, displayedMonth, onClickDay, onContextMenuDay, onHoverDay, getDailyMetadata, sources, selectedId*/ 18261) {
+				each_value_1 = /*week*/ ctx[18].days;
+				group_outros();
+				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value_1, each_1_lookup, tr, outro_and_destroy_block, create_each_block_1, t1, get_each_context_1);
+				check_outros();
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(if_block);
+
+			for (let i = 0; i < each_value_1.length; i += 1) {
+				transition_in(each_blocks[i]);
+			}
+
+			current = true;
+		},
+		o(local) {
+			transition_out(if_block);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				transition_out(each_blocks[i]);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(tr);
+			if (if_block) if_block.d();
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].d();
+			}
+		}
+	};
+}
+
+function create_fragment$7(ctx) {
+	let div;
+	let nav;
+	let t0;
+	let table;
+	let colgroup;
+	let t1;
+	let t2;
+	let thead;
+	let tr;
+	let t3;
+	let t4;
+	let tbody;
+	let each_blocks = [];
+	let each2_lookup = new Map();
+	let current;
+
+	nav = new Nav({
+			props: {
+				today: /*today*/ ctx[10],
+				displayedMonth: /*displayedMonth*/ ctx[0],
+				incrementDisplayedMonth: /*incrementDisplayedMonth*/ ctx[11],
+				decrementDisplayedMonth: /*decrementDisplayedMonth*/ ctx[12],
+				resetDisplayedMonth: /*resetDisplayedMonth*/ ctx[13]
+			}
+		});
+
+	let if_block0 = /*showWeekNums*/ ctx[1] && create_if_block_2();
+	let each_value_3 = /*month*/ ctx[14][1].days;
+	let each_blocks_2 = [];
+
+	for (let i = 0; i < each_value_3.length; i += 1) {
+		each_blocks_2[i] = create_each_block_3(get_each_context_3(ctx, each_value_3, i));
+	}
+
+	let if_block1 = /*showWeekNums*/ ctx[1] && create_if_block_1();
+	let each_value_2 = /*daysOfWeek*/ ctx[15];
+	let each_blocks_1 = [];
+
+	for (let i = 0; i < each_value_2.length; i += 1) {
+		each_blocks_1[i] = create_each_block_2(get_each_context_2(ctx, each_value_2, i));
+	}
+
+	let each_value = /*month*/ ctx[14];
+	const get_key = ctx => /*week*/ ctx[18].weekNum;
+
+	for (let i = 0; i < each_value.length; i += 1) {
+		let child_ctx = get_each_context(ctx, each_value, i);
+		let key = get_key(child_ctx);
+		each2_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx));
+	}
+
+	return {
+		c() {
+			div = element("div");
+			create_component(nav.$$.fragment);
+			t0 = space();
+			table = element("table");
+			colgroup = element("colgroup");
+			if (if_block0) if_block0.c();
+			t1 = space();
+
+			for (let i = 0; i < each_blocks_2.length; i += 1) {
+				each_blocks_2[i].c();
+			}
+
+			t2 = space();
+			thead = element("thead");
+			tr = element("tr");
+			if (if_block1) if_block1.c();
+			t3 = space();
+
+			for (let i = 0; i < each_blocks_1.length; i += 1) {
+				each_blocks_1[i].c();
+			}
+
+			t4 = space();
+			tbody = element("tbody");
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].c();
+			}
+
+			attr(table, "class", "calendar svelte-pcimu8");
+			attr(div, "id", "calendar-container");
+			attr(div, "class", "container svelte-pcimu8");
+			toggle_class(div, "is-mobile", /*isMobile*/ ctx[16]);
+		},
+		m(target, anchor) {
+			insert(target, div, anchor);
+			mount_component(nav, div, null);
+			append(div, t0);
+			append(div, table);
+			append(table, colgroup);
+			if (if_block0) if_block0.m(colgroup, null);
+			append(colgroup, t1);
+
+			for (let i = 0; i < each_blocks_2.length; i += 1) {
+				each_blocks_2[i].m(colgroup, null);
+			}
+
+			append(table, t2);
+			append(table, thead);
+			append(thead, tr);
+			if (if_block1) if_block1.m(tr, null);
+			append(tr, t3);
+
+			for (let i = 0; i < each_blocks_1.length; i += 1) {
+				each_blocks_1[i].m(tr, null);
+			}
+
+			append(table, t4);
+			append(table, tbody);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].m(tbody, null);
+			}
+
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			const nav_changes = {};
+			if (dirty & /*today*/ 1024) nav_changes.today = /*today*/ ctx[10];
+			if (dirty & /*displayedMonth*/ 1) nav_changes.displayedMonth = /*displayedMonth*/ ctx[0];
+			nav.$set(nav_changes);
+
+			if (/*showWeekNums*/ ctx[1]) {
+				if (if_block0) ; else {
+					if_block0 = create_if_block_2();
+					if_block0.c();
+					if_block0.m(colgroup, t1);
+				}
+			} else if (if_block0) {
+				if_block0.d(1);
+				if_block0 = null;
+			}
+
+			if (dirty & /*isWeekend, month*/ 16384) {
+				each_value_3 = /*month*/ ctx[14][1].days;
+				let i;
+
+				for (i = 0; i < each_value_3.length; i += 1) {
+					const child_ctx = get_each_context_3(ctx, each_value_3, i);
+
+					if (each_blocks_2[i]) {
+						each_blocks_2[i].p(child_ctx, dirty);
+					} else {
+						each_blocks_2[i] = create_each_block_3(child_ctx);
+						each_blocks_2[i].c();
+						each_blocks_2[i].m(colgroup, null);
+					}
+				}
+
+				for (; i < each_blocks_2.length; i += 1) {
+					each_blocks_2[i].d(1);
+				}
+
+				each_blocks_2.length = each_value_3.length;
+			}
+
+			if (/*showWeekNums*/ ctx[1]) {
+				if (if_block1) ; else {
+					if_block1 = create_if_block_1();
+					if_block1.c();
+					if_block1.m(tr, t3);
+				}
+			} else if (if_block1) {
+				if_block1.d(1);
+				if_block1 = null;
+			}
+
+			if (dirty & /*daysOfWeek*/ 32768) {
+				each_value_2 = /*daysOfWeek*/ ctx[15];
+				let i;
+
+				for (i = 0; i < each_value_2.length; i += 1) {
+					const child_ctx = get_each_context_2(ctx, each_value_2, i);
+
+					if (each_blocks_1[i]) {
+						each_blocks_1[i].p(child_ctx, dirty);
+					} else {
+						each_blocks_1[i] = create_each_block_2(child_ctx);
+						each_blocks_1[i].c();
+						each_blocks_1[i].m(tr, null);
+					}
+				}
+
+				for (; i < each_blocks_1.length; i += 1) {
+					each_blocks_1[i].d(1);
+				}
+
+				each_blocks_1.length = each_value_2.length;
+			}
+
+			if (dirty & /*month, today, displayedMonth, onClickDay, onContextMenuDay, onHoverDay, getDailyMetadata, sources, selectedId, getWeeklyMetadata, onClickWeek, onContextMenuWeek, onHoverWeek, showWeekNums*/ 18431) {
+				each_value = /*month*/ ctx[14];
+				group_outros();
+				each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each2_lookup, tbody, outro_and_destroy_block, create_each_block, null, get_each_context);
+				check_outros();
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(nav.$$.fragment, local);
+
+			for (let i = 0; i < each_value.length; i += 1) {
+				transition_in(each_blocks[i]);
+			}
+
+			current = true;
+		},
+		o(local) {
+			transition_out(nav.$$.fragment, local);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				transition_out(each_blocks[i]);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(div);
+			destroy_component(nav);
+			if (if_block0) if_block0.d();
+			destroy_each(each_blocks_2, detaching);
+			if (if_block1) if_block1.d();
+			destroy_each(each_blocks_1, detaching);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].d();
+			}
+		}
+	};
+}
+
+function instance$7($$self, $$props, $$invalidate) {
+	
+	
+	let { localeData } = $$props;
+	let { showWeekNums = false } = $$props;
+	let { onHoverDay } = $$props;
+	let { onHoverWeek } = $$props;
+	let { onContextMenuDay } = $$props;
+	let { onContextMenuWeek } = $$props;
+	let { onClickDay } = $$props;
+	let { onClickWeek } = $$props;
+	let { sources = [] } = $$props;
+	let { selectedId } = $$props;
+	let { today = window.moment() } = $$props;
+	let { displayedMonth = today } = $$props;
+	let month;
+	let daysOfWeek;
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let isMobile = window.app.isMobile;
+
+	function incrementDisplayedMonth() {
+		$$invalidate(0, displayedMonth = displayedMonth.clone().add(1, "month"));
+	}
+
+	function decrementDisplayedMonth() {
+		$$invalidate(0, displayedMonth = displayedMonth.clone().subtract(1, "month"));
+	}
+
+	function resetDisplayedMonth() {
+		$$invalidate(0, displayedMonth = today.clone());
+	}
+
+	$$self.$$set = $$props => {
+		if ("localeData" in $$props) $$invalidate(17, localeData = $$props.localeData);
+		if ("showWeekNums" in $$props) $$invalidate(1, showWeekNums = $$props.showWeekNums);
+		if ("onHoverDay" in $$props) $$invalidate(2, onHoverDay = $$props.onHoverDay);
+		if ("onHoverWeek" in $$props) $$invalidate(3, onHoverWeek = $$props.onHoverWeek);
+		if ("onContextMenuDay" in $$props) $$invalidate(4, onContextMenuDay = $$props.onContextMenuDay);
+		if ("onContextMenuWeek" in $$props) $$invalidate(5, onContextMenuWeek = $$props.onContextMenuWeek);
+		if ("onClickDay" in $$props) $$invalidate(6, onClickDay = $$props.onClickDay);
+		if ("onClickWeek" in $$props) $$invalidate(7, onClickWeek = $$props.onClickWeek);
+		if ("sources" in $$props) $$invalidate(8, sources = $$props.sources);
+		if ("selectedId" in $$props) $$invalidate(9, selectedId = $$props.selectedId);
+		if ("today" in $$props) $$invalidate(10, today = $$props.today);
+		if ("displayedMonth" in $$props) $$invalidate(0, displayedMonth = $$props.displayedMonth);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*displayedMonth, localeData*/ 131073) {
+			$$invalidate(14, month = getMonth(displayedMonth, localeData));
+		}
+
+		if ($$self.$$.dirty & /*today, localeData*/ 132096) {
+			$$invalidate(15, daysOfWeek = getDaysOfWeek(today, localeData));
+		}
+	};
+
+	return [
+		displayedMonth,
+		showWeekNums,
+		onHoverDay,
+		onHoverWeek,
+		onContextMenuDay,
+		onContextMenuWeek,
+		onClickDay,
+		onClickWeek,
+		sources,
+		selectedId,
+		today,
+		incrementDisplayedMonth,
+		decrementDisplayedMonth,
+		resetDisplayedMonth,
+		month,
+		daysOfWeek,
+		isMobile,
+		localeData
+	];
+}
+
+class Calendar$1 extends SvelteComponent {
+	constructor(options) {
+		super();
+		if (!document.getElementById("svelte-pcimu8-style")) add_css();
+
+		init(this, options, instance$7, create_fragment$7, not_equal, {
+			localeData: 17,
+			showWeekNums: 1,
+			onHoverDay: 2,
+			onHoverWeek: 3,
+			onContextMenuDay: 4,
+			onContextMenuWeek: 5,
+			onClickDay: 6,
+			onClickWeek: 7,
+			sources: 8,
+			selectedId: 9,
+			today: 10,
+			displayedMonth: 0,
+			incrementDisplayedMonth: 11,
+			decrementDisplayedMonth: 12,
+			resetDisplayedMonth: 13
+		});
+	}
+
+	get incrementDisplayedMonth() {
+		return this.$$.ctx[11];
+	}
+
+	get decrementDisplayedMonth() {
+		return this.$$.ctx[12];
+	}
+
+	get resetDisplayedMonth() {
+		return this.$$.ctx[13];
+	}
+}
+
+const langToMomentLocale = {
+    en: "en-gb",
+    zh: "zh-cn",
+    "zh-TW": "zh-tw",
+    ru: "ru",
+    ko: "ko",
+    it: "it",
+    id: "id",
+    ro: "ro",
+    "pt-BR": "pt-br",
+    cz: "cs",
+    da: "da",
+    de: "de",
+    es: "es",
+    fr: "fr",
+    no: "nn",
+    pl: "pl",
+    pt: "pt",
+    tr: "tr",
+    hi: "hi",
+    nl: "nl",
+    ar: "ar",
+    ja: "ja",
+};
+const weekdays = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+];
+function overrideGlobalMomentWeekStart(weekStart) {
+    const { moment } = window;
+    const currentLocale = moment.locale();
+    // Save the initial locale weekspec so that we can restore
+    // it when toggling between the different options in settings.
+    if (!window._bundledLocaleWeekSpec) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        window._bundledLocaleWeekSpec = moment.localeData()._week;
+    }
+    if (weekStart === "locale") {
+        moment.updateLocale(currentLocale, {
+            week: window._bundledLocaleWeekSpec,
+        });
+    }
+    else {
+        moment.updateLocale(currentLocale, {
+            week: {
+                dow: weekdays.indexOf(weekStart) || 0,
+            },
+        });
+    }
+}
+/**
+ * Sets the locale used by the calendar. This allows the calendar to
+ * default to the user's locale (e.g. Start Week on Sunday/Monday/Friday)
+ *
+ * @param localeOverride locale string (e.g. "en-US")
+ */
+function configureGlobalMomentLocale(localeOverride = "system-default", weekStart = "locale") {
+    var _a;
+    const obsidianLang = localStorage.getItem("language") || "en";
+    const systemLang = (_a = navigator.language) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    let momentLocale = langToMomentLocale[obsidianLang];
+    if (localeOverride !== "system-default") {
+        momentLocale = localeOverride;
+    }
+    else if (systemLang.startsWith(obsidianLang)) {
+        // If the system locale is more specific (en-gb vs en), use the system locale.
+        momentLocale = systemLang;
+    }
+    const currentLocale = window.moment.locale(momentLocale);
+    console.debug(`[Calendar] Trying to switch Moment.js global locale to ${momentLocale}, got ${currentLocale}`);
+    overrideGlobalMomentWeekStart(weekStart);
+    return currentLocale;
+}
+
+/* src/ui/Calendar.svelte generated by Svelte v3.35.0 */
+
+function create_fragment(ctx) {
+	let calendarbase;
+	let updating_displayedMonth;
+	let current;
+
+	function calendarbase_displayedMonth_binding(value) {
+		/*calendarbase_displayedMonth_binding*/ ctx[12](value);
+	}
+
+	let calendarbase_props = {
+		sources: /*sources*/ ctx[1],
+		today: /*today*/ ctx[9],
+		onHoverDay: /*onHoverDay*/ ctx[2],
+		onHoverWeek: /*onHoverWeek*/ ctx[3],
+		onContextMenuDay: /*onContextMenuDay*/ ctx[6],
+		onContextMenuWeek: /*onContextMenuWeek*/ ctx[7],
+		onClickDay: /*onClickDay*/ ctx[4],
+		onClickWeek: /*onClickWeek*/ ctx[5],
+		localeData: /*today*/ ctx[9].localeData(),
+		selectedId: /*$activeFile*/ ctx[10],
+		showWeekNums: /*$settings*/ ctx[8].showWeeklyNote
+	};
+
+	if (/*displayedMonth*/ ctx[0] !== void 0) {
+		calendarbase_props.displayedMonth = /*displayedMonth*/ ctx[0];
+	}
+
+	calendarbase = new Calendar$1({ props: calendarbase_props });
+	binding_callbacks$1.push(() => bind(calendarbase, "displayedMonth", calendarbase_displayedMonth_binding));
+
+	return {
+		c() {
+			create_component$1(calendarbase.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component$1(calendarbase, target, anchor);
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			const calendarbase_changes = {};
+			if (dirty & /*sources*/ 2) calendarbase_changes.sources = /*sources*/ ctx[1];
+			if (dirty & /*today*/ 512) calendarbase_changes.today = /*today*/ ctx[9];
+			if (dirty & /*onHoverDay*/ 4) calendarbase_changes.onHoverDay = /*onHoverDay*/ ctx[2];
+			if (dirty & /*onHoverWeek*/ 8) calendarbase_changes.onHoverWeek = /*onHoverWeek*/ ctx[3];
+			if (dirty & /*onContextMenuDay*/ 64) calendarbase_changes.onContextMenuDay = /*onContextMenuDay*/ ctx[6];
+			if (dirty & /*onContextMenuWeek*/ 128) calendarbase_changes.onContextMenuWeek = /*onContextMenuWeek*/ ctx[7];
+			if (dirty & /*onClickDay*/ 16) calendarbase_changes.onClickDay = /*onClickDay*/ ctx[4];
+			if (dirty & /*onClickWeek*/ 32) calendarbase_changes.onClickWeek = /*onClickWeek*/ ctx[5];
+			if (dirty & /*today*/ 512) calendarbase_changes.localeData = /*today*/ ctx[9].localeData();
+			if (dirty & /*$activeFile*/ 1024) calendarbase_changes.selectedId = /*$activeFile*/ ctx[10];
+			if (dirty & /*$settings*/ 256) calendarbase_changes.showWeekNums = /*$settings*/ ctx[8].showWeeklyNote;
+
+			if (!updating_displayedMonth && dirty & /*displayedMonth*/ 1) {
+				updating_displayedMonth = true;
+				calendarbase_changes.displayedMonth = /*displayedMonth*/ ctx[0];
+				add_flush_callback(() => updating_displayedMonth = false);
+			}
+
+			calendarbase.$set(calendarbase_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in$1(calendarbase.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out$1(calendarbase.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component$1(calendarbase, detaching);
+		}
+	};
+}
+
+function instance($$self, $$props, $$invalidate) {
+	let $settings;
+	let $activeFile;
+	component_subscribe($$self, settings, $$value => $$invalidate(8, $settings = $$value));
+	component_subscribe($$self, activeFile, $$value => $$invalidate(10, $activeFile = $$value));
+	
+	
+	let today;
+	let { displayedMonth = today } = $$props;
+	let { sources } = $$props;
+	let { onHoverDay } = $$props;
+	let { onHoverWeek } = $$props;
+	let { onClickDay } = $$props;
+	let { onClickWeek } = $$props;
+	let { onContextMenuDay } = $$props;
+	let { onContextMenuWeek } = $$props;
+
+	function tick() {
+		$$invalidate(9, today = window.moment());
+	}
+
+	function getToday(settings) {
+		configureGlobalMomentLocale(settings.localeOverride, settings.weekStart);
+		dailyNotes.reindex();
+		weeklyNotes.reindex();
+		return window.moment();
+	}
+
+	// 1 minute heartbeat to keep `today` reflecting the current day
+	let heartbeat = setInterval(
+		() => {
+			tick();
+			const isViewingCurrentMonth = displayedMonth.isSame(today, "day");
+
+			if (isViewingCurrentMonth) {
+				// if it's midnight on the last day of the month, this will
+				// update the display to show the new month.
+				$$invalidate(0, displayedMonth = today);
+			}
+		},
+		1000 * 60
+	);
+
+	onDestroy(() => {
+		clearInterval(heartbeat);
+	});
+
+	function calendarbase_displayedMonth_binding(value) {
+		displayedMonth = value;
+		$$invalidate(0, displayedMonth);
+	}
+
+	$$self.$$set = $$props => {
+		if ("displayedMonth" in $$props) $$invalidate(0, displayedMonth = $$props.displayedMonth);
+		if ("sources" in $$props) $$invalidate(1, sources = $$props.sources);
+		if ("onHoverDay" in $$props) $$invalidate(2, onHoverDay = $$props.onHoverDay);
+		if ("onHoverWeek" in $$props) $$invalidate(3, onHoverWeek = $$props.onHoverWeek);
+		if ("onClickDay" in $$props) $$invalidate(4, onClickDay = $$props.onClickDay);
+		if ("onClickWeek" in $$props) $$invalidate(5, onClickWeek = $$props.onClickWeek);
+		if ("onContextMenuDay" in $$props) $$invalidate(6, onContextMenuDay = $$props.onContextMenuDay);
+		if ("onContextMenuWeek" in $$props) $$invalidate(7, onContextMenuWeek = $$props.onContextMenuWeek);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*$settings*/ 256) {
+			$$invalidate(9, today = getToday($settings));
+		}
+	};
+
+	return [
+		displayedMonth,
+		sources,
+		onHoverDay,
+		onHoverWeek,
+		onClickDay,
+		onClickWeek,
+		onContextMenuDay,
+		onContextMenuWeek,
+		$settings,
+		today,
+		$activeFile,
+		tick,
+		calendarbase_displayedMonth_binding
+	];
+}
+
+class Calendar extends SvelteComponent$1 {
+	constructor(options) {
+		super();
+
+		init$1(this, options, instance, create_fragment, not_equal$1, {
+			displayedMonth: 0,
+			sources: 1,
+			onHoverDay: 2,
+			onHoverWeek: 3,
+			onClickDay: 4,
+			onClickWeek: 5,
+			onContextMenuDay: 6,
+			onContextMenuWeek: 7,
+			tick: 11
+		});
+	}
+
+	get tick() {
+		return this.$$.ctx[11];
+	}
+}
+
+function showFileMenu(app, file, position) {
+    const fileMenu = new obsidian.Menu(app);
+    fileMenu.addItem((item) => item
+        .setTitle("Delete")
+        .setIcon("trash")
+        .onClick(() => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        app.fileManager.promptForFileDeletion(file);
+    }));
+    app.workspace.trigger("file-menu", fileMenu, file, "calendar-context-menu", null);
+    fileMenu.showAtPosition(position);
+}
+
+const getStreakClasses = (file) => {
+    return classList({
+        "has-note": !!file,
+    });
+};
+const streakSource = {
+    getDailyMetadata: async (date) => {
+        const file = getDailyNote_1(date, get_store_value(dailyNotes));
+        return {
+            classes: getStreakClasses(file),
+            dots: [],
+        };
+    },
+    getWeeklyMetadata: async (date) => {
+        const file = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        return {
+            classes: getStreakClasses(file),
+            dots: [],
+        };
+    },
+};
+
+function getNoteTags(note) {
+    var _a;
+    if (!note) {
+        return [];
+    }
+    const { metadataCache } = window.app;
+    const frontmatter = (_a = metadataCache.getFileCache(note)) === null || _a === void 0 ? void 0 : _a.frontmatter;
+    const tags = [];
+    if (frontmatter) {
+        const frontmatterTags = obsidian.parseFrontMatterTags(frontmatter) || [];
+        tags.push(...frontmatterTags);
+    }
+    // strip the '#' at the beginning
+    return tags.map((tag) => tag.substring(1));
+}
+function getFormattedTagAttributes(note) {
+    const attrs = {};
+    const tags = getNoteTags(note);
+    const [emojiTags, nonEmojiTags] = partition(tags, (tag) => /(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff]|[\u0023-\u0039]\ufe0f?\u20e3|\u3299|\u3297|\u303d|\u3030|\u24c2|\ud83c[\udd70-\udd71]|\ud83c[\udd7e-\udd7f]|\ud83c\udd8e|\ud83c[\udd91-\udd9a]|\ud83c[\udde6-\uddff]|\ud83c[\ude01-\ude02]|\ud83c\ude1a|\ud83c\ude2f|\ud83c[\ude32-\ude3a]|\ud83c[\ude50-\ude51]|\u203c|\u2049|[\u25aa-\u25ab]|\u25b6|\u25c0|[\u25fb-\u25fe]|\u00a9|\u00ae|\u2122|\u2139|\ud83c\udc04|[\u2600-\u26FF]|\u2b05|\u2b06|\u2b07|\u2b1b|\u2b1c|\u2b50|\u2b55|\u231a|\u231b|\u2328|\u23cf|[\u23e9-\u23f3]|[\u23f8-\u23fa]|\ud83c\udccf|\u2934|\u2935|[\u2190-\u21ff])/.test(tag));
+    if (nonEmojiTags) {
+        attrs["data-tags"] = nonEmojiTags.join(" ");
+    }
+    if (emojiTags) {
+        attrs["data-emoji-tag"] = emojiTags[0];
+    }
+    return attrs;
+}
+const customTagsSource = {
+    getDailyMetadata: async (date) => {
+        const file = getDailyNote_1(date, get_store_value(dailyNotes));
+        return {
+            dataAttributes: getFormattedTagAttributes(file),
+            dots: [],
+        };
+    },
+    getWeeklyMetadata: async (date) => {
+        const file = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        return {
+            dataAttributes: getFormattedTagAttributes(file),
+            dots: [],
+        };
+    },
+};
+
+async function getNumberOfRemainingTasks(note) {
+    if (!note) {
+        return 0;
+    }
+    const { vault } = window.app;
+    const fileContents = await vault.cachedRead(note);
+    return (fileContents.match(/(-|\*) \[ \]/g) || []).length;
+}
+async function getDotsForDailyNote$1(dailyNote) {
+    if (!dailyNote) {
+        return [];
+    }
+    const numTasks = await getNumberOfRemainingTasks(dailyNote);
+    const dots = [];
+    if (numTasks) {
+        dots.push({
+            className: "task",
+            color: "default",
+            isFilled: false,
+        });
+    }
+    return dots;
+}
+const tasksSource = {
+    getDailyMetadata: async (date) => {
+        const file = getDailyNote_1(date, get_store_value(dailyNotes));
+        const dots = await getDotsForDailyNote$1(file);
+        return {
+            dots,
+        };
+    },
+    getWeeklyMetadata: async (date) => {
+        const file = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        const dots = await getDotsForDailyNote$1(file);
+        return {
+            dots,
+        };
+    },
+};
+
+const NUM_MAX_DOTS = 5;
+async function getWordLengthAsDots(note) {
+    const { wordsPerDot = DEFAULT_WORDS_PER_DOT } = get_store_value(settings);
+    if (!note || wordsPerDot <= 0) {
+        return 0;
+    }
+    const fileContents = await window.app.vault.cachedRead(note);
+    const wordCount = getWordCount(fileContents);
+    const numDots = wordCount / wordsPerDot;
+    return clamp(Math.floor(numDots), 1, NUM_MAX_DOTS);
+}
+async function getDotsForDailyNote(dailyNote) {
+    if (!dailyNote) {
+        return [];
+    }
+    const numSolidDots = await getWordLengthAsDots(dailyNote);
+    const dots = [];
+    for (let i = 0; i < numSolidDots; i++) {
+        dots.push({
+            color: "default",
+            isFilled: true,
+        });
+    }
+    return dots;
+}
+const wordCountSource = {
+    getDailyMetadata: async (date) => {
+        const file = getDailyNote_1(date, get_store_value(dailyNotes));
+        const dots = await getDotsForDailyNote(file);
+        return {
+            dots,
+        };
+    },
+    getWeeklyMetadata: async (date) => {
+        const file = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        const dots = await getDotsForDailyNote(file);
+        return {
+            dots,
+        };
+    },
+};
+
+class CalendarView extends obsidian.ItemView {
+    constructor(leaf) {
+        super(leaf);
+        this.openOrCreateDailyNote = this.openOrCreateDailyNote.bind(this);
+        this.openOrCreateWeeklyNote = this.openOrCreateWeeklyNote.bind(this);
+        this.onNoteSettingsUpdate = this.onNoteSettingsUpdate.bind(this);
+        this.onFileCreated = this.onFileCreated.bind(this);
+        this.onFileDeleted = this.onFileDeleted.bind(this);
+        this.onFileModified = this.onFileModified.bind(this);
+        this.onFileOpen = this.onFileOpen.bind(this);
+        this.onHoverDay = this.onHoverDay.bind(this);
+        this.onHoverWeek = this.onHoverWeek.bind(this);
+        this.onContextMenuDay = this.onContextMenuDay.bind(this);
+        this.onContextMenuWeek = this.onContextMenuWeek.bind(this);
+        this.registerEvent(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.app.workspace.on("periodic-notes:settings-updated", this.onNoteSettingsUpdate));
+        this.registerEvent(this.app.vault.on("create", this.onFileCreated));
+        this.registerEvent(this.app.vault.on("delete", this.onFileDeleted));
+        this.registerEvent(this.app.vault.on("modify", this.onFileModified));
+        this.registerEvent(this.app.workspace.on("file-open", this.onFileOpen));
+        this.settings = null;
+        settings.subscribe((val) => {
+            this.settings = val;
+            // Refresh the calendar if settings change
+            if (this.calendar) {
+                this.calendar.tick();
+            }
+        });
+    }
+    getViewType() {
+        return VIEW_TYPE_CALENDAR;
+    }
+    getDisplayText() {
+        return "Calendar";
+    }
+    getIcon() {
+        return "calendar-with-checkmark";
+    }
+    onClose() {
+        if (this.calendar) {
+            this.calendar.$destroy();
+        }
+        return Promise.resolve();
+    }
+    async onOpen() {
+        // Integration point: external plugins can listen for `calendar:open`
+        // to feed in additional sources.
+        const sources = [
+            customTagsSource,
+            streakSource,
+            wordCountSource,
+            tasksSource,
+        ];
+        this.app.workspace.trigger(TRIGGER_ON_OPEN, sources);
+        this.calendar = new Calendar({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            target: this.contentEl,
+            props: {
+                onClickDay: this.openOrCreateDailyNote,
+                onClickWeek: this.openOrCreateWeeklyNote,
+                onHoverDay: this.onHoverDay,
+                onHoverWeek: this.onHoverWeek,
+                onContextMenuDay: this.onContextMenuDay,
+                onContextMenuWeek: this.onContextMenuWeek,
+                sources,
+            },
+        });
+    }
+    onHoverDay(date, targetEl, isMetaPressed) {
+        if (!isMetaPressed) {
+            return;
+        }
+        const { format } = getDailyNoteSettings_1();
+        const note = getDailyNote_1(date, get_store_value(dailyNotes));
+        this.app.workspace.trigger("link-hover", this, targetEl, date.format(format), note === null || note === void 0 ? void 0 : note.path);
+    }
+    onHoverWeek(date, targetEl, isMetaPressed) {
+        if (!isMetaPressed) {
+            return;
+        }
+        const note = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        const { format } = getWeeklyNoteSettings_1();
+        this.app.workspace.trigger("link-hover", this, targetEl, date.format(format), note === null || note === void 0 ? void 0 : note.path);
+    }
+    onContextMenuDay(date, event) {
+        const note = getDailyNote_1(date, get_store_value(dailyNotes));
+        if (!note) {
+            // If no file exists for a given day, show nothing.
+            return;
+        }
+        showFileMenu(this.app, note, {
+            x: event.pageX,
+            y: event.pageY,
+        });
+    }
+    onContextMenuWeek(date, event) {
+        const note = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        if (!note) {
+            // If no file exists for a given day, show nothing.
+            return;
+        }
+        showFileMenu(this.app, note, {
+            x: event.pageX,
+            y: event.pageY,
+        });
+    }
+    onNoteSettingsUpdate() {
+        dailyNotes.reindex();
+        weeklyNotes.reindex();
+        this.updateActiveFile();
+    }
+    async onFileDeleted(file) {
+        if (getDateFromFile_1(file, "day")) {
+            dailyNotes.reindex();
+            this.updateActiveFile();
+        }
+        if (getDateFromFile_1(file, "week")) {
+            weeklyNotes.reindex();
+            this.updateActiveFile();
+        }
+    }
+    async onFileModified(file) {
+        const date = getDateFromFile_1(file, "day") || getDateFromFile_1(file, "week");
+        if (date && this.calendar) {
+            this.calendar.tick();
+        }
+    }
+    onFileCreated(file) {
+        if (this.app.workspace.layoutReady && this.calendar) {
+            if (getDateFromFile_1(file, "day")) {
+                dailyNotes.reindex();
+                this.calendar.tick();
+            }
+            if (getDateFromFile_1(file, "week")) {
+                weeklyNotes.reindex();
+                this.calendar.tick();
+            }
+        }
+    }
+    onFileOpen(_file) {
+        if (this.app.workspace.layoutReady) {
+            this.updateActiveFile();
+        }
+    }
+    updateActiveFile() {
+        const { view } = this.app.workspace.activeLeaf;
+        let file = null;
+        if (view instanceof obsidian.FileView) {
+            file = view.file;
+        }
+        activeFile.setFile(file);
+        if (this.calendar) {
+            this.calendar.tick();
+        }
+    }
+    revealActiveNote() {
+        const { moment } = window;
+        const { activeLeaf } = this.app.workspace;
+        if (activeLeaf.view instanceof obsidian.FileView) {
+            // Check to see if the active note is a daily-note
+            let date = getDateFromFile_1(activeLeaf.view.file, "day");
+            if (date) {
+                this.calendar.$set({ displayedMonth: date });
+                return;
+            }
+            // Check to see if the active note is a weekly-note
+            const { format } = getWeeklyNoteSettings_1();
+            date = moment(activeLeaf.view.file.basename, format, true);
+            if (date.isValid()) {
+                this.calendar.$set({ displayedMonth: date });
+                return;
+            }
+        }
+    }
+    async openOrCreateWeeklyNote(date, inNewSplit) {
+        const { workspace } = this.app;
+        const startOfWeek = date.clone().startOf("week");
+        const existingFile = getWeeklyNote_1(date, get_store_value(weeklyNotes));
+        if (!existingFile) {
+            // File doesn't exist
+            tryToCreateWeeklyNote(startOfWeek, inNewSplit, this.settings, (file) => {
+                activeFile.setFile(file);
+            });
+            return;
+        }
+        const leaf = inNewSplit
+            ? workspace.splitActiveLeaf()
+            : workspace.getUnpinnedLeaf();
+        await leaf.openFile(existingFile);
+        activeFile.setFile(existingFile);
+    }
+    async openOrCreateDailyNote(date, inNewSplit) {
+        const { workspace } = this.app;
+        const existingFile = getDailyNote_1(date, get_store_value(dailyNotes));
+        if (!existingFile) {
+            // File doesn't exist
+            tryToCreateDailyNote(date, inNewSplit, this.settings, (dailyNote) => {
+                activeFile.setFile(dailyNote);
+            });
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mode = this.app.vault.getConfig("defaultViewMode");
+        const leaf = inNewSplit
+            ? workspace.splitActiveLeaf()
+            : workspace.getUnpinnedLeaf();
+        await leaf.openFile(existingFile, { mode });
+        activeFile.setFile(existingFile);
+    }
+}
+
+class CalendarPlugin extends obsidian.Plugin {
+    onunload() {
+        this.app.workspace
+            .getLeavesOfType(VIEW_TYPE_CALENDAR)
+            .forEach((leaf) => leaf.detach());
+    }
+    async onload() {
+        this.register(settings.subscribe((value) => {
+            this.options = value;
+        }));
+        this.registerView(VIEW_TYPE_CALENDAR, (leaf) => (this.view = new CalendarView(leaf)));
+        this.addCommand({
+            id: "show-calendar-view",
+            name: "Open view",
+            checkCallback: (checking) => {
+                if (checking) {
+                    return (this.app.workspace.getLeavesOfType(VIEW_TYPE_CALENDAR).length === 0);
+                }
+                this.initLeaf();
+            },
+        });
+        this.addCommand({
+            id: "open-weekly-note",
+            name: "Open Weekly Note",
+            checkCallback: (checking) => {
+                if (checking) {
+                    return !appHasPeriodicNotesPluginLoaded();
+                }
+                this.view.openOrCreateWeeklyNote(window.moment(), false);
+            },
+        });
+        this.addCommand({
+            id: "reveal-active-note",
+            name: "Reveal active note",
+            callback: () => this.view.revealActiveNote(),
+        });
+        await this.loadOptions();
+        this.addSettingTab(new CalendarSettingsTab(this.app, this));
+        if (this.app.workspace.layoutReady) {
+            this.initLeaf();
+        }
+        else {
+            this.registerEvent(this.app.workspace.on("layout-ready", this.initLeaf.bind(this)));
+        }
+    }
+    initLeaf() {
+        if (this.app.workspace.getLeavesOfType(VIEW_TYPE_CALENDAR).length) {
+            return;
+        }
+        this.app.workspace.getRightLeaf(false).setViewState({
+            type: VIEW_TYPE_CALENDAR,
+        });
+    }
+    async loadOptions() {
+        const options = await this.loadData();
+        settings.update((old) => {
+            return Object.assign(Object.assign({}, old), (options || {}));
+        });
+        await this.saveData(this.options);
+    }
+    async writeOptions(changeOpts) {
+        settings.update((old) => (Object.assign(Object.assign({}, old), changeOpts(old))));
+        await this.saveData(this.options);
+    }
+}
+
+module.exports = CalendarPlugin;
+
+/* nosourcemap */