From 4576a31dd3d5f964123de916edd624dbbb24792e Mon Sep 17 00:00:00 2001 From: Jesse James Isler Date: Mon, 27 Jun 2022 10:33:08 +0200 Subject: [PATCH] added encrypt/decrpyt workflow --- .obsidian/community-plugins.json | 4 +- .obsidian/core-plugins.json | 1 + .obsidian/plugins/calendar/data.json | 10 + .obsidian/plugins/calendar/main.js | 4457 ++++++++++++++++++ .obsidian/plugins/calendar/manifest.json | 10 + .obsidian/plugins/meld-encrypt/data.json | 7 + .obsidian/plugins/meld-encrypt/main.js | 764 +++ .obsidian/plugins/meld-encrypt/manifest.json | 10 + .obsidian/plugins/meld-encrypt/styles.css | 42 + .obsidian/workspace | 38 +- 10 files changed, 5331 insertions(+), 12 deletions(-) create mode 100644 .obsidian/plugins/calendar/data.json create mode 100644 .obsidian/plugins/calendar/main.js create mode 100644 .obsidian/plugins/calendar/manifest.json create mode 100644 .obsidian/plugins/meld-encrypt/data.json create mode 100644 .obsidian/plugins/meld-encrypt/main.js create mode 100644 .obsidian/plugins/meld-encrypt/manifest.json create mode 100644 .obsidian/plugins/meld-encrypt/styles.css diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index 431e842..31902b1 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -1,5 +1,7 @@ [ "obsidian-git", "table-editor-obsidian", - "obsidian-image-toolkit" + "obsidian-image-toolkit", + "calendar", + "meld-encrypt" ] \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json index d331556..1f21bdc 100644 --- a/.obsidian/core-plugins.json +++ b/.obsidian/core-plugins.json @@ -7,6 +7,7 @@ "outgoing-link", "tag-pane", "page-preview", + "daily-notes", "note-composer", "command-palette", "slash-command", diff --git a/.obsidian/plugins/calendar/data.json b/.obsidian/plugins/calendar/data.json new file mode 100644 index 0000000..b03e21d --- /dev/null +++ b/.obsidian/plugins/calendar/data.json @@ -0,0 +1,10 @@ +{ + "shouldConfirmBeforeCreate": true, + "weekStart": "locale", + "wordsPerDot": 250, + "showWeeklyNote": false, + "weeklyNoteFormat": "", + "weeklyNoteTemplate": "", + "weeklyNoteFolder": "", + "localeOverride": "system-default" +} \ No newline at end of file diff --git a/.obsidian/plugins/calendar/main.js b/.obsidian/plugins/calendar/main.js new file mode 100644 index 0000000..eb2951b --- /dev/null +++ b/.obsidian/plugins/calendar/main.js @@ -0,0 +1,4457 @@ +'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) {#if metadata} +function create_catch_block(ctx) { + return { + c: noop, + m: noop, + p: noop, + i: noop, + o: noop, + d: noop + }; +} + +// (8:37) ; export let metadata; {#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) +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) +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; diff --git a/.obsidian/plugins/calendar/manifest.json b/.obsidian/plugins/calendar/manifest.json new file mode 100644 index 0000000..028bfa5 --- /dev/null +++ b/.obsidian/plugins/calendar/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "calendar", + "name": "Calendar", + "description": "Calendar view of your daily notes", + "version": "1.5.10", + "author": "Liam Cain", + "authorUrl": "https://github.com/liamcain/", + "isDesktopOnly": false, + "minAppVersion": "0.9.11" +} diff --git a/.obsidian/plugins/meld-encrypt/data.json b/.obsidian/plugins/meld-encrypt/data.json new file mode 100644 index 0000000..3a06bb5 --- /dev/null +++ b/.obsidian/plugins/meld-encrypt/data.json @@ -0,0 +1,7 @@ +{ + "expandToWholeLines": true, + "confirmPassword": true, + "showButton": true, + "rememberPassword": true, + "rememberPasswordTimeout": 120 +} \ No newline at end of file diff --git a/.obsidian/plugins/meld-encrypt/main.js b/.obsidian/plugins/meld-encrypt/main.js new file mode 100644 index 0000000..6f57c62 --- /dev/null +++ b/.obsidian/plugins/meld-encrypt/main.js @@ -0,0 +1,764 @@ +'use strict'; + +var obsidian = require('obsidian'); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +class DecryptModal extends obsidian.Modal { + constructor(app, title, text = '', showButton) { + super(app); + this.decryptInPlace = false; + this.text = text; + this.titleEl.innerText = title; + this.showButton = showButton; + } + onOpen() { + let { contentEl } = this; + const textEl = contentEl.createDiv().createEl('textarea', { text: this.text }); + textEl.style.width = '100%'; + textEl.style.height = '100%'; + textEl.rows = 10; + textEl.readOnly = true; + //textEl.focus(); // Doesn't seem to work here... + setTimeout(() => { textEl.focus(); }, 100); //... but this does + const btnContainerEl = contentEl.createDiv(''); + if (this.showButton) { + const copyBtnEl = btnContainerEl.createEl('button', { text: 'Copy' }); + copyBtnEl.addEventListener('click', () => { + navigator.clipboard.writeText(textEl.value); + }); + } + const decryptInPlaceBtnEl = btnContainerEl.createEl('button', { text: 'Decrypt in-place' }); + decryptInPlaceBtnEl.addEventListener('click', () => { + this.decryptInPlace = true; + this.close(); + }); + const cancelBtnEl = btnContainerEl.createEl('button', { text: 'Close' }); + cancelBtnEl.addEventListener('click', () => { + this.close(); + }); + } +} + +class PasswordModal extends obsidian.Modal { + constructor(app, isEncrypting, confirmPassword, defaultPassword = null, hint) { + super(app); + this.password = null; + this.hint = null; + this.defaultPassword = null; + this.defaultPassword = defaultPassword; + this.confirmPassword = confirmPassword; + this.isEncrypting = isEncrypting; + this.hint = hint; + } + onOpen() { + var _a, _b, _c; + let { contentEl } = this; + contentEl.empty(); + contentEl.addClass('meld-e-password'); + if (obsidian.Platform.isMobile) { + contentEl.addClass('meld-e-platform-mobile'); + } + else if (obsidian.Platform.isDesktop) { + contentEl.addClass('meld-e-platform-desktop'); + } + /* Main password input row */ + const inputPwContainerEl = contentEl.createDiv({ cls: 'meld-e-row' }); + inputPwContainerEl.createSpan({ cls: 'meld-e-icon', text: '🔑' }); + const pwInputEl = inputPwContainerEl.createEl('input', { type: 'password', value: (_a = this.defaultPassword) !== null && _a !== void 0 ? _a : '' }); + pwInputEl.placeholder = 'Enter your password'; + pwInputEl.focus(); + if (obsidian.Platform.isMobile) { + // Add 'Next' button for mobile + const inputInputNextBtnEl = inputPwContainerEl.createEl('button', { + text: '→', + cls: 'meld-e-button-next' + }); + inputInputNextBtnEl.addEventListener('click', (ev) => { + inputPasswordHandler(); + }); + } + /* End Main password input row */ + /* Confirm password input row */ + const confirmPwShown = this.confirmPassword; + const confirmPwContainerEl = contentEl.createDiv({ cls: 'meld-e-row' }); + confirmPwContainerEl.createSpan({ cls: 'meld-e-icon', text: '🔑' }); + const pwConfirmInputEl = confirmPwContainerEl.createEl('input', { + type: 'password', + value: (_b = this.defaultPassword) !== null && _b !== void 0 ? _b : '' + }); + pwConfirmInputEl.placeholder = 'Confirm your password'; + const messageEl = contentEl.createDiv({ cls: 'meld-e-message' }); + messageEl.hide(); + if (obsidian.Platform.isMobile) { + // Add 'Next' button for mobile + const confirmInputNextBtnEl = confirmPwContainerEl.createEl('button', { + text: '→', + cls: 'meld-e-button-next' + }); + confirmInputNextBtnEl.addEventListener('click', (ev) => { + confirmPasswordHandler(); + }); + } + if (!confirmPwShown) { + confirmPwContainerEl.hide(); + } + /* End Confirm password input row */ + /* Hint input row */ + const hintInputShown = this.isEncrypting; + const inputHintContainerEl = contentEl.createDiv({ cls: 'meld-e-row' }); + inputHintContainerEl.createSpan({ cls: 'meld-e-icon', text: '💡' }); + const hintInputEl = inputHintContainerEl.createEl('input', { type: 'text', value: this.hint }); + hintInputEl.placeholder = 'Enter an optional password hint'; + if (obsidian.Platform.isMobile) { + // Add 'Next' button for mobile + const hintInputNextBtnEl = inputHintContainerEl.createEl('button', { + text: '→', + cls: 'meld-e-button-next' + }); + hintInputNextBtnEl.addEventListener('click', (ev) => { + hintPasswordHandler(); + }); + } + if (!hintInputShown) { + inputHintContainerEl.hide(); + } + /* End Hint input row */ + /* Hint text row */ + const spanHintContainerEl = contentEl.createDiv({ cls: 'meld-e-row' }); + spanHintContainerEl.createSpan({ cls: 'meld-e-icon', text: '💡' }); + spanHintContainerEl.createSpan({ cls: 'meld-e-hint', text: `Hint: '${this.hint}'` }); + if (hintInputShown || ((_c = this.hint) !== null && _c !== void 0 ? _c : '').length == 0) { + spanHintContainerEl.hide(); + } + /* END Hint text row */ + const confirmPwButtonEl = contentEl.createEl('button', { + text: 'Confirm', + cls: 'meld-e-button-confirm' + }); + confirmPwButtonEl.addEventListener('click', (ev) => { + if (validate()) { + this.close(); + } + else { + pwInputEl.focus(); + } + }); + const validate = () => { + if (confirmPwShown) { + if (pwInputEl.value != pwConfirmInputEl.value) { + // passwords don't match + messageEl.setText('Passwords don\'t match'); + messageEl.show(); + return false; + } + } + this.password = pwInputEl.value; + this.hint = hintInputEl.value; + return true; + }; + const inputPasswordHandler = () => { + if (confirmPwShown) { + pwConfirmInputEl.focus(); + return; + } + if (hintInputShown) { + hintInputEl.focus(); + return; + } + if (validate()) { + this.close(); + } + }; + const confirmPasswordHandler = () => { + if (validate()) { + if (hintInputShown) { + hintInputEl.focus(); + } + else { + this.close(); + } + } + }; + const hintPasswordHandler = () => { + if (validate()) { + this.close(); + } + else { + pwInputEl.focus(); + } + }; + hintInputEl.addEventListener('keypress', (ev) => { + if ((ev.code === 'Enter' || ev.code === 'NumpadEnter') + && pwInputEl.value.length > 0) { + ev.preventDefault(); + hintPasswordHandler(); + } + }); + pwConfirmInputEl.addEventListener('keypress', (ev) => { + if ((ev.code === 'Enter' || ev.code === 'NumpadEnter') + && pwConfirmInputEl.value.length > 0) { + ev.preventDefault(); + confirmPasswordHandler(); + } + }); + pwInputEl.addEventListener('keypress', (ev) => { + if ((ev.code === 'Enter' || ev.code === 'NumpadEnter') + && pwInputEl.value.length > 0) { + ev.preventDefault(); + inputPasswordHandler(); + } + }); + } +} + +const vectorSize = 16; +const utf8Encoder = new TextEncoder(); +const utf8Decoder = new TextDecoder(); +const iterations = 1000; +const salt = utf8Encoder.encode('XHWnDAT6ehMVY2zD'); +class CryptoHelperV2 { + deriveKey(password) { + return __awaiter(this, void 0, void 0, function* () { + const buffer = utf8Encoder.encode(password); + const key = yield crypto.subtle.importKey('raw', buffer, { name: 'PBKDF2' }, false, ['deriveKey']); + const privateKey = crypto.subtle.deriveKey({ + name: 'PBKDF2', + hash: { name: 'SHA-256' }, + iterations, + salt + }, key, { + name: 'AES-GCM', + length: 256 + }, false, ['encrypt', 'decrypt']); + return privateKey; + }); + } + encryptToBase64(text, password) { + return __awaiter(this, void 0, void 0, function* () { + const key = yield this.deriveKey(password); + const textBytesToEncrypt = utf8Encoder.encode(text); + const vector = crypto.getRandomValues(new Uint8Array(vectorSize)); + // encrypt into bytes + const encryptedBytes = new Uint8Array(yield crypto.subtle.encrypt({ name: 'AES-GCM', iv: vector }, key, textBytesToEncrypt)); + const finalBytes = new Uint8Array(vector.byteLength + encryptedBytes.byteLength); + finalBytes.set(vector, 0); + finalBytes.set(encryptedBytes, vector.byteLength); + //convert array to base64 + const base64Text = btoa(String.fromCharCode(...finalBytes)); + return base64Text; + }); + } + stringToArray(str) { + var result = []; + for (var i = 0; i < str.length; i++) { + result.push(str.charCodeAt(i)); + } + return new Uint8Array(result); + } + decryptFromBase64(base64Encoded, password) { + return __awaiter(this, void 0, void 0, function* () { + try { + let bytesToDecode = this.stringToArray(atob(base64Encoded)); + // extract iv + const vector = bytesToDecode.slice(0, vectorSize); + // extract encrypted text + const encryptedTextBytes = bytesToDecode.slice(vectorSize); + const key = yield this.deriveKey(password); + // decrypt into bytes + let decryptedBytes = yield crypto.subtle.decrypt({ name: 'AES-GCM', iv: vector }, key, encryptedTextBytes); + // convert bytes to text + let decryptedText = utf8Decoder.decode(decryptedBytes); + return decryptedText; + } + catch (e) { + //console.error(e); + return null; + } + }); + } +} +const algorithmObsolete = { + name: 'AES-GCM', + iv: new Uint8Array([196, 190, 240, 190, 188, 78, 41, 132, 15, 220, 84, 211]), + tagLength: 128 +}; +class CryptoHelperObsolete { + buildKey(password) { + return __awaiter(this, void 0, void 0, function* () { + let utf8Encode = new TextEncoder(); + let passwordBytes = utf8Encode.encode(password); + let passwordDigest = yield crypto.subtle.digest({ name: 'SHA-256' }, passwordBytes); + let key = yield crypto.subtle.importKey('raw', passwordDigest, algorithmObsolete, false, ['encrypt', 'decrypt']); + return key; + }); + } + encryptToBase64(text, password) { + return __awaiter(this, void 0, void 0, function* () { + let key = yield this.buildKey(password); + let utf8Encode = new TextEncoder(); + let bytesToEncrypt = utf8Encode.encode(text); + // encrypt into bytes + let encryptedBytes = new Uint8Array(yield crypto.subtle.encrypt(algorithmObsolete, key, bytesToEncrypt)); + //convert array to base64 + let base64Text = btoa(String.fromCharCode(...encryptedBytes)); + return base64Text; + }); + } + stringToArray(str) { + var result = []; + for (var i = 0; i < str.length; i++) { + result.push(str.charCodeAt(i)); + } + return new Uint8Array(result); + } + decryptFromBase64(base64Encoded, password) { + return __awaiter(this, void 0, void 0, function* () { + try { + // convert base 64 to array + let bytesToDecrypt = this.stringToArray(atob(base64Encoded)); + let key = yield this.buildKey(password); + // decrypt into bytes + let decryptedBytes = yield crypto.subtle.decrypt(algorithmObsolete, key, bytesToDecrypt); + // convert bytes to text + let utf8Decode = new TextDecoder(); + let decryptedText = utf8Decode.decode(decryptedBytes); + return decryptedText; + } + catch (e) { + return null; + } + }); + } +} + +class MeldEncryptSettingsTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Settings for Meld Encrypt' }); + new obsidian.Setting(containerEl) + .setName('Expand selection to whole line?') + .setDesc('Partial selections will get expanded to the whole line.') + .addToggle(toggle => { + toggle + .setValue(this.plugin.settings.expandToWholeLines) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.expandToWholeLines = value; + yield this.plugin.saveSettings(); + //this.updateSettingsUi(); + })); + }); + new obsidian.Setting(containerEl) + .setName('Confirm password?') + .setDesc('Confirm password when encrypting.') + .addToggle(toggle => { + toggle + .setValue(this.plugin.settings.confirmPassword) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.confirmPassword = value; + yield this.plugin.saveSettings(); + this.updateSettingsUi(); + })); + }); + new obsidian.Setting(containerEl) + .setName('Copy button?') + .setDesc('Show a button to copy decrypted text.') + .addToggle(toggle => { + toggle + .setValue(this.plugin.settings.showButton) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.showButton = value; + yield this.plugin.saveSettings(); + this.updateSettingsUi(); + })); + }); + new obsidian.Setting(containerEl) + .setName('Remember password?') + .setDesc('Remember the last used password for this session.') + .addToggle(toggle => { + toggle + .setValue(this.plugin.settings.rememberPassword) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.rememberPassword = value; + yield this.plugin.saveSettings(); + this.updateSettingsUi(); + })); + }); + this.pwTimeoutSetting = new obsidian.Setting(containerEl) + .setName(this.buildPasswordTimeoutSettingName()) + .setDesc('The number of minutes to remember the last used password.') + .addSlider(slider => { + slider + .setLimits(0, 120, 5) + .setValue(this.plugin.settings.rememberPasswordTimeout) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.rememberPasswordTimeout = value; + yield this.plugin.saveSettings(); + this.updateSettingsUi(); + })); + }); + this.updateSettingsUi(); + } + updateSettingsUi() { + this.pwTimeoutSetting.setName(this.buildPasswordTimeoutSettingName()); + if (this.plugin.settings.rememberPassword) { + this.pwTimeoutSetting.settingEl.show(); + } + else { + this.pwTimeoutSetting.settingEl.hide(); + } + } + buildPasswordTimeoutSettingName() { + const value = this.plugin.settings.rememberPasswordTimeout; + let timeoutString = `${value} minutes`; + if (value == 0) { + timeoutString = 'Never forget'; + } + return `Remember Password Timeout (${timeoutString})`; + } +} + +const _PREFIX = '%%🔐'; +const _PREFIX_OBSOLETE = _PREFIX + ' '; +const _PREFIX_A = _PREFIX + 'α '; +const _SUFFIX = ' 🔐%%'; +const _HINT = '💡'; +const DEFAULT_SETTINGS = { + expandToWholeLines: true, + confirmPassword: true, + showButton: false, + rememberPassword: true, + rememberPasswordTimeout: 30 +}; +class MeldEncrypt extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + yield this.loadSettings(); + this.addSettingTab(new MeldEncryptSettingsTab(this.app, this)); + this.addCommand({ + id: 'meld-encrypt', + name: 'Encrypt/Decrypt', + editorCheckCallback: (checking, editor, view) => this.processEncryptDecryptCommand(checking, editor, view, false) + }); + this.addCommand({ + id: 'meld-encrypt-in-place', + name: 'Encrypt/Decrypt In-place', + editorCheckCallback: (checking, editor, view) => this.processEncryptDecryptCommand(checking, editor, view, true) + }); + this.addCommand({ + id: 'meld-encrypt-note', + name: 'Encrypt/Decrypt Whole Note', + editorCheckCallback: (checking, editor, view) => this.processEncryptDecryptWholeNoteCommand(checking, editor, view) + }); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } + isSettingsModalOpen() { + return document.querySelector('.mod-settings') !== null; + } + processEncryptDecryptWholeNoteCommand(checking, editor, view) { + if (checking && this.isSettingsModalOpen()) { + // Settings is open, ensures this command can show up in other + // plugins which list commands e.g. customizable-sidebar + return true; + } + const startPos = editor.offsetToPos(0); + const endPos = { line: editor.lastLine(), ch: editor.getLine(editor.lastLine()).length }; + const selectionText = editor.getRange(startPos, endPos).trim(); + return this.processSelection(checking, editor, selectionText, startPos, endPos, true); + } + processEncryptDecryptCommand(checking, editor, view, decryptInPlace) { + if (checking && this.isSettingsModalOpen()) { + // Settings is open, ensures this command can show up in other + // plugins which list commands e.g. customizable-sidebar + return true; + } + let startPos = editor.getCursor('from'); + let endPos = editor.getCursor('to'); + if (this.settings.expandToWholeLines) { + const startLine = startPos.line; + startPos = { line: startLine, ch: 0 }; // want the start of the first line + const endLine = endPos.line; + const endLineText = editor.getLine(endLine); + endPos = { line: endLine, ch: endLineText.length }; // want the end of last line + } + else { + if (!editor.somethingSelected()) { + // nothing selected, assume user wants to decrypt, expand to start and end markers + startPos = this.getClosestPrevTextCursorPos(editor, _PREFIX, startPos); + endPos = this.getClosestNextTextCursorPos(editor, _SUFFIX, endPos); + } + } + const selectionText = editor.getRange(startPos, endPos); + return this.processSelection(checking, editor, selectionText, startPos, endPos, decryptInPlace); + } + getClosestPrevTextCursorPos(editor, text, defaultValue) { + const initOffset = editor.posToOffset(editor.getCursor("from")); + for (let offset = initOffset; offset >= 0; offset--) { + const offsetPos = editor.offsetToPos(offset); + const textEndOffset = offset + text.length; + const prefixEndPos = editor.offsetToPos(textEndOffset); + const testText = editor.getRange(offsetPos, prefixEndPos); + if (testText == text) { + return offsetPos; + } + } + return defaultValue; + } + getClosestNextTextCursorPos(editor, text, defaultValue) { + const initOffset = editor.posToOffset(editor.getCursor("from")); + const lastLineNum = editor.lastLine(); + let maxOffset = editor.posToOffset({ line: lastLineNum, ch: editor.getLine(lastLineNum).length }); + for (let offset = initOffset; offset <= maxOffset - text.length; offset++) { + const offsetPos = editor.offsetToPos(offset); + const textEndOffset = offset + text.length; + const prefixEndPos = editor.offsetToPos(textEndOffset); + const testText = editor.getRange(offsetPos, prefixEndPos); + if (testText == text) { + return prefixEndPos; + } + } + return defaultValue; + } + analyseSelection(selectionText) { + const result = new SelectionAnalysis(); + result.isEmpty = selectionText.length === 0; + result.hasObsoleteEncryptedPrefix = selectionText.startsWith(_PREFIX_OBSOLETE); + result.hasEncryptedPrefix = result.hasObsoleteEncryptedPrefix || selectionText.startsWith(_PREFIX_A); + result.hasDecryptSuffix = selectionText.endsWith(_SUFFIX); + result.containsEncryptedMarkers = + selectionText.contains(_PREFIX_OBSOLETE) + || selectionText.contains(_PREFIX_A) + || selectionText.contains(_SUFFIX); + result.canDecrypt = result.hasEncryptedPrefix && result.hasDecryptSuffix; + result.canEncrypt = !result.hasEncryptedPrefix && !result.containsEncryptedMarkers; + if (result.canDecrypt) { + result.decryptable = this.parseDecryptableContent(selectionText); + if (result.decryptable == null) { + result.canDecrypt = false; + } + } + return result; + } + processSelection(checking, editor, selectionText, finalSelectionStart, finalSelectionEnd, decryptInPlace) { + var _a; + const selectionAnalysis = this.analyseSelection(selectionText); + if (selectionAnalysis.isEmpty) { + if (!checking) { + new obsidian.Notice('Nothing to Encrypt.'); + } + return false; + } + if (!selectionAnalysis.canDecrypt && !selectionAnalysis.canEncrypt) { + if (!checking) { + new obsidian.Notice('Unable to Encrypt or Decrypt that.'); + } + return false; + } + if (checking) { + return true; + } + // Fetch password from user + // determine default password + const isRememberPasswordExpired = !this.settings.rememberPassword + || (this.passwordLastUsedExpiry != null + && Date.now() > this.passwordLastUsedExpiry); + const confirmPassword = selectionAnalysis.canEncrypt && this.settings.confirmPassword; + if (isRememberPasswordExpired || confirmPassword) { + // forget password + this.passwordLastUsed = ''; + } + const pwModal = new PasswordModal(this.app, selectionAnalysis.canEncrypt, confirmPassword, this.passwordLastUsed, (_a = selectionAnalysis.decryptable) === null || _a === void 0 ? void 0 : _a.hint); + pwModal.onClose = () => { + var _a; + const pw = (_a = pwModal.password) !== null && _a !== void 0 ? _a : ''; + if (pw.length == 0) { + return; + } + const hint = pwModal.hint; + // remember password? + if (this.settings.rememberPassword) { + this.passwordLastUsed = pw; + this.passwordLastUsedExpiry = + this.settings.rememberPasswordTimeout == 0 + ? null + : Date.now() + this.settings.rememberPasswordTimeout * 1000 * 60 // new expiry + ; + } + if (selectionAnalysis.canEncrypt) { + const encryptable = new Encryptable(); + encryptable.text = selectionText; + encryptable.hint = hint; + this.encryptSelection(editor, encryptable, pw, finalSelectionStart, finalSelectionEnd); + } + else { + if (selectionAnalysis.decryptable.version == 1) { + this.decryptSelection_a(editor, selectionAnalysis.decryptable, pw, finalSelectionStart, finalSelectionEnd, decryptInPlace); + } + else { + this.decryptSelectionObsolete(editor, selectionAnalysis.decryptable, pw, finalSelectionStart, finalSelectionEnd, decryptInPlace); + } + } + }; + pwModal.open(); + return true; + } + encryptSelection(editor, encryptable, password, finalSelectionStart, finalSelectionEnd) { + return __awaiter(this, void 0, void 0, function* () { + //encrypt + const crypto = new CryptoHelperV2(); + const encodedText = this.encodeEncryption(yield crypto.encryptToBase64(encryptable.text, password), encryptable.hint); + editor.setSelection(finalSelectionStart, finalSelectionEnd); + editor.replaceSelection(encodedText); + }); + } + decryptSelection_a(editor, decryptable, password, selectionStart, selectionEnd, decryptInPlace) { + return __awaiter(this, void 0, void 0, function* () { + // decrypt + const crypto = new CryptoHelperV2(); + const decryptedText = yield crypto.decryptFromBase64(decryptable.base64CipherText, password); + if (decryptedText === null) { + new obsidian.Notice('❌ Decryption failed!'); + } + else { + if (decryptInPlace) { + editor.setSelection(selectionStart, selectionEnd); + editor.replaceSelection(decryptedText); + } + else { + const decryptModal = new DecryptModal(this.app, '🔓', decryptedText, this.settings.showButton); + decryptModal.onClose = () => { + editor.focus(); + if (decryptModal.decryptInPlace) { + editor.setSelection(selectionStart, selectionEnd); + editor.replaceSelection(decryptedText); + } + }; + decryptModal.open(); + } + } + }); + } + decryptSelectionObsolete(editor, decryptable, password, selectionStart, selectionEnd, decryptInPlace) { + return __awaiter(this, void 0, void 0, function* () { + // decrypt + const base64CipherText = this.removeMarkers(decryptable.base64CipherText); + const crypto = new CryptoHelperObsolete(); + const decryptedText = yield crypto.decryptFromBase64(base64CipherText, password); + if (decryptedText === null) { + new obsidian.Notice('❌ Decryption failed!'); + } + else { + if (decryptInPlace) { + editor.setSelection(selectionStart, selectionEnd); + editor.replaceSelection(decryptedText); + } + else { + const decryptModal = new DecryptModal(this.app, '🔓', decryptedText, this.settings.showButton); + decryptModal.onClose = () => { + editor.focus(); + if (decryptModal.decryptInPlace) { + editor.setSelection(selectionStart, selectionEnd); + editor.replaceSelection(decryptedText); + } + }; + decryptModal.open(); + } + } + }); + } + parseDecryptableContent(text) { + const result = new Decryptable(); + let content = text; + if (content.startsWith(_PREFIX_A) && content.endsWith(_SUFFIX)) { + result.version = 1; + content = content.replace(_PREFIX_A, '').replace(_SUFFIX, ''); + } + else if (content.startsWith(_PREFIX_OBSOLETE) && content.endsWith(_SUFFIX)) { + result.version = 0; + content = content.replace(_PREFIX_OBSOLETE, '').replace(_SUFFIX, ''); + } + else { + return null; // invalid format + } + // check if there is a hint + //console.table(content); + if (content.substr(0, _HINT.length) == _HINT) { + const endHintMarker = content.indexOf(_HINT, _HINT.length); + if (endHintMarker < 0) { + return null; // invalid format + } + result.hint = content.substring(_HINT.length, endHintMarker); + result.base64CipherText = content.substring(endHintMarker + _HINT.length); + } + else { + result.base64CipherText = content; + } + //console.table(result); + return result; + } + removeMarkers(text) { + if (text.startsWith(_PREFIX_A) && text.endsWith(_SUFFIX)) { + return text.replace(_PREFIX_A, '').replace(_SUFFIX, ''); + } + if (text.startsWith(_PREFIX_OBSOLETE) && text.endsWith(_SUFFIX)) { + return text.replace(_PREFIX_OBSOLETE, '').replace(_SUFFIX, ''); + } + return text; + } + encodeEncryption(encryptedText, hint) { + if (!encryptedText.contains(_PREFIX_OBSOLETE) && !encryptedText.contains(_PREFIX_A) && !encryptedText.contains(_SUFFIX)) { + if (hint) { + return _PREFIX_A.concat(_HINT, hint, _HINT, encryptedText, _SUFFIX); + } + return _PREFIX_A.concat(encryptedText, _SUFFIX); + } + return encryptedText; + } +} +class SelectionAnalysis { +} +class Encryptable { +} +class Decryptable { +} + +module.exports = MeldEncrypt; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../node_modules/tslib/tslib.es6.js","../src/DecryptModal.ts","../src/PasswordModal.ts","../src/CryptoHelper.ts","../src/MeldEncryptSettingsTab.ts","../src/main.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","import { App, Modal } from 'obsidian';\r\n\r\nexport default class DecryptModal extends Modal {\r\n\ttext: string;\r\n\tdecryptInPlace: boolean = false;\r\n\tshowButton: boolean\r\n\r\n\tconstructor(app: App, title: string, text: string = '', showButton:boolean) {\r\n\t\tsuper(app);\r\n\t\tthis.text = text;\r\n\t\tthis.titleEl.innerText = title;\r\n\t\tthis.showButton = showButton;\r\n\t}\r\n\r\n\tonOpen() {\r\n\t\tlet { contentEl } = this;\r\n\r\n\t\tconst textEl = contentEl.createDiv().createEl('textarea', { text: this.text });\r\n\t\ttextEl.style.width = '100%';\r\n\t\ttextEl.style.height = '100%';\r\n\t\ttextEl.rows = 10;\r\n\t\ttextEl.readOnly = true;\r\n\t\t//textEl.focus(); // Doesn't seem to work here...\r\n\t\tsetTimeout(() => { textEl.focus() },100); //... but this does\r\n\r\n\r\n\t\tconst btnContainerEl = contentEl.createDiv('');\r\n\r\n\t\tif (this.showButton){\r\n\t\tconst copyBtnEl = btnContainerEl.createEl('button', { text: 'Copy' });\r\n\t\tcopyBtnEl.addEventListener('click', () => {\r\n\t\t\tnavigator.clipboard.writeText(textEl.value);\r\n\t\t}); }\r\n\r\n\t\tconst decryptInPlaceBtnEl = btnContainerEl.createEl('button', { text: 'Decrypt in-place' });\r\n\t\tdecryptInPlaceBtnEl.addEventListener('click', () => {\r\n\t\t\tthis.decryptInPlace = true;\r\n\t\t\tthis.close();\r\n\t\t});\r\n\r\n\t\tconst cancelBtnEl = btnContainerEl.createEl('button', { text: 'Close' });\r\n\t\tcancelBtnEl.addEventListener('click', () => {\r\n\t\t\tthis.close();\r\n\t\t});\r\n\r\n\t}\r\n\r\n}","import { App, Modal, Platform } from 'obsidian';\r\n\r\nexport default class PasswordModal extends Modal {\r\n\tpassword: string = null;\r\n\thint: string = null;\r\n\tdefaultPassword: string = null;\r\n\tconfirmPassword: boolean;\r\n\tisEncrypting: boolean;\r\n\r\n\tconstructor(app: App, isEncrypting:boolean, confirmPassword: boolean, defaultPassword: string = null, hint:string ) {\r\n\t\tsuper(app);\r\n\t\tthis.defaultPassword = defaultPassword;\r\n\t\tthis.confirmPassword = confirmPassword;\r\n\t\tthis.isEncrypting = isEncrypting;\r\n\t\tthis.hint = hint;\r\n\t}\r\n\r\n\tonOpen() {\r\n\t\tlet { contentEl } = this;\r\n\r\n\t\tcontentEl.empty();\r\n\r\n\t\tcontentEl.addClass( 'meld-e-password' );\r\n\t\tif (Platform.isMobile){\r\n\t\t\tcontentEl.addClass( 'meld-e-platform-mobile' );\r\n\t\t}else if (Platform.isDesktop){\r\n\t\t\tcontentEl.addClass( 'meld-e-platform-desktop' );\r\n\t\t}\r\n\r\n\t\t/* Main password input row */\r\n\t\tconst inputPwContainerEl = contentEl.createDiv( { cls:'meld-e-row' } );\r\n\t\tinputPwContainerEl.createSpan({ cls:'meld-e-icon', text: '🔑' });\r\n\t\t\r\n\t\tconst pwInputEl = inputPwContainerEl.createEl('input', { type: 'password', value: this.defaultPassword ?? '' });\r\n\r\n\t\tpwInputEl.placeholder = 'Enter your password';\r\n\t\tpwInputEl.focus();\r\n\r\n\t\tif (Platform.isMobile){\r\n\t\t\t// Add 'Next' button for mobile\r\n\t\t\tconst inputInputNextBtnEl = inputPwContainerEl.createEl('button', {\r\n\t\t\t\ttext: '→',\r\n\t\t\t\tcls:'meld-e-button-next'\r\n\t\t\t});\r\n\t\t\tinputInputNextBtnEl.addEventListener('click', (ev) => {\r\n\t\t\t\tinputPasswordHandler();\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\t/* End Main password input row */\r\n\r\n\t\t/* Confirm password input row */\r\n\t\tconst confirmPwShown = this.confirmPassword;\r\n\t\tconst confirmPwContainerEl = contentEl.createDiv( { cls:'meld-e-row' } );\r\n\t\tconfirmPwContainerEl.createSpan( { cls:'meld-e-icon', text: '🔑' } );\r\n\t\t\r\n\t\tconst pwConfirmInputEl = confirmPwContainerEl.createEl( 'input', {\r\n\t\t\ttype: 'password',\r\n\t\t\tvalue: this.defaultPassword ?? ''\r\n\t\t});\r\n\t\tpwConfirmInputEl.placeholder = 'Confirm your password';\r\n\r\n\t\tconst messageEl = contentEl.createDiv({ cls:'meld-e-message' });\r\n\t\tmessageEl.hide();\r\n\t\t\r\n\t\t\r\n\t\tif (Platform.isMobile){\r\n\t\t\t// Add 'Next' button for mobile\r\n\t\t\tconst confirmInputNextBtnEl = confirmPwContainerEl.createEl('button', {\r\n\t\t\t\ttext: '→',\r\n\t\t\t\tcls:'meld-e-button-next'\r\n\t\t\t});\r\n\t\t\tconfirmInputNextBtnEl.addEventListener('click', (ev) => {\r\n\t\t\t\tconfirmPasswordHandler();\r\n\t\t\t});\r\n\t\t}\r\n\t\t\r\n\t\tif (!confirmPwShown) {\r\n\t\t\tconfirmPwContainerEl.hide();\r\n\t\t}\r\n\t\t/* End Confirm password input row */\r\n\r\n\t\t/* Hint input row */\r\n\t\tconst hintInputShown = this.isEncrypting;\r\n\t\tconst inputHintContainerEl = contentEl.createDiv( { cls:'meld-e-row' } );\r\n\t\tinputHintContainerEl.createSpan({ cls:'meld-e-icon', text: '💡' });\r\n\t\tconst hintInputEl = inputHintContainerEl.createEl('input', { type: 'text', value: this.hint });\r\n\t\thintInputEl.placeholder = 'Enter an optional password hint';\r\n\t\tif (Platform.isMobile){\r\n\t\t\t// Add 'Next' button for mobile\r\n\t\t\tconst hintInputNextBtnEl = inputHintContainerEl.createEl('button', {\r\n\t\t\t\ttext: '→',\r\n\t\t\t\tcls:'meld-e-button-next'\r\n\t\t\t});\r\n\t\t\thintInputNextBtnEl.addEventListener('click', (ev) => {\r\n\t\t\t\thintPasswordHandler();\r\n\t\t\t});\r\n\t\t}\r\n\t\tif (!hintInputShown){\r\n\t\t\tinputHintContainerEl.hide();\r\n\t\t}\r\n\t\t/* End Hint input row */\r\n\r\n\t\t/* Hint text row */\r\n\t\tconst spanHintContainerEl = contentEl.createDiv( { cls:'meld-e-row' } );\r\n\t\tspanHintContainerEl.createSpan({ cls:'meld-e-icon', text: '💡' });\r\n\t\tspanHintContainerEl.createSpan( {cls: 'meld-e-hint', text:`Hint: '${this.hint}'`});\r\n\r\n\t\tif (hintInputShown || (this.hint ?? '').length==0){\r\n\t\t\tspanHintContainerEl.hide();\r\n\t\t}\r\n\r\n\t\t/* END Hint text row */\r\n\r\n\t\tconst confirmPwButtonEl = contentEl.createEl( 'button', {\r\n\t\t\ttext:'Confirm',\r\n\t\t\tcls:'meld-e-button-confirm'\r\n\t\t});\r\n\t\tconfirmPwButtonEl.addEventListener( 'click', (ev) =>{\r\n\t\t\tif (validate()){\r\n\t\t\t\tthis.close();\r\n\t\t\t}else{\r\n\t\t\t\tpwInputEl.focus();\r\n\t\t\t}\r\n\t\t})\r\n\r\n\t\tconst validate = () : boolean => {\r\n\t\t\tif (confirmPwShown){\r\n\t\t\t\tif (pwInputEl.value != pwConfirmInputEl.value){\r\n\t\t\t\t\t// passwords don't match\r\n\t\t\t\t\tmessageEl.setText('Passwords don\\'t match');\r\n\t\t\t\t\tmessageEl.show();\r\n\t\t\t\t\treturn false;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tthis.password = pwInputEl.value;\r\n\t\t\t\r\n\t\t\tthis.hint = hintInputEl.value;\r\n\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\tconst inputPasswordHandler = () =>{\r\n\t\t\tif (confirmPwShown){\r\n\t\t\t\tpwConfirmInputEl.focus();\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif (hintInputShown){\r\n\t\t\t\thintInputEl.focus();\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif ( validate() ){\r\n\t\t\t\tthis.close();\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst confirmPasswordHandler = () => {\r\n\t\t\tif ( validate() ){\r\n\t\t\t\tif (hintInputShown){\r\n\t\t\t\t\thintInputEl.focus();\r\n\t\t\t\t}else{\r\n\t\t\t\t\tthis.close();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst hintPasswordHandler = () => {\r\n\t\t\tif (validate()){\r\n\t\t\t\tthis.close();\r\n\t\t\t}else{\r\n\t\t\t\tpwInputEl.focus();\r\n\t\t\t}\r\n\t\t}\r\n\t\t\r\n\t\thintInputEl.addEventListener('keypress', (ev) => {\r\n\t\t\tif (\r\n\t\t\t\t( ev.code === 'Enter' || ev.code === 'NumpadEnter' )\r\n\t\t\t\t&& pwInputEl.value.length > 0\r\n\t\t\t) {\r\n\t\t\t\tev.preventDefault();\r\n\t\t\t\thintPasswordHandler();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tpwConfirmInputEl.addEventListener('keypress', (ev) => {\r\n\t\t\tif (\r\n\t\t\t\t( ev.code === 'Enter' || ev.code === 'NumpadEnter' )\r\n\t\t\t\t&& pwConfirmInputEl.value.length > 0\r\n\t\t\t) {\r\n\t\t\t\tev.preventDefault();\r\n\t\t\t\tconfirmPasswordHandler();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\r\n\t\tpwInputEl.addEventListener('keypress', (ev) => {\r\n\t\t\tif (\r\n\t\t\t\t( ev.code === 'Enter' || ev.code === 'NumpadEnter' )\r\n\t\t\t\t&& pwInputEl.value.length > 0\r\n\t\t\t) {\r\n\t\t\t\tev.preventDefault();\r\n\t\t\t\tinputPasswordHandler();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t}\r\n\r\n}","const vectorSize\t= 16;\r\nconst utf8Encoder\t= new TextEncoder();\r\nconst utf8Decoder\t= new TextDecoder();\r\nconst iterations\t= 1000;\r\nconst salt\t\t\t= utf8Encoder.encode('XHWnDAT6ehMVY2zD');\r\n\r\nexport class CryptoHelperV2 {\r\n\r\n\tprivate async deriveKey(password:string) :Promise<CryptoKey> {\r\n\t\tconst buffer     = utf8Encoder.encode(password);\r\n\t\tconst key        = await crypto.subtle.importKey('raw', buffer, {name: 'PBKDF2'}, false, ['deriveKey']);\r\n\t\tconst privateKey = crypto.subtle.deriveKey(\r\n\t\t\t{\r\n\t\t\t\tname: 'PBKDF2',\r\n\t\t\t\thash: {name: 'SHA-256'},\r\n\t\t\t\titerations,\r\n\t\t\t\tsalt\r\n\t\t\t},\r\n\t\t\tkey,\r\n\t\t\t{\r\n\t\t\t\tname: 'AES-GCM',\r\n\t\t\t\tlength: 256\r\n\t\t\t},\r\n\t\t\tfalse,\r\n\t\t\t['encrypt', 'decrypt']\r\n\t\t);\r\n\t\t\r\n\t\treturn privateKey;\r\n\t}\r\n\r\n\tpublic async encryptToBase64(text: string, password: string): Promise<string> {\r\n\r\n\t\tconst key = await this.deriveKey(password);\r\n\t\t\r\n\t\tconst textBytesToEncrypt = utf8Encoder.encode(text);\r\n\t\tconst vector = crypto.getRandomValues(new Uint8Array(vectorSize));\r\n\t\t\r\n\t\t// encrypt into bytes\r\n\t\tconst encryptedBytes = new Uint8Array(\r\n\t\t\tawait crypto.subtle.encrypt(\r\n\t\t\t\t{name: 'AES-GCM', iv: vector},\r\n\t\t\t\tkey,\r\n\t\t\t\ttextBytesToEncrypt\r\n\t\t\t)\r\n\t\t);\r\n\t\t\r\n\t\tconst finalBytes = new Uint8Array( vector.byteLength + encryptedBytes.byteLength );\r\n\t\tfinalBytes.set( vector, 0 );\r\n\t\tfinalBytes.set( encryptedBytes, vector.byteLength );\r\n\r\n\t\t//convert array to base64\r\n\t\tconst base64Text = btoa( String.fromCharCode(...finalBytes) );\r\n\r\n\t\treturn base64Text;\r\n\t}\r\n\r\n\tprivate stringToArray(str: string): Uint8Array {\r\n\t\tvar result = [];\r\n\t\tfor (var i = 0; i < str.length; i++) {\r\n\t\t\tresult.push(str.charCodeAt(i));\r\n\t\t}\r\n\t\treturn new Uint8Array(result);\r\n\t}\r\n\r\n\tpublic async decryptFromBase64(base64Encoded: string, password: string): Promise<string> {\r\n\t\ttry {\r\n\r\n\t\t\tlet bytesToDecode = this.stringToArray(atob(base64Encoded));\r\n\t\t\t\r\n\t\t\t// extract iv\r\n\t\t\tconst vector = bytesToDecode.slice(0,vectorSize);\r\n\r\n\t\t\t// extract encrypted text\r\n\t\t\tconst encryptedTextBytes = bytesToDecode.slice(vectorSize);\r\n\r\n\t\t\tconst key = await this.deriveKey(password);\r\n\r\n\t\t\t// decrypt into bytes\r\n\t\t\tlet decryptedBytes = await crypto.subtle.decrypt(\r\n\t\t\t\t{name: 'AES-GCM', iv: vector},\r\n\t\t\t\tkey,\r\n\t\t\t\tencryptedTextBytes\r\n\t\t\t);\r\n\r\n\t\t\t// convert bytes to text\r\n\t\t\tlet decryptedText = utf8Decoder.decode(decryptedBytes);\r\n\t\t\treturn decryptedText;\r\n\t\t} catch (e) {\r\n\t\t\t//console.error(e);\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n}\r\n\r\nconst algorithmObsolete = {\r\n\tname: 'AES-GCM',\r\n\tiv: new Uint8Array([196, 190, 240, 190, 188, 78, 41, 132, 15, 220, 84, 211]),\r\n\ttagLength: 128\r\n}\r\n\r\nexport class CryptoHelperObsolete {\r\n\r\n\tprivate async buildKey(password: string) {\r\n\t\tlet utf8Encode = new TextEncoder();\r\n\t\tlet passwordBytes = utf8Encode.encode(password);\r\n\r\n\t\tlet passwordDigest = await crypto.subtle.digest({ name: 'SHA-256' }, passwordBytes);\r\n\r\n\t\tlet key = await crypto.subtle.importKey(\r\n\t\t\t'raw',\r\n\t\t\tpasswordDigest,\r\n\t\t\talgorithmObsolete,\r\n\t\t\tfalse,\r\n\t\t\t['encrypt', 'decrypt']\r\n\t\t);\r\n\r\n\t\treturn key;\r\n\t}\r\n\r\n\tpublic async encryptToBase64(text: string, password: string): Promise<string> {\r\n\t\tlet key = await this.buildKey(password);\r\n\r\n\t\tlet utf8Encode = new TextEncoder();\r\n\t\tlet bytesToEncrypt = utf8Encode.encode(text);\r\n\r\n\t\t// encrypt into bytes\r\n\t\tlet encryptedBytes = new Uint8Array(await crypto.subtle.encrypt(\r\n\t\t\talgorithmObsolete, key, bytesToEncrypt\r\n\t\t));\r\n\r\n\t\t//convert array to base64\r\n\t\tlet base64Text = btoa(String.fromCharCode(...encryptedBytes));\r\n\r\n\t\treturn base64Text;\r\n\t}\r\n\r\n\tprivate stringToArray(str: string): Uint8Array {\r\n\t\tvar result = [];\r\n\t\tfor (var i = 0; i < str.length; i++) {\r\n\t\t\tresult.push(str.charCodeAt(i));\r\n\t\t}\r\n\t\treturn new Uint8Array(result);\r\n\t}\r\n\r\n\tpublic async decryptFromBase64(base64Encoded: string, password: string): Promise<string> {\r\n\t\ttry {\r\n\t\t\t// convert base 64 to array\r\n\t\t\tlet bytesToDecrypt = this.stringToArray(atob(base64Encoded));\r\n\r\n\t\t\tlet key = await this.buildKey(password);\r\n\r\n\t\t\t// decrypt into bytes\r\n\t\t\tlet decryptedBytes = await crypto.subtle.decrypt(algorithmObsolete, key, bytesToDecrypt);\r\n\r\n\t\t\t// convert bytes to text\r\n\t\t\tlet utf8Decode = new TextDecoder();\r\n\t\t\tlet decryptedText = utf8Decode.decode(decryptedBytes);\r\n\t\t\treturn decryptedText;\r\n\t\t} catch (e) {\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n}\r\n","import { App, PluginSettingTab, Setting } from \"obsidian\";\r\nimport MeldEncrypt from \"./main\";\r\n\r\nexport default class MeldEncryptSettingsTab extends PluginSettingTab {\r\n\tplugin: MeldEncrypt;\r\n\r\n\tpwTimeoutSetting:Setting;\r\n\r\n\tconstructor(app: App, plugin: MeldEncrypt) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tlet { containerEl } = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\t\t\r\n\t\tcontainerEl.createEl('h2', {text: 'Settings for Meld Encrypt'});\r\n\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Expand selection to whole line?')\r\n\t\t\t.setDesc('Partial selections will get expanded to the whole line.')\r\n\t\t\t.addToggle( toggle =>{\r\n\t\t\t\ttoggle\r\n\t\t\t\t\t.setValue(this.plugin.settings.expandToWholeLines)\r\n\t\t\t\t\t.onChange( async value =>{\r\n\t\t\t\t\t\tthis.plugin.settings.expandToWholeLines = value;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t\t//this.updateSettingsUi();\r\n\t\t\t\t\t})\r\n\t\t\t})\r\n\t\t;\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Confirm password?')\r\n\t\t\t.setDesc('Confirm password when encrypting.')\r\n\t\t\t.addToggle( toggle =>{\r\n\t\t\t\ttoggle\r\n\t\t\t\t\t.setValue(this.plugin.settings.confirmPassword)\r\n\t\t\t\t\t.onChange( async value =>{\r\n\t\t\t\t\t\tthis.plugin.settings.confirmPassword = value;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t\tthis.updateSettingsUi();\r\n\t\t\t\t\t})\r\n\t\t\t})\r\n\t\t;\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Copy button?')\r\n\t\t\t.setDesc('Show a button to copy decrypted text.')\r\n\t\t\t.addToggle( toggle =>{\r\n\t\t\t\ttoggle\r\n\t\t\t\t\t.setValue(this.plugin.settings.showButton)\r\n\t\t\t\t\t.onChange( async value =>{\r\n\t\t\t\t\t\tthis.plugin.settings.showButton = value;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t\tthis.updateSettingsUi();\r\n\t\t\t\t\t})\r\n\t\t\t})\r\n\t\t;\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Remember password?')\r\n\t\t\t.setDesc('Remember the last used password for this session.')\r\n\t\t\t.addToggle( toggle =>{\r\n\t\t\t\ttoggle\r\n\t\t\t\t\t.setValue(this.plugin.settings.rememberPassword)\r\n\t\t\t\t\t.onChange( async value =>{\r\n\t\t\t\t\t\tthis.plugin.settings.rememberPassword = value;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t\tthis.updateSettingsUi();\r\n\t\t\t\t\t})\r\n\t\t\t})\r\n\t\t;\r\n\r\n\t\tthis.pwTimeoutSetting = new Setting(containerEl)\r\n\t\t\t.setName( this.buildPasswordTimeoutSettingName() )\r\n\t\t\t.setDesc('The number of minutes to remember the last used password.')\r\n\t\t\t.addSlider( slider => {\r\n\t\t\t\tslider\r\n\t\t\t\t\t.setLimits(0, 120, 5)\r\n\t\t\t\t\t.setValue(this.plugin.settings.rememberPasswordTimeout)\r\n\t\t\t\t\t.onChange( async value => {\r\n\t\t\t\t\t\tthis.plugin.settings.rememberPasswordTimeout = value;\r\n\t\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t\t\tthis.updateSettingsUi();\r\n\t\t\t\t\t})\r\n\t\t\t\t;\r\n\t\t\t\t\r\n\t\t\t})\r\n\t\t;\r\n\r\n\t\tthis.updateSettingsUi();\r\n\t}\r\n\r\n\tupdateSettingsUi():void{\r\n\t\tthis.pwTimeoutSetting.setName(this.buildPasswordTimeoutSettingName());\r\n\r\n\r\n\t\tif ( this.plugin.settings.rememberPassword ){\r\n\t\t\tthis.pwTimeoutSetting.settingEl.show();\r\n\t\t}else{\r\n\t\t\tthis.pwTimeoutSetting.settingEl.hide();\r\n\t\t}\r\n\t}\r\n\r\n\tbuildPasswordTimeoutSettingName():string{\r\n\t\tconst value = this.plugin.settings.rememberPasswordTimeout;\r\n\t\tlet timeoutString = `${value} minutes`;\r\n\t\tif(value == 0){\r\n\t\t\ttimeoutString = 'Never forget';\r\n\t\t}\r\n\t\treturn `Remember Password Timeout (${timeoutString})`;\r\n\t}\r\n}","import { Notice, Plugin, MarkdownView, Editor, EditorPosition } from 'obsidian';\r\nimport DecryptModal from './DecryptModal';\r\nimport PasswordModal from './PasswordModal';\r\nimport { CryptoHelperV2, CryptoHelperObsolete} from './CryptoHelper';\r\nimport MeldEncryptSettingsTab from './MeldEncryptSettingsTab';\r\n\r\nconst _PREFIX: string = '%%🔐';\r\nconst _PREFIX_OBSOLETE: string = _PREFIX + ' ';\r\nconst _PREFIX_A: string = _PREFIX + 'α ';\r\nconst _SUFFIX: string = ' 🔐%%';\r\n\r\nconst _HINT: string = '💡';\r\n\r\ninterface MeldEncryptPluginSettings {\r\n\texpandToWholeLines: boolean,\r\n\tconfirmPassword: boolean;\r\n\tshowButton: boolean;\r\n\trememberPassword: boolean;\r\n\trememberPasswordTimeout: number;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: MeldEncryptPluginSettings = {\r\n\texpandToWholeLines: true,\r\n\tconfirmPassword: true,\r\n\tshowButton: false,\r\n\trememberPassword: true,\r\n\trememberPasswordTimeout: 30\r\n}\r\n\r\nexport default class MeldEncrypt extends Plugin {\r\n\r\n\tsettings: MeldEncryptPluginSettings;\r\n\tpasswordLastUsedExpiry: number\r\n\tpasswordLastUsed: string;\r\n\r\n\tasync onload() {\r\n\r\n\t\tawait this.loadSettings();\r\n\r\n\t\tthis.addSettingTab(new MeldEncryptSettingsTab(this.app, this));\r\n\r\n\t\tthis.addCommand({\r\n\t\t\tid: 'meld-encrypt',\r\n\t\t\tname: 'Encrypt/Decrypt',\r\n\t\t\teditorCheckCallback: (checking, editor, view) => this.processEncryptDecryptCommand(checking, editor, view, false)\r\n\t\t});\r\n\r\n\t\tthis.addCommand({\r\n\t\t\tid: 'meld-encrypt-in-place',\r\n\t\t\tname: 'Encrypt/Decrypt In-place',\r\n\t\t\teditorCheckCallback: (checking, editor, view) => this.processEncryptDecryptCommand(checking, editor, view, true)\r\n\t\t});\r\n\r\n\t\tthis.addCommand({\r\n\t\t\tid: 'meld-encrypt-note',\r\n\t\t\tname: 'Encrypt/Decrypt Whole Note',\r\n\t\t\teditorCheckCallback: (checking, editor, view) => this.processEncryptDecryptWholeNoteCommand(checking, editor, view)\r\n\t\t});\r\n\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n\r\n\tisSettingsModalOpen() : boolean{\r\n\t\treturn document.querySelector('.mod-settings') !== null;\r\n\t} \r\n\r\n\tprocessEncryptDecryptWholeNoteCommand(checking: boolean, editor: Editor, view: MarkdownView): boolean {\r\n\r\n\t\tif ( checking && this.isSettingsModalOpen() ){\r\n\t\t\t// Settings is open, ensures this command can show up in other\r\n\t\t\t// plugins which list commands e.g. customizable-sidebar\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\tconst startPos = editor.offsetToPos(0);\r\n\t\tconst endPos = { line: editor.lastLine(), ch: editor.getLine(editor.lastLine()).length };\r\n\r\n\t\tconst selectionText = editor.getRange(startPos, endPos).trim();\r\n\r\n\t\treturn this.processSelection(\r\n\t\t\tchecking,\r\n\t\t\teditor,\r\n\t\t\tselectionText,\r\n\t\t\tstartPos,\r\n\t\t\tendPos,\r\n\t\t\ttrue\r\n\t\t);\r\n\t}\r\n\r\n\tprocessEncryptDecryptCommand(checking: boolean, editor: Editor, view: MarkdownView, decryptInPlace: boolean): boolean {\r\n\t\tif ( checking && this.isSettingsModalOpen() ){\r\n\t\t\t// Settings is open, ensures this command can show up in other\r\n\t\t\t// plugins which list commands e.g. customizable-sidebar\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\tlet startPos = editor.getCursor('from');\r\n\t\tlet endPos = editor.getCursor('to');\r\n\r\n\t\tif (this.settings.expandToWholeLines){\r\n\t\t\tconst startLine = startPos.line;\r\n\t\t\tstartPos = { line: startLine, ch: 0 }; // want the start of the first line\r\n\r\n\t\t\tconst endLine = endPos.line;\r\n\t\t\tconst endLineText = editor.getLine(endLine);\r\n\t\t\tendPos = { line: endLine, ch: endLineText.length }; // want the end of last line\r\n\t\t}else{\r\n\t\t\tif ( !editor.somethingSelected() ){\r\n\t\t\t\t// nothing selected, assume user wants to decrypt, expand to start and end markers\r\n\t\t\t\tstartPos = this.getClosestPrevTextCursorPos(editor, _PREFIX, startPos );\r\n\t\t\t\tendPos = this.getClosestNextTextCursorPos(editor, _SUFFIX, endPos );\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst selectionText = editor.getRange(startPos, endPos);\r\n\r\n\t\treturn this.processSelection(\r\n\t\t\tchecking,\r\n\t\t\teditor,\r\n\t\t\tselectionText,\r\n\t\t\tstartPos,\r\n\t\t\tendPos,\r\n\t\t\tdecryptInPlace\r\n\t\t);\r\n\t}\r\n\r\n\tprivate getClosestPrevTextCursorPos(editor: Editor, text: string, defaultValue:EditorPosition ): EditorPosition{\r\n\t\tconst initOffset = editor.posToOffset( editor.getCursor(\"from\") );\r\n\r\n\t\tfor (let offset = initOffset; offset >= 0; offset--) {\r\n\t\t\tconst offsetPos = editor.offsetToPos(offset);\r\n\t\t\tconst textEndOffset = offset + text.length;\r\n\t\t\tconst prefixEndPos = editor.offsetToPos(textEndOffset);\r\n\t\t\t\r\n\t\t\tconst testText = editor.getRange( offsetPos, prefixEndPos );\r\n\t\t\tif (testText == text){\r\n\t\t\t\treturn offsetPos;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn defaultValue;\r\n\t}\r\n\r\n\tprivate getClosestNextTextCursorPos(editor: Editor, text: string, defaultValue:EditorPosition ): EditorPosition{\r\n\t\tconst initOffset = editor.posToOffset( editor.getCursor(\"from\") );\r\n\t\tconst lastLineNum = editor.lastLine();\r\n\r\n\t\tlet maxOffset = editor.posToOffset( {line:lastLineNum, ch:editor.getLine(lastLineNum).length} );\r\n\r\n\t\tfor (let offset = initOffset; offset <= maxOffset - text.length; offset++) {\r\n\t\t\tconst offsetPos = editor.offsetToPos(offset);\r\n\t\t\tconst textEndOffset = offset + text.length;\r\n\t\t\tconst prefixEndPos = editor.offsetToPos(textEndOffset);\r\n\t\t\t\r\n\t\t\tconst testText = editor.getRange( offsetPos, prefixEndPos );\r\n\t\t\t\r\n\t\t\tif (testText == text){\r\n\t\t\t\treturn prefixEndPos;\r\n\t\t\t}\r\n\t\t}\r\n\t\t\r\n\t\treturn defaultValue;\r\n\t}\r\n\r\n\tprivate analyseSelection( selectionText: string ):SelectionAnalysis{\r\n\t\t\r\n\t\tconst result = new SelectionAnalysis();\r\n\r\n\t\tresult.isEmpty = selectionText.length === 0;\r\n\r\n\t\tresult.hasObsoleteEncryptedPrefix = selectionText.startsWith(_PREFIX_OBSOLETE);\r\n\t\tresult.hasEncryptedPrefix = result.hasObsoleteEncryptedPrefix || selectionText.startsWith(_PREFIX_A);\r\n\r\n\t\tresult.hasDecryptSuffix = selectionText.endsWith(_SUFFIX);\r\n\r\n\t\tresult.containsEncryptedMarkers =\r\n\t\t\tselectionText.contains(_PREFIX_OBSOLETE)\r\n\t\t\t|| selectionText.contains(_PREFIX_A)\r\n\t\t\t|| selectionText.contains(_SUFFIX)\r\n\t\t;\r\n\r\n\t\tresult.canDecrypt = result.hasEncryptedPrefix && result.hasDecryptSuffix;\r\n\t\tresult.canEncrypt = !result.hasEncryptedPrefix && !result.containsEncryptedMarkers;\r\n\t\t\r\n\t\tif (result.canDecrypt){\r\n\t\t\tresult.decryptable = this.parseDecryptableContent(selectionText);\r\n\t\t\tif (result.decryptable == null){\r\n\t\t\t\tresult.canDecrypt = false;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\tprivate processSelection(\r\n\t\tchecking: boolean,\r\n\t\teditor: Editor,\r\n\t\tselectionText: string,\r\n\t\tfinalSelectionStart: CodeMirror.Position,\r\n\t\tfinalSelectionEnd: CodeMirror.Position,\r\n\t\tdecryptInPlace: boolean\r\n\t){\r\n\r\n\t\tconst selectionAnalysis = this.analyseSelection(selectionText);\r\n\r\n\t\tif (selectionAnalysis.isEmpty) {\r\n\t\t\tif (!checking){\r\n\t\t\t\tnew Notice('Nothing to Encrypt.');\r\n\t\t\t}\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tif (!selectionAnalysis.canDecrypt && !selectionAnalysis.canEncrypt) {\r\n\t\t\tif (!checking){\r\n\t\t\t\tnew Notice('Unable to Encrypt or Decrypt that.');\r\n\t\t\t}\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tif (checking) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\r\n\t\t// Fetch password from user\r\n\r\n\t\t// determine default password\r\n\t\tconst isRememberPasswordExpired =\r\n\t\t\t!this.settings.rememberPassword\r\n\t\t\t|| (\r\n\t\t\t\tthis.passwordLastUsedExpiry != null\r\n\t\t\t\t&& Date.now() > this.passwordLastUsedExpiry\r\n\t\t\t)\r\n\t\t;\r\n\r\n\t\tconst confirmPassword = selectionAnalysis.canEncrypt && this.settings.confirmPassword;\r\n\r\n\t\tif ( isRememberPasswordExpired || confirmPassword ) {\r\n\t\t\t// forget password\r\n\t\t\tthis.passwordLastUsed = '';\r\n\t\t}\r\n\r\n\t\tconst pwModal = new PasswordModal(\r\n\t\t\tthis.app,\r\n\t\t\tselectionAnalysis.canEncrypt,\r\n\t\t\tconfirmPassword,\r\n\t\t\tthis.passwordLastUsed,\r\n\t\t\tselectionAnalysis.decryptable?.hint\r\n\t\t);\r\n\t\tpwModal.onClose = () => {\r\n\t\t\tconst pw = pwModal.password ?? ''\r\n\t\t\tif (pw.length == 0) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tconst hint = pwModal.hint;\r\n\r\n\t\t\t// remember password?\r\n\t\t\tif (this.settings.rememberPassword) {\r\n\t\t\t\tthis.passwordLastUsed = pw;\r\n\t\t\t\tthis.passwordLastUsedExpiry =\r\n\t\t\t\t\tthis.settings.rememberPasswordTimeout == 0\r\n\t\t\t\t\t\t? null\r\n\t\t\t\t\t\t: Date.now() + this.settings.rememberPasswordTimeout * 1000 * 60// new expiry\r\n\t\t\t\t\t;\r\n\t\t\t}\r\n\r\n\t\t\tif (selectionAnalysis.canEncrypt) {\r\n\t\t\t\tconst encryptable = new Encryptable();\r\n\t\t\t\tencryptable.text = selectionText;\r\n\t\t\t\tencryptable.hint = hint;\r\n\r\n\t\t\t\tthis.encryptSelection(\r\n\t\t\t\t\teditor,\r\n\t\t\t\t\tencryptable,\r\n\t\t\t\t\tpw,\r\n\t\t\t\t\tfinalSelectionStart,\r\n\t\t\t\t\tfinalSelectionEnd\r\n\t\t\t\t);\r\n\t\t\t} else {\r\n\r\n\t\t\t\tif (selectionAnalysis.decryptable.version == 1){\r\n\t\t\t\t\tthis.decryptSelection_a(\r\n\t\t\t\t\t\teditor,\r\n\t\t\t\t\t\tselectionAnalysis.decryptable,\r\n\t\t\t\t\t\tpw,\r\n\t\t\t\t\t\tfinalSelectionStart,\r\n\t\t\t\t\t\tfinalSelectionEnd,\r\n\t\t\t\t\t\tdecryptInPlace\r\n\t\t\t\t\t);\r\n\t\t\t\t}else{\r\n\t\t\t\t\tthis.decryptSelectionObsolete(\r\n\t\t\t\t\t\teditor,\r\n\t\t\t\t\t\tselectionAnalysis.decryptable,\r\n\t\t\t\t\t\tpw,\r\n\t\t\t\t\t\tfinalSelectionStart,\r\n\t\t\t\t\t\tfinalSelectionEnd,\r\n\t\t\t\t\t\tdecryptInPlace\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tpwModal.open();\r\n\r\n\t\treturn true;\r\n\t}\r\n\r\n\tprivate async encryptSelection(\r\n\t\teditor: Editor,\r\n\t\tencryptable: Encryptable,\r\n\t\tpassword: string,\r\n\t\tfinalSelectionStart: CodeMirror.Position,\r\n\t\tfinalSelectionEnd: CodeMirror.Position,\r\n\t) {\r\n\t\t//encrypt\r\n\t\tconst crypto = new CryptoHelperV2();\r\n\t\tconst encodedText = this.encodeEncryption(\r\n\t\t\tawait crypto.encryptToBase64(encryptable.text, password),\r\n\t\t\tencryptable.hint\r\n\t\t);\r\n\t\teditor.setSelection(finalSelectionStart, finalSelectionEnd);\r\n\t\teditor.replaceSelection(encodedText);\r\n\t}\r\n\r\n\tprivate async decryptSelection_a(\r\n\t\teditor: Editor,\r\n\t\tdecryptable: Decryptable,\r\n\t\tpassword: string,\r\n\t\tselectionStart: CodeMirror.Position,\r\n\t\tselectionEnd: CodeMirror.Position,\r\n\t\tdecryptInPlace: boolean\r\n\t) {\r\n\t\t// decrypt\r\n\r\n\t\tconst crypto = new CryptoHelperV2();\r\n\t\tconst decryptedText = await crypto.decryptFromBase64(decryptable.base64CipherText, password);\r\n\t\tif (decryptedText === null) {\r\n\t\t\tnew Notice('❌ Decryption failed!');\r\n\t\t} else {\r\n\r\n\t\t\tif (decryptInPlace) {\r\n\t\t\t\teditor.setSelection(selectionStart, selectionEnd);\r\n\t\t\t\teditor.replaceSelection(decryptedText);\r\n\t\t\t} else {\r\n\t\t\t\tconst decryptModal = new DecryptModal(this.app, '🔓', decryptedText, this.settings.showButton);\r\n\t\t\t\tdecryptModal.onClose = () => {\r\n\t\t\t\t\teditor.focus();\r\n\t\t\t\t\tif (decryptModal.decryptInPlace) {\r\n\t\t\t\t\t\teditor.setSelection(selectionStart, selectionEnd);\r\n\t\t\t\t\t\teditor.replaceSelection(decryptedText);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tdecryptModal.open();\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async decryptSelectionObsolete(\r\n\t\teditor: Editor,\r\n\t\tdecryptable: Decryptable,\r\n\t\tpassword: string,\r\n\t\tselectionStart: CodeMirror.Position,\r\n\t\tselectionEnd: CodeMirror.Position,\r\n\t\tdecryptInPlace: boolean\r\n\t) {\r\n\t\t// decrypt\r\n\t\tconst base64CipherText = this.removeMarkers(decryptable.base64CipherText);\r\n\t\tconst crypto = new CryptoHelperObsolete();\r\n\t\tconst decryptedText = await crypto.decryptFromBase64(base64CipherText, password);\r\n\t\tif (decryptedText === null) {\r\n\t\t\tnew Notice('❌ Decryption failed!');\r\n\t\t} else {\r\n\r\n\t\t\tif (decryptInPlace) {\r\n\t\t\t\teditor.setSelection(selectionStart, selectionEnd);\r\n\t\t\t\teditor.replaceSelection(decryptedText);\r\n\t\t\t} else {\r\n\t\t\t\tconst decryptModal = new DecryptModal(this.app, '🔓', decryptedText, this.settings.showButton);\r\n\t\t\t\tdecryptModal.onClose = () => {\r\n\t\t\t\t\teditor.focus();\r\n\t\t\t\t\tif (decryptModal.decryptInPlace) {\r\n\t\t\t\t\t\teditor.setSelection(selectionStart, selectionEnd);\r\n\t\t\t\t\t\teditor.replaceSelection(decryptedText);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tdecryptModal.open();\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate parseDecryptableContent(text: string) : Decryptable{\r\n\t\tconst result = new Decryptable();\r\n\r\n\t\tlet content = text;\r\n\t\tif (content.startsWith(_PREFIX_A) && content.endsWith(_SUFFIX)) {\r\n\t\t\tresult.version=1;\r\n\t\t\tcontent = content.replace(_PREFIX_A, '').replace(_SUFFIX, '');\r\n\t\t}else if (content.startsWith(_PREFIX_OBSOLETE) && content.endsWith(_SUFFIX)) {\r\n\t\t\tresult.version=0;\r\n\t\t\tcontent = content.replace(_PREFIX_OBSOLETE, '').replace(_SUFFIX, '');\r\n\t\t}else {\r\n\t\t\treturn null; // invalid format\r\n\t\t}\r\n\r\n\t\t// check if there is a hint\r\n\t\t//console.table(content);\r\n\t\tif (content.substr(0,_HINT.length) == _HINT){\r\n\t\t\tconst endHintMarker = content.indexOf(_HINT,_HINT.length);\r\n\t\t\tif (endHintMarker<0){\r\n\t\t\t\treturn null; // invalid format\r\n\t\t\t}\r\n\t\t\tresult.hint = content.substring(_HINT.length,endHintMarker)\r\n\t\t\tresult.base64CipherText = content.substring(endHintMarker+_HINT.length);\r\n\t\t}else{\r\n\t\t\tresult.base64CipherText = content;\r\n\t\t}\r\n\t\t\r\n\t\t//console.table(result);\r\n\r\n\t\treturn result;\r\n\r\n\t}\r\n\r\n\tprivate removeMarkers(text: string): string {\r\n\t\tif (text.startsWith(_PREFIX_A) && text.endsWith(_SUFFIX)) {\r\n\t\t\treturn text.replace(_PREFIX_A, '').replace(_SUFFIX, '');\r\n\t\t}\r\n\t\tif (text.startsWith(_PREFIX_OBSOLETE) && text.endsWith(_SUFFIX)) {\r\n\t\t\treturn text.replace(_PREFIX_OBSOLETE, '').replace(_SUFFIX, '');\r\n\t\t}\r\n\t\treturn text;\r\n\t}\r\n\r\n\tprivate encodeEncryption( encryptedText: string, hint: string ): string {\r\n\t\tif (!encryptedText.contains(_PREFIX_OBSOLETE) && !encryptedText.contains(_PREFIX_A) && !encryptedText.contains(_SUFFIX)) {\r\n\t\t\tif (hint){\r\n\t\t\t\treturn _PREFIX_A.concat(_HINT, hint, _HINT, encryptedText, _SUFFIX);\t\r\n\t\t\t}\r\n\t\t\treturn _PREFIX_A.concat(encryptedText, _SUFFIX);\r\n\t\t}\r\n\t\treturn encryptedText;\r\n\t}\r\n\r\n}\r\n\r\nclass SelectionAnalysis{\r\n\tisEmpty: boolean;\r\n\thasObsoleteEncryptedPrefix: boolean;\r\n\thasEncryptedPrefix: boolean;\r\n\thasDecryptSuffix: boolean;\r\n\tcanDecrypt: boolean;\r\n\tcanEncrypt: boolean;\r\n\tcontainsEncryptedMarkers: boolean;\r\n\tdecryptable : Decryptable;\r\n}\r\n\r\nclass Encryptable{\r\n\ttext:string;\r\n\thint:string;\r\n}\r\n\r\nclass Decryptable{\r\n\tversion: number;\r\n\tbase64CipherText:string;\r\n\thint:string;\r\n}"],"names":["Modal","Platform","PluginSettingTab","Setting","Plugin","Notice"],"mappings":"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"} diff --git a/.obsidian/plugins/meld-encrypt/manifest.json b/.obsidian/plugins/meld-encrypt/manifest.json new file mode 100644 index 0000000..ee1a6db --- /dev/null +++ b/.obsidian/plugins/meld-encrypt/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "meld-encrypt", + "name": "Meld Encrypt", + "version": "1.6.2", + "minAppVersion": "0.12.15", + "description": "Hide secrets in your notes", + "author": "meld-cp", + "authorUrl": "https://github.com/meld-cp/obsidian-encrypt", + "isDesktopOnly": false +} diff --git a/.obsidian/plugins/meld-encrypt/styles.css b/.obsidian/plugins/meld-encrypt/styles.css new file mode 100644 index 0000000..5273f02 --- /dev/null +++ b/.obsidian/plugins/meld-encrypt/styles.css @@ -0,0 +1,42 @@ +.meld-e-row{ + display: flex; + margin-bottom: 1em; +} + +.meld-e-icon{ + flex: 1; + display: inline-block; + margin-right: 1em; +} + +.meld-e-row input{ + flex: 20; +} + +.meld-e-platform-desktop .meld-e-button-confirm { + margin-left: 2.8em; + padding: 1em 2em; +} +.meld-e-platform-desktop .meld-e-button-confirm:focus{ + font-weight: bold; +} + +.meld-e-message{ + margin-left: 2.8em; + margin-bottom: 1em; +} + +.meld-e-button-next{ + margin-left: 1em; + flex: 3; +} + +.meld-e-platform-mobile .meld-e-button-next{ + display: inline-block; + margin: 0 0 0 1em; + width: auto; +} + +.meld-e-hint{ + flex: 20; +} \ No newline at end of file diff --git a/.obsidian/workspace b/.obsidian/workspace index 7411495..1ee0e95 100644 --- a/.obsidian/workspace +++ b/.obsidian/workspace @@ -4,12 +4,14 @@ "type": "split", "children": [ { - "id": "6b97c5c8667e492b", + "id": "0d2c7508a23f0a87", "type": "leaf", "state": { - "type": "image", + "type": "markdown", "state": { - "file": "attachment/Steinemann Technology/mails/spammails/fakeinvite.png" + "file": "2022-06-27.md", + "mode": "source", + "source": false } } } @@ -65,6 +67,20 @@ "id": "a54ca124d2689b37", "type": "split", "children": [ + { + "id": "36d1b5112e960052", + "type": "tabs", + "children": [ + { + "id": "39650d5b939ff18b", + "type": "leaf", + "state": { + "type": "calendar", + "state": {} + } + } + ] + }, { "id": "156a5a111c133560", "type": "tabs", @@ -75,7 +91,7 @@ "state": { "type": "backlink", "state": { - "file": "attachment/Steinemann Technology/mails/spammails/fakeinvite.png", + "file": "2022-06-27.md", "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical", @@ -103,7 +119,7 @@ "state": { "type": "outgoing-link", "state": { - "file": "attachment/Steinemann Technology/mails/spammails/fakeinvite.png", + "file": "2022-06-27.md", "linksCollapsed": false, "unlinkedCollapsed": false } @@ -115,28 +131,28 @@ "state": { "type": "outline", "state": { - "file": "attachment/Steinemann Technology/mails/spammails/fakeinvite.png" + "file": "2022-06-27.md" } } } ], - "currentTab": 2 + "currentTab": 3 } ], "direction": "horizontal", "width": 300 }, - "active": "6b97c5c8667e492b", + "active": "0d2c7508a23f0a87", "lastOpenFiles": [ + "2022-06-27.md", + "steinemann technology/Ky2Help.md", "attachment/Steinemann Technology/mails/spammails/fakeinvite.png", "attachment/Steinemann Technology/mails/spammails/fake.png", "Firmen/steinemann technology/infomails/Achtung Phish!.md", - "steinemann technology/Ky2Help.md", "attachment/Steinemann Technology/penta/error23.jpg", "attachment/Steinemann Technology/keeper/sso.jpg", "attachment/Steinemann Technology/monitre.jpg", "attachment/Steinemann Technology/keeper/keeper_konto.jpg", - "attachment/Steinemann Technology/penta/läuft.jpg", - "attachment/attachment.md" + "attachment/Steinemann Technology/penta/läuft.jpg" ] } \ No newline at end of file