diff --git a/notes/.obsidian/community-plugins.json b/notes/.obsidian/community-plugins.json index a895f9f..e119600 100644 --- a/notes/.obsidian/community-plugins.json +++ b/notes/.obsidian/community-plugins.json @@ -39,5 +39,7 @@ "obsidian-spaced-repetition", "highlightr-plugin", "obsidian-reading-time", - "obsidian-banners" + "obsidian-banners", + "obsidian-smart-typography", + "various-complements" ] \ No newline at end of file diff --git a/notes/.obsidian/plugins/obsidian-activity-history/data.json b/notes/.obsidian/plugins/obsidian-activity-history/data.json index 08ed5e6..c9a2f4f 100644 --- a/notes/.obsidian/plugins/obsidian-activity-history/data.json +++ b/notes/.obsidian/plugins/obsidian-activity-history/data.json @@ -12,8 +12,8 @@ "checkpointList": [ { "path": "/", - "date": "2022-09-19", - "size": 899709 + "date": "2022-09-20", + "size": 901739 } ], "activityHistory": [ @@ -807,6 +807,10 @@ { "date": "2022-09-19", "value": 125 + }, + { + "date": "2022-09-20", + "value": 2030 } ] } diff --git a/notes/.obsidian/plugins/obsidian-smart-typography/data.json b/notes/.obsidian/plugins/obsidian-smart-typography/data.json new file mode 100644 index 0000000..4c6521b --- /dev/null +++ b/notes/.obsidian/plugins/obsidian-smart-typography/data.json @@ -0,0 +1,18 @@ +{ + "curlyQuotes": true, + "emDash": true, + "ellipsis": true, + "arrows": true, + "comparisons": true, + "fractions": true, + "guillemets": false, + "skipEnDash": false, + "openSingle": "‘", + "closeSingle": "’", + "openDouble": "“", + "closeDouble": "”", + "openGuillemet": "«", + "closeGuillemet": "»", + "leftArrow": "←", + "rightArrow": "→" +} \ No newline at end of file diff --git a/notes/.obsidian/plugins/obsidian-smart-typography/main.js b/notes/.obsidian/plugins/obsidian-smart-typography/main.js new file mode 100644 index 0000000..f0fd55b --- /dev/null +++ b/notes/.obsidian/plugins/obsidian-smart-typography/main.js @@ -0,0 +1,1060 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); +var state = require('@codemirror/state'); +var language = require('@codemirror/language'); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +// Dashes +const dashRules = [ + // en dash + { + trigger: "-", + from: "--", + to: "–", + contextMatch: /-$/, + }, + // em dash + { + trigger: "-", + from: "–-", + to: "—", + contextMatch: /–$/, + }, + // tripple dash + { + trigger: "-", + from: "—-", + to: "---", + contextMatch: /—$/, + }, +]; +const dashRulesSansEnDash = [ + // em dash + { + trigger: "-", + from: "--", + to: "—", + contextMatch: /-$/, + }, + // tripple dash + { + trigger: "-", + from: "—-", + to: "---", + contextMatch: /—$/, + }, +]; +// Ellipsis +const ellipsisRules = [ + { + trigger: ".", + from: "...", + to: "…", + contextMatch: /\.\.$/, + }, +]; +// Quotes +const smartQuoteRules = [ + // Open double + { + trigger: '"', + from: '"', + to: (settings) => settings.openDouble, + contextMatch: /[\s\{\[\(\<'"\u2018\u201C]$/, + }, + // Close double + { + trigger: '"', + from: '"', + to: (settings) => settings.closeDouble, + contextMatch: /.*$/, + }, + // Paired double + { + trigger: '""', + from: '""', + to: (settings) => settings.openDouble + settings.closeDouble, + contextMatch: /.*$/, + }, + // Open single + { + trigger: "'", + from: "'", + to: (settings) => settings.openSingle, + contextMatch: /[\s\{\[\(\<'"\u2018\u201C]$/, + }, + // Close single + { + trigger: "'", + from: "'", + to: (settings) => settings.closeSingle, + contextMatch: /.*$/, + }, + // Paired single + { + trigger: "''", + from: "''", + to: (settings) => settings.openSingle + settings.closeSingle, + contextMatch: /.*$/, + }, +]; +// Arrows +const arrowRules = [ + { + trigger: "-", + from: "<-", + to: (settings) => settings.leftArrow, + contextMatch: /<$/, + }, + { + trigger: ">", + from: "->", + to: (settings) => settings.rightArrow, + contextMatch: /-$/, + }, +]; +// Guillemet +const guillemetRules = [ + { + trigger: "<", + from: "<<", + to: (settings) => settings.openGuillemet, + contextMatch: /<$/, + }, + { + trigger: ">", + from: ">>", + to: (settings) => settings.closeGuillemet, + contextMatch: />$/, + }, +]; +// Comparisons +const comparisonRules = [ + { + trigger: "=", + from: ">=", + to: "≥", + contextMatch: />$/, + }, + { + trigger: "=", + from: "<=", + to: "≤", + contextMatch: /<$/, + }, + { + trigger: "=", + from: "/=", + to: "≠", + contextMatch: /\/$/, + }, +]; +// Fractions +const fractionRules = [ + { + trigger: "2", + from: "1/2", + to: "½", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "3", + from: "1/3", + to: "⅓", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "3", + from: "2/3", + to: "⅔", + contextMatch: /(?:^|\s)2\/$/, + }, + { + trigger: "4", + from: "1/4", + to: "¼", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "4", + from: "3/4", + to: "¾", + contextMatch: /(?:^|\s)3\/$/, + }, + { + trigger: "5", + from: "1/5", + to: "⅕", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "5", + from: "2/5", + to: "⅖", + contextMatch: /(?:^|\s)2\/$/, + }, + { + trigger: "5", + from: "3/5", + to: "⅗", + contextMatch: /(?:^|\s)3\/$/, + }, + { + trigger: "5", + from: "4/5", + to: "⅘", + contextMatch: /(?:^|\s)4\/$/, + }, + { + trigger: "6", + from: "1/6", + to: "⅙", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "6", + from: "5/6", + to: "⅚", + contextMatch: /(?:^|\s)5\/$/, + }, + { + trigger: "7", + from: "1/7", + to: "⅐", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "8", + from: "1/8", + to: "⅛", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "8", + from: "3/8", + to: "⅜", + contextMatch: /(?:^|\s)3\/$/, + }, + { + trigger: "8", + from: "5/8", + to: "⅝", + contextMatch: /(?:^|\s)5\/$/, + }, + { + trigger: "8", + from: "7/8", + to: "⅞", + contextMatch: /(?:^|\s)7\/$/, + }, + { + trigger: "9", + from: "1/9", + to: "⅑", + contextMatch: /(?:^|\s)1\/$/, + }, + { + trigger: "0", + from: "1/10", + to: "⅒", + contextMatch: /(?:^|\s)1\/1$/, + }, +]; + +const dashChar = "-"; +const enDashChar = "–"; +const emDashChar = "—"; +const enDash = { + matchTrigger: dashChar, + matchRegExp: /--$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + enDashChar, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === enDashChar) { + delta.update(delta.from, delta.to, [dashChar + dashChar]); + } + }, +}; +const emDash = { + matchTrigger: dashChar, + matchRegExp: /–-$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + emDashChar, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === emDashChar) { + delta.update(delta.from, delta.to, [enDashChar + dashChar]); + } + }, +}; +const trippleDash = { + matchTrigger: dashChar, + matchRegExp: /—-$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + dashChar + dashChar + dashChar, + ]); + }, + performRevert: (instance, delta, settings) => { }, +}; +const ellipsis = { + matchTrigger: ".", + matchRegExp: /\.\.\.$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 2 }, delta.to, [ + "…", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "…") { + delta.update(delta.from, delta.to, ["..."]); + } + }, +}; +const openDoubleQuote = { + matchTrigger: '"', + matchRegExp: /(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [settings.openDouble]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.openDouble) { + delta.update(delta.from, delta.to, ['"']); + } + }, +}; +const closeDoubleQuote = { + matchTrigger: '"', + matchRegExp: /"$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [settings.closeDouble]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.closeDouble) { + delta.update(delta.from, delta.to, ['"']); + } + }, +}; +const pairedDoubleQuote = { + matchTrigger: '""', + matchRegExp: /""$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [ + settings.openDouble + settings.closeDouble, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.openDouble) { + delta.update(delta.from, Object.assign(Object.assign({}, delta.to), { ch: delta.to.ch + 1 }), ['""']); + setTimeout(() => instance.setCursor(Object.assign(Object.assign({}, delta.from), { ch: delta.from.ch + 1 }))); + } + }, +}; +const wrappedDoubleQuote = { + matchTrigger: /^".*"$/, + matchRegExp: false, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [ + settings.openDouble + delta.text[0].slice(1, -1) + settings.closeDouble, + ]); + }, + performRevert: false, +}; +const openSingleQuote = { + matchTrigger: "'", + matchRegExp: /(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [settings.openSingle]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.openSingle) { + delta.update(delta.from, delta.to, ["'"]); + } + }, +}; +const closeSingleQuote = { + matchTrigger: "'", + matchRegExp: /'$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [settings.closeSingle]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.closeSingle) { + delta.update(delta.from, delta.to, ["'"]); + } + }, +}; +const pairedSingleQuote = { + matchTrigger: "''", + matchRegExp: /''$/, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [ + settings.openSingle + settings.closeSingle, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.openSingle) { + delta.update(delta.from, Object.assign(Object.assign({}, delta.to), { ch: delta.to.ch + 1 }), ["''"]); + setTimeout(() => instance.setCursor(Object.assign(Object.assign({}, delta.from), { ch: delta.from.ch + 1 }))); + } + }, +}; +const wrappedSingleQuote = { + matchTrigger: /^'.*'$/, + matchRegExp: false, + performUpdate: (instance, delta, settings) => { + delta.update(delta.from, delta.to, [ + settings.openSingle + delta.text[0].slice(1, -1) + settings.closeSingle, + ]); + }, + performRevert: false, +}; +const rightArrow = { + matchTrigger: ">", + matchRegExp: /->$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + settings.rightArrow, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.rightArrow) { + delta.update(delta.from, delta.to, ["->"]); + } + }, +}; +const leftArrow = { + matchTrigger: "-", + matchRegExp: /<-$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + settings.leftArrow, + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === settings.leftArrow) { + delta.update(delta.from, delta.to, ["<-"]); + } + }, +}; +const greaterThanOrEqualTo = { + matchTrigger: "=", + matchRegExp: />=$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + "≥", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "≥") { + delta.update(delta.from, delta.to, [">="]); + } + }, +}; +const lessThanOrEqualTo = { + matchTrigger: "=", + matchRegExp: /<=$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + "≤", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "≤") { + delta.update(delta.from, delta.to, ["<="]); + } + }, +}; +const notEqualTo = { + matchTrigger: "=", + matchRegExp: /\/=$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + "≠", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "≠") { + delta.update(delta.from, delta.to, ["/="]); + } + }, +}; +const rightGuillemet = { + matchTrigger: ">", + matchRegExp: />>$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + "»", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "»") { + delta.update(delta.from, delta.to, [">>"]); + } + }, +}; +const leftGuillemet = { + matchTrigger: "<", + matchRegExp: /<<$/, + performUpdate: (instance, delta, settings) => { + delta.update({ line: delta.from.line, ch: delta.from.ch - 1 }, delta.to, [ + "«", + ]); + }, + performRevert: (instance, delta, settings) => { + if (instance.getRange(delta.from, delta.to) === "«") { + delta.update(delta.from, delta.to, ["<<"]); + } + }, +}; +const legacyDashRules = [enDash, emDash, trippleDash]; +const legacyEllipsisRules = [ellipsis]; +const legacySmartQuoteRules = [ + openDoubleQuote, + closeDoubleQuote, + pairedDoubleQuote, + wrappedDoubleQuote, + openSingleQuote, + closeSingleQuote, + pairedSingleQuote, + wrappedSingleQuote, +]; +const legacyComparisonRules = [ + lessThanOrEqualTo, + greaterThanOrEqualTo, + notEqualTo, +]; +const legacyArrowRules = [leftArrow, rightArrow]; +const legacyGuillemetRules = [leftGuillemet, rightGuillemet]; + +const DEFAULT_SETTINGS = { + curlyQuotes: true, + emDash: true, + ellipsis: true, + arrows: true, + comparisons: true, + fractions: false, + guillemets: false, + skipEnDash: false, + openSingle: "‘", + closeSingle: "’", + openDouble: "“", + closeDouble: "”", + openGuillemet: "«", + closeGuillemet: "»", + leftArrow: "←", + rightArrow: "→", +}; +class SmartTypography extends obsidian.Plugin { + constructor() { + super(...arguments); + this.beforeChangeHandler = (instance, delta) => { + if (this.legacyLastUpdate.has(instance) && delta.origin === "+delete") { + const revert = this.legacyLastUpdate.get(instance).performRevert; + if (revert) { + revert(instance, delta, this.settings); + this.legacyLastUpdate.delete(instance); + } + return; + } + if (delta.origin === undefined && delta.text.length === 1) { + const input = delta.text[0]; + for (let rule of this.legacyInputRules) { + if (!(rule.matchTrigger instanceof RegExp)) { + continue; + } + if (rule.matchTrigger.test(input)) { + rule.performUpdate(instance, delta, this.settings); + return; + } + } + return; + } + if (delta.origin === "+input" && delta.text.length === 1) { + const input = delta.text[0]; + const rules = this.legacyInputRules.filter((r) => { + return typeof r.matchTrigger === "string" && r.matchTrigger === input; + }); + if (rules.length === 0) { + if (this.legacyLastUpdate.has(instance)) { + this.legacyLastUpdate.delete(instance); + } + return; + } + let str = input; + if (delta.to.ch > 0) { + str = `${instance.getRange({ line: delta.to.line, ch: 0 }, delta.to)}${str}`; + } + for (let rule of rules) { + if (rule.matchRegExp && rule.matchRegExp.test(str)) { + if (shouldCheckTextAtPos(instance, delta.from) && + shouldCheckTextAtPos(instance, delta.to)) { + this.legacyLastUpdate.set(instance, rule); + rule.performUpdate(instance, delta, this.settings); + } + return; + } + } + } + if (this.legacyLastUpdate.has(instance)) { + this.legacyLastUpdate.delete(instance); + } + }; + } + buildInputRules() { + this.legacyInputRules = []; + this.inputRules = []; + this.inputRuleMap = {}; + if (this.settings.emDash) { + if (this.settings.skipEnDash) { + this.inputRules.push(...dashRulesSansEnDash); + } + else { + this.inputRules.push(...dashRules); + } + this.legacyInputRules.push(...legacyDashRules); + } + if (this.settings.ellipsis) { + this.inputRules.push(...ellipsisRules); + this.legacyInputRules.push(...legacyEllipsisRules); + } + if (this.settings.curlyQuotes) { + this.inputRules.push(...smartQuoteRules); + this.legacyInputRules.push(...legacySmartQuoteRules); + } + if (this.settings.arrows) { + this.inputRules.push(...arrowRules); + this.legacyInputRules.push(...legacyArrowRules); + } + if (this.settings.guillemets) { + this.inputRules.push(...guillemetRules); + this.legacyInputRules.push(...legacyGuillemetRules); + } + if (this.settings.comparisons) { + this.inputRules.push(...comparisonRules); + this.legacyInputRules.push(...legacyComparisonRules); + } + if (this.settings.fractions) { + this.inputRules.push(...fractionRules); + } + this.inputRules.forEach((rule) => { + if (this.inputRuleMap[rule.trigger] === undefined) { + this.inputRuleMap[rule.trigger] = []; + } + this.inputRuleMap[rule.trigger].push(rule); + }); + } + onload() { + return __awaiter(this, void 0, void 0, function* () { + yield this.loadSettings(); + this.addSettingTab(new SmartTypographySettingTab(this.app, this)); + // Codemirror 6 + // + // When smart typography overrides changes, we want to keep a record + // so we can undo them when the user presses backspace + const storeTransaction = state.StateEffect.define(); + const prevTransactionState = state.StateField.define({ + create() { + return null; + }, + update(oldVal, tr) { + for (let e of tr.effects) { + if (e.is(storeTransaction)) { + return e.value; + } + } + if (!oldVal || + tr.isUserEvent("input") || + tr.isUserEvent("delete.forward") || + tr.isUserEvent("delete.cut") || + tr.isUserEvent("move") || + tr.isUserEvent("select") || + tr.isUserEvent("undo")) { + return null; + } + return oldVal; + }, + }); + this.registerEditorExtension([ + prevTransactionState, + state.EditorState.transactionFilter.of((tr) => { + // Revert any stored changes on delete + if (tr.isUserEvent("delete.backward") || + tr.isUserEvent("delete.selection")) { + return tr.startState.field(prevTransactionState, false) || tr; + } + // If the user hasn't typed, or the doc hasn't changed, return early + if (!tr.isUserEvent("input.type") || !tr.docChanged) { + return tr; + } + // Cache the syntax tree if we end up accessing it + let tree = null; + // Memoize any positions we check so we can avoid some work + const seenPositions = {}; + const canPerformReplacement = (pos) => { + if (seenPositions[pos] !== undefined) { + return seenPositions[pos]; + } + if (!tree) + tree = language.syntaxTree(tr.state); + const nodeProps = tree + .resolveInner(pos, 1) + .type.prop(language.tokenClassNodeProp); + if (nodeProps && ignoreListRegEx.test(nodeProps)) { + seenPositions[pos] = false; + } + else { + seenPositions[pos] = true; + } + return seenPositions[pos]; + }; + // Store a list of changes and specs to revert these changes + const changes = []; + const reverts = []; + const registerChange = (change, revert) => { + changes.push(change); + reverts.push(revert); + }; + const contextCache = {}; + let newSelection = tr.selection; + tr.changes.iterChanges((fromA, toA, fromB, toB, inserted) => { + const insertedText = inserted.sliceString(0, 0 + inserted.length); + const matchedRules = this.inputRuleMap[insertedText]; + if (!matchedRules) { + return; + } + for (let rule of matchedRules) { + // If we're in a codeblock, etc, return early, no need to continue checking + if (!canPerformReplacement(fromA)) + return; + // Grab and cache three chars before the one being inserted + if (contextCache[fromA] === undefined) { + contextCache[fromA] = tr.newDoc.sliceString(fromB - 3, fromB); + } + const context = contextCache[fromA]; + if (!rule.contextMatch.test(context)) { + continue; + } + const insert = typeof rule.to === "string" ? rule.to : rule.to(this.settings); + const replacementLength = rule.from.length - rule.trigger.length; + const insertionPoint = fromA - replacementLength; + const reversionPoint = fromB - replacementLength; + registerChange({ + from: insertionPoint, + to: insertionPoint + replacementLength, + insert, + }, { + from: reversionPoint, + to: reversionPoint + insert.length, + insert: rule.from, + }); + const selectionAdjustment = rule.from.length - insert.length; + newSelection = state.EditorSelection.create(newSelection.ranges.map((r) => state.EditorSelection.range(r.anchor - selectionAdjustment, r.head - selectionAdjustment))); + return; + } + }, false); + // If we have any changes, construct a transaction spec + if (changes.length) { + return [ + { + effects: storeTransaction.of({ + effects: storeTransaction.of(null), + selection: tr.selection, + scrollIntoView: tr.scrollIntoView, + changes: reverts, + }), + selection: newSelection, + scrollIntoView: tr.scrollIntoView, + changes, + }, + ]; + } + return tr; + }), + ]); + // Codemirror 5 + this.legacyLastUpdate = new WeakMap(); + this.registerCodeMirror((cm) => { + cm.on("beforeChange", this.beforeChangeHandler); + }); + }); + } + onunload() { + this.legacyLastUpdate = null; + this.app.workspace.iterateCodeMirrors((cm) => { + cm.off("beforeChange", this.beforeChangeHandler); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + this.buildInputRules(); + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.buildInputRules(); + yield this.saveData(this.settings); + }); + } +} +class SmartTypographySettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + new obsidian.Setting(containerEl) + .setName("Curly Quotes") + .setDesc("Double and single quotes will be converted to curly quotes (“” & ‘’)") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.curlyQuotes) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.curlyQuotes = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Open double quote character") + .addText((text) => { + text + .setValue(this.plugin.settings.openDouble) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.openDouble = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Close double quote character") + .addText((text) => { + text + .setValue(this.plugin.settings.closeDouble) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.closeDouble = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Open single quote character") + .addText((text) => { + text + .setValue(this.plugin.settings.openSingle) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.openSingle = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Close single quote character") + .addText((text) => { + text + .setValue(this.plugin.settings.closeSingle) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.closeSingle = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Dashes") + .setDesc("Two dashes (--) will be converted to an en-dash (–). And en-dash followed by a dash will be converted to and em-dash (—). An em-dash followed by a dash will be converted into three dashes (---)") + .addToggle((toggle) => { + toggle.setValue(this.plugin.settings.emDash).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.emDash = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Skip en-dash") + .setDesc("When enabled, two dashes will be converted to an em-dash rather than an en-dash.") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.skipEnDash) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.skipEnDash = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Ellipsis") + .setDesc("Three periods (...) will be converted to an ellipses (…)") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.ellipsis) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.ellipsis = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Guillemets") + .setDesc("<< | >> will be converted to « | »") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.guillemets) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.guillemets = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl).setName("Open guillemet").addText((text) => { + text + .setValue(this.plugin.settings.openGuillemet) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + this.plugin.settings.openGuillemet = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl).setName("Close guillemet").addText((text) => { + text + .setValue(this.plugin.settings.closeGuillemet) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + this.plugin.settings.closeGuillemet = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Arrows") + .setDesc("<- | -> will be converted to ← | →") + .addToggle((toggle) => { + toggle.setValue(this.plugin.settings.arrows).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.arrows = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl).setName("Left arrow character").addText((text) => { + text.setValue(this.plugin.settings.leftArrow).onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.leftArrow = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Right arrow character") + .addText((text) => { + text + .setValue(this.plugin.settings.rightArrow) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + if (!value) + return; + if (value.length > 1) { + text.setValue(value[0]); + return; + } + this.plugin.settings.rightArrow = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Comparison") + .setDesc("<= | >= | /= will be converted to ≤ | ≥ | ≠") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.comparisons) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.comparisons = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Fractions") + .setDesc("1/2 will be converted to ½. Supported UTF-8 fractions: ½, ⅓, ⅔, ¼, ¾, ⅕, ⅖, ⅗, ⅘, ⅙, ⅚, ⅐, ⅛, ⅜, ⅝, ⅞, ⅑, ⅒") + .addToggle((toggle) => { + toggle + .setValue(this.plugin.settings.fractions) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.fractions = value; + yield this.plugin.saveSettings(); + })); + }); + } +} +const ignoreListRegEx = /frontmatter|code|math|templater|hashtag/; +function shouldCheckTextAtPos(instance, pos) { + // Empty line + if (!instance.getLine(pos.line)) { + return true; + } + const tokens = instance.getTokenTypeAt(pos); + // Plain text line + if (!tokens) { + return true; + } + // Not codeblock or frontmatter + if (!ignoreListRegEx.test(tokens)) { + return true; + } + return false; +} + +module.exports = SmartTypography; diff --git a/notes/.obsidian/plugins/obsidian-smart-typography/manifest.json b/notes/.obsidian/plugins/obsidian-smart-typography/manifest.json new file mode 100644 index 0000000..bbbb76b --- /dev/null +++ b/notes/.obsidian/plugins/obsidian-smart-typography/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-smart-typography", + "name": "Smart Typography", + "version": "1.0.18", + "minAppVersion": "0.15.0", + "description": "Converts quotes to curly quotes, dashes to em dashes, and periods to ellipses", + "author": "mgmeyers", + "authorUrl": "https://github.com/mgmeyers/obsidian-smart-typography", + "isDesktopOnly": false +} diff --git a/notes/.obsidian/plugins/various-complements/main.js b/notes/.obsidian/plugins/various-complements/main.js new file mode 100644 index 0000000..6e0309f --- /dev/null +++ b/notes/.obsidian/plugins/various-complements/main.js @@ -0,0 +1,6230 @@ +'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 __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +const regEmoji = new RegExp(/[\u2700-\u27BF]|[\uE000-\uF8FF]|\uD83C[\uDC00-\uDFFF]|\uD83D[\uDC00-\uDFFF]|[\u2011-\u26FF]|\uD83E[\uDD10-\uDDFF]|[\uFE0E-\uFE0F]/, "g"); +function allAlphabets(text) { + return Boolean(text.match(/^[a-zA-Z0-9_-]+$/)); +} +function excludeEmoji(text) { + return text.replace(regEmoji, ""); +} +function lowerIncludes(one, other) { + return one.toLowerCase().includes(other.toLowerCase()); +} +function lowerStartsWith(a, b) { + return a.toLowerCase().startsWith(b.toLowerCase()); +} +function capitalizeFirstLetter(str) { + return str.charAt(0).toUpperCase() + str.slice(1); +} +function startsSmallLetterOnlyFirst(str) { + return Boolean(str.match(/^[A-Z][^A-Z]+$/)); +} +function* splitRaw(text, regexp) { + let previousIndex = 0; + for (let r of text.matchAll(regexp)) { + if (previousIndex !== r.index) { + yield text.slice(previousIndex, r.index); + } + yield text[r.index]; + previousIndex = r.index + 1; + } + if (previousIndex !== text.length) { + yield text.slice(previousIndex, text.length); + } +} + +function pickTokens(content, trimPattern) { + return content.split(trimPattern).filter((x) => x !== ""); +} +const TRIM_CHAR_PATTERN = /[\n\t\[\]$/:?!=()<>"'.,|;*~ `]/g; +class DefaultTokenizer { + tokenize(content, raw) { + return raw + ? Array.from(splitRaw(content, this.getTrimPattern())).filter((x) => x !== " ") + : pickTokens(content, this.getTrimPattern()); + } + recursiveTokenize(content) { + const trimIndexes = Array.from(content.matchAll(this.getTrimPattern())) + .sort((a, b) => a.index - b.index) + .map((x) => x.index); + return [ + { word: content, offset: 0 }, + ...trimIndexes.map((i) => ({ + word: content.slice(i + 1), + offset: i + 1, + })), + ]; + } + getTrimPattern() { + return TRIM_CHAR_PATTERN; + } + shouldIgnoreOnCurrent(str) { + return false; + } +} + +const ARABIC_TRIM_CHAR_PATTERN = /[\n\t\[\]$/:?!=()<>"'.,|;*~ `،؛]/g; +class ArabicTokenizer extends DefaultTokenizer { + getTrimPattern() { + return ARABIC_TRIM_CHAR_PATTERN; + } +} + +// @ts-nocheck +// Because this code is originally javascript code. +// noinspection FunctionTooLongJS,FunctionWithMultipleLoopsJS,EqualityComparisonWithCoercionJS,PointlessBooleanExpressionJS,JSDeclarationsAtScopeStart +// TinySegmenter 0.1 -- Super compact Japanese tokenizer in Javascript +// (c) 2008 Taku Kudo +// TinySegmenter is freely distributable under the terms of a new BSD licence. +// For details, see http://chasen.org/~taku/software/TinySegmenter/LICENCE.txt +function TinySegmenter() { + var patterns = { + "[一二三四五六七八九十百千万億兆]": "M", + "[一-龠々〆ヵヶ]": "H", + "[ぁ-ん]": "I", + "[ァ-ヴーｱ-ﾝﾞｰ]": "K", + "[a-zA-Zａ-ｚＡ-Ｚ]": "A", + "[0-9０-９]": "N", + }; + this.chartype_ = []; + for (var i in patterns) { + var regexp = new RegExp(); + regexp.compile(i); + this.chartype_.push([regexp, patterns[i]]); + } + this.BIAS__ = -332; + this.BC1__ = { HH: 6, II: 2461, KH: 406, OH: -1378 }; + this.BC2__ = { + AA: -3267, + AI: 2744, + AN: -878, + HH: -4070, + HM: -1711, + HN: 4012, + HO: 3761, + IA: 1327, + IH: -1184, + II: -1332, + IK: 1721, + IO: 5492, + KI: 3831, + KK: -8741, + MH: -3132, + MK: 3334, + OO: -2920, + }; + this.BC3__ = { + HH: 996, + HI: 626, + HK: -721, + HN: -1307, + HO: -836, + IH: -301, + KK: 2762, + MK: 1079, + MM: 4034, + OA: -1652, + OH: 266, + }; + this.BP1__ = { BB: 295, OB: 304, OO: -125, UB: 352 }; + this.BP2__ = { BO: 60, OO: -1762 }; + this.BQ1__ = { + BHH: 1150, + BHM: 1521, + BII: -1158, + BIM: 886, + BMH: 1208, + BNH: 449, + BOH: -91, + BOO: -2597, + OHI: 451, + OIH: -296, + OKA: 1851, + OKH: -1020, + OKK: 904, + OOO: 2965, + }; + this.BQ2__ = { + BHH: 118, + BHI: -1159, + BHM: 466, + BIH: -919, + BKK: -1720, + BKO: 864, + OHH: -1139, + OHM: -181, + OIH: 153, + UHI: -1146, + }; + this.BQ3__ = { + BHH: -792, + BHI: 2664, + BII: -299, + BKI: 419, + BMH: 937, + BMM: 8335, + BNN: 998, + BOH: 775, + OHH: 2174, + OHM: 439, + OII: 280, + OKH: 1798, + OKI: -793, + OKO: -2242, + OMH: -2402, + OOO: 11699, + }; + this.BQ4__ = { + BHH: -3895, + BIH: 3761, + BII: -4654, + BIK: 1348, + BKK: -1806, + BMI: -3385, + BOO: -12396, + OAH: 926, + OHH: 266, + OHK: -2036, + ONN: -973, + }; + this.BW1__ = { + ",と": 660, + ",同": 727, + B1あ: 1404, + B1同: 542, + "、と": 660, + "、同": 727, + "」と": 1682, + あっ: 1505, + いう: 1743, + いっ: -2055, + いる: 672, + うし: -4817, + うん: 665, + から: 3472, + がら: 600, + こう: -790, + こと: 2083, + こん: -1262, + さら: -4143, + さん: 4573, + した: 2641, + して: 1104, + すで: -3399, + そこ: 1977, + それ: -871, + たち: 1122, + ため: 601, + った: 3463, + つい: -802, + てい: 805, + てき: 1249, + でき: 1127, + です: 3445, + では: 844, + とい: -4915, + とみ: 1922, + どこ: 3887, + ない: 5713, + なっ: 3015, + など: 7379, + なん: -1113, + にし: 2468, + には: 1498, + にも: 1671, + に対: -912, + の一: -501, + の中: 741, + ませ: 2448, + まで: 1711, + まま: 2600, + まる: -2155, + やむ: -1947, + よっ: -2565, + れた: 2369, + れで: -913, + をし: 1860, + を見: 731, + 亡く: -1886, + 京都: 2558, + 取り: -2784, + 大き: -2604, + 大阪: 1497, + 平方: -2314, + 引き: -1336, + 日本: -195, + 本当: -2423, + 毎日: -2113, + 目指: -724, + Ｂ１あ: 1404, + Ｂ１同: 542, + "｣と": 1682, + }; + this.BW2__ = { + "..": -11822, + 11: -669, + "――": -5730, + "−−": -13175, + いう: -1609, + うか: 2490, + かし: -1350, + かも: -602, + から: -7194, + かれ: 4612, + がい: 853, + がら: -3198, + きた: 1941, + くな: -1597, + こと: -8392, + この: -4193, + させ: 4533, + され: 13168, + さん: -3977, + しい: -1819, + しか: -545, + した: 5078, + して: 972, + しな: 939, + その: -3744, + たい: -1253, + たた: -662, + ただ: -3857, + たち: -786, + たと: 1224, + たは: -939, + った: 4589, + って: 1647, + っと: -2094, + てい: 6144, + てき: 3640, + てく: 2551, + ては: -3110, + ても: -3065, + でい: 2666, + でき: -1528, + でし: -3828, + です: -4761, + でも: -4203, + とい: 1890, + とこ: -1746, + とと: -2279, + との: 720, + とみ: 5168, + とも: -3941, + ない: -2488, + なが: -1313, + など: -6509, + なの: 2614, + なん: 3099, + にお: -1615, + にし: 2748, + にな: 2454, + によ: -7236, + に対: -14943, + に従: -4688, + に関: -11388, + のか: 2093, + ので: -7059, + のに: -6041, + のの: -6125, + はい: 1073, + はが: -1033, + はず: -2532, + ばれ: 1813, + まし: -1316, + まで: -6621, + まれ: 5409, + めて: -3153, + もい: 2230, + もの: -10713, + らか: -944, + らし: -1611, + らに: -1897, + りし: 651, + りま: 1620, + れた: 4270, + れて: 849, + れば: 4114, + ろう: 6067, + われ: 7901, + を通: -11877, + んだ: 728, + んな: -4115, + 一人: 602, + 一方: -1375, + 一日: 970, + 一部: -1051, + 上が: -4479, + 会社: -1116, + 出て: 2163, + 分の: -7758, + 同党: 970, + 同日: -913, + 大阪: -2471, + 委員: -1250, + 少な: -1050, + 年度: -8669, + 年間: -1626, + 府県: -2363, + 手権: -1982, + 新聞: -4066, + 日新: -722, + 日本: -7068, + 日米: 3372, + 曜日: -601, + 朝鮮: -2355, + 本人: -2697, + 東京: -1543, + 然と: -1384, + 社会: -1276, + 立て: -990, + 第に: -1612, + 米国: -4268, + "１１": -669, + }; + this.BW3__ = { + あた: -2194, + あり: 719, + ある: 3846, + "い.": -1185, + "い。": -1185, + いい: 5308, + いえ: 2079, + いく: 3029, + いた: 2056, + いっ: 1883, + いる: 5600, + いわ: 1527, + うち: 1117, + うと: 4798, + えと: 1454, + "か.": 2857, + "か。": 2857, + かけ: -743, + かっ: -4098, + かに: -669, + から: 6520, + かり: -2670, + "が,": 1816, + "が、": 1816, + がき: -4855, + がけ: -1127, + がっ: -913, + がら: -4977, + がり: -2064, + きた: 1645, + けど: 1374, + こと: 7397, + この: 1542, + ころ: -2757, + さい: -714, + さを: 976, + "し,": 1557, + "し、": 1557, + しい: -3714, + した: 3562, + して: 1449, + しな: 2608, + しま: 1200, + "す.": -1310, + "す。": -1310, + する: 6521, + "ず,": 3426, + "ず、": 3426, + ずに: 841, + そう: 428, + "た.": 8875, + "た。": 8875, + たい: -594, + たの: 812, + たり: -1183, + たる: -853, + "だ.": 4098, + "だ。": 4098, + だっ: 1004, + った: -4748, + って: 300, + てい: 6240, + てお: 855, + ても: 302, + です: 1437, + でに: -1482, + では: 2295, + とう: -1387, + とし: 2266, + との: 541, + とも: -3543, + どう: 4664, + ない: 1796, + なく: -903, + など: 2135, + "に,": -1021, + "に、": -1021, + にし: 1771, + にな: 1906, + には: 2644, + "の,": -724, + "の、": -724, + の子: -1000, + "は,": 1337, + "は、": 1337, + べき: 2181, + まし: 1113, + ます: 6943, + まっ: -1549, + まで: 6154, + まれ: -793, + らし: 1479, + られ: 6820, + るる: 3818, + "れ,": 854, + "れ、": 854, + れた: 1850, + れて: 1375, + れば: -3246, + れる: 1091, + われ: -605, + んだ: 606, + んで: 798, + カ月: 990, + 会議: 860, + 入り: 1232, + 大会: 2217, + 始め: 1681, + 市: 965, + 新聞: -5055, + "日,": 974, + "日、": 974, + 社会: 2024, + ｶ月: 990, + }; + this.TC1__ = { + AAA: 1093, + HHH: 1029, + HHM: 580, + HII: 998, + HOH: -390, + HOM: -331, + IHI: 1169, + IOH: -142, + IOI: -1015, + IOM: 467, + MMH: 187, + OOI: -1832, + }; + this.TC2__ = { + HHO: 2088, + HII: -1023, + HMM: -1154, + IHI: -1965, + KKH: 703, + OII: -2649, + }; + this.TC3__ = { + AAA: -294, + HHH: 346, + HHI: -341, + HII: -1088, + HIK: 731, + HOH: -1486, + IHH: 128, + IHI: -3041, + IHO: -1935, + IIH: -825, + IIM: -1035, + IOI: -542, + KHH: -1216, + KKA: 491, + KKH: -1217, + KOK: -1009, + MHH: -2694, + MHM: -457, + MHO: 123, + MMH: -471, + NNH: -1689, + NNO: 662, + OHO: -3393, + }; + this.TC4__ = { + HHH: -203, + HHI: 1344, + HHK: 365, + HHM: -122, + HHN: 182, + HHO: 669, + HIH: 804, + HII: 679, + HOH: 446, + IHH: 695, + IHO: -2324, + IIH: 321, + III: 1497, + IIO: 656, + IOO: 54, + KAK: 4845, + KKA: 3386, + KKK: 3065, + MHH: -405, + MHI: 201, + MMH: -241, + MMM: 661, + MOM: 841, + }; + this.TQ1__ = { + BHHH: -227, + BHHI: 316, + BHIH: -132, + BIHH: 60, + BIII: 1595, + BNHH: -744, + BOHH: 225, + BOOO: -908, + OAKK: 482, + OHHH: 281, + OHIH: 249, + OIHI: 200, + OIIH: -68, + }; + this.TQ2__ = { BIHH: -1401, BIII: -1033, BKAK: -543, BOOO: -5591 }; + this.TQ3__ = { + BHHH: 478, + BHHM: -1073, + BHIH: 222, + BHII: -504, + BIIH: -116, + BIII: -105, + BMHI: -863, + BMHM: -464, + BOMH: 620, + OHHH: 346, + OHHI: 1729, + OHII: 997, + OHMH: 481, + OIHH: 623, + OIIH: 1344, + OKAK: 2792, + OKHH: 587, + OKKA: 679, + OOHH: 110, + OOII: -685, + }; + this.TQ4__ = { + BHHH: -721, + BHHM: -3604, + BHII: -966, + BIIH: -607, + BIII: -2181, + OAAA: -2763, + OAKK: 180, + OHHH: -294, + OHHI: 2446, + OHHO: 480, + OHIH: -1573, + OIHH: 1935, + OIHI: -493, + OIIH: 626, + OIII: -4007, + OKAK: -8156, + }; + this.TW1__ = { につい: -4681, 東京都: 2026 }; + this.TW2__ = { + ある程: -2049, + いった: -1256, + ころが: -2434, + しょう: 3873, + その後: -4430, + だって: -1049, + ていた: 1833, + として: -4657, + ともに: -4517, + もので: 1882, + 一気に: -792, + 初めて: -1512, + 同時に: -8097, + 大きな: -1255, + 対して: -2721, + 社会党: -3216, + }; + this.TW3__ = { + いただ: -1734, + してい: 1314, + として: -4314, + につい: -5483, + にとっ: -5989, + に当た: -6247, + "ので,": -727, + "ので、": -727, + のもの: -600, + れから: -3752, + 十二月: -2287, + }; + this.TW4__ = { + "いう.": 8576, + "いう。": 8576, + からな: -2348, + してい: 2958, + "たが,": 1516, + "たが、": 1516, + ている: 1538, + という: 1349, + ました: 5543, + ません: 1097, + ようと: -4258, + よると: 5865, + }; + this.UC1__ = { A: 484, K: 93, M: 645, O: -505 }; + this.UC2__ = { A: 819, H: 1059, I: 409, M: 3987, N: 5775, O: 646 }; + this.UC3__ = { A: -1370, I: 2311 }; + this.UC4__ = { + A: -2643, + H: 1809, + I: -1032, + K: -3450, + M: 3565, + N: 3876, + O: 6646, + }; + this.UC5__ = { H: 313, I: -1238, K: -799, M: 539, O: -831 }; + this.UC6__ = { H: -506, I: -253, K: 87, M: 247, O: -387 }; + this.UP1__ = { O: -214 }; + this.UP2__ = { B: 69, O: 935 }; + this.UP3__ = { B: 189 }; + this.UQ1__ = { + BH: 21, + BI: -12, + BK: -99, + BN: 142, + BO: -56, + OH: -95, + OI: 477, + OK: 410, + OO: -2422, + }; + this.UQ2__ = { BH: 216, BI: 113, OK: 1759 }; + this.UQ3__ = { + BA: -479, + BH: 42, + BI: 1913, + BK: -7198, + BM: 3160, + BN: 6427, + BO: 14761, + OI: -827, + ON: -3212, + }; + this.UW1__ = { + ",": 156, + "、": 156, + "「": -463, + あ: -941, + う: -127, + が: -553, + き: 121, + こ: 505, + で: -201, + と: -547, + ど: -123, + に: -789, + の: -185, + は: -847, + も: -466, + や: -470, + よ: 182, + ら: -292, + り: 208, + れ: 169, + を: -446, + ん: -137, + "・": -135, + 主: -402, + 京: -268, + 区: -912, + 午: 871, + 国: -460, + 大: 561, + 委: 729, + 市: -411, + 日: -141, + 理: 361, + 生: -408, + 県: -386, + 都: -718, + "｢": -463, + "･": -135, + }; + this.UW2__ = { + ",": -829, + "、": -829, + 〇: 892, + "「": -645, + "」": 3145, + あ: -538, + い: 505, + う: 134, + お: -502, + か: 1454, + が: -856, + く: -412, + こ: 1141, + さ: 878, + ざ: 540, + し: 1529, + す: -675, + せ: 300, + そ: -1011, + た: 188, + だ: 1837, + つ: -949, + て: -291, + で: -268, + と: -981, + ど: 1273, + な: 1063, + に: -1764, + の: 130, + は: -409, + ひ: -1273, + べ: 1261, + ま: 600, + も: -1263, + や: -402, + よ: 1639, + り: -579, + る: -694, + れ: 571, + を: -2516, + ん: 2095, + ア: -587, + カ: 306, + キ: 568, + ッ: 831, + 三: -758, + 不: -2150, + 世: -302, + 中: -968, + 主: -861, + 事: 492, + 人: -123, + 会: 978, + 保: 362, + 入: 548, + 初: -3025, + 副: -1566, + 北: -3414, + 区: -422, + 大: -1769, + 天: -865, + 太: -483, + 子: -1519, + 学: 760, + 実: 1023, + 小: -2009, + 市: -813, + 年: -1060, + 強: 1067, + 手: -1519, + 揺: -1033, + 政: 1522, + 文: -1355, + 新: -1682, + 日: -1815, + 明: -1462, + 最: -630, + 朝: -1843, + 本: -1650, + 東: -931, + 果: -665, + 次: -2378, + 民: -180, + 気: -1740, + 理: 752, + 発: 529, + 目: -1584, + 相: -242, + 県: -1165, + 立: -763, + 第: 810, + 米: 509, + 自: -1353, + 行: 838, + 西: -744, + 見: -3874, + 調: 1010, + 議: 1198, + 込: 3041, + 開: 1758, + 間: -1257, + "｢": -645, + "｣": 3145, + ｯ: 831, + ｱ: -587, + ｶ: 306, + ｷ: 568, + }; + this.UW3__ = { + ",": 4889, + 1: -800, + "−": -1723, + "、": 4889, + 々: -2311, + 〇: 5827, + "」": 2670, + "〓": -3573, + あ: -2696, + い: 1006, + う: 2342, + え: 1983, + お: -4864, + か: -1163, + が: 3271, + く: 1004, + け: 388, + げ: 401, + こ: -3552, + ご: -3116, + さ: -1058, + し: -395, + す: 584, + せ: 3685, + そ: -5228, + た: 842, + ち: -521, + っ: -1444, + つ: -1081, + て: 6167, + で: 2318, + と: 1691, + ど: -899, + な: -2788, + に: 2745, + の: 4056, + は: 4555, + ひ: -2171, + ふ: -1798, + へ: 1199, + ほ: -5516, + ま: -4384, + み: -120, + め: 1205, + も: 2323, + や: -788, + よ: -202, + ら: 727, + り: 649, + る: 5905, + れ: 2773, + わ: -1207, + を: 6620, + ん: -518, + ア: 551, + グ: 1319, + ス: 874, + ッ: -1350, + ト: 521, + ム: 1109, + ル: 1591, + ロ: 2201, + ン: 278, + "・": -3794, + 一: -1619, + 下: -1759, + 世: -2087, + 両: 3815, + 中: 653, + 主: -758, + 予: -1193, + 二: 974, + 人: 2742, + 今: 792, + 他: 1889, + 以: -1368, + 低: 811, + 何: 4265, + 作: -361, + 保: -2439, + 元: 4858, + 党: 3593, + 全: 1574, + 公: -3030, + 六: 755, + 共: -1880, + 円: 5807, + 再: 3095, + 分: 457, + 初: 2475, + 別: 1129, + 前: 2286, + 副: 4437, + 力: 365, + 動: -949, + 務: -1872, + 化: 1327, + 北: -1038, + 区: 4646, + 千: -2309, + 午: -783, + 協: -1006, + 口: 483, + 右: 1233, + 各: 3588, + 合: -241, + 同: 3906, + 和: -837, + 員: 4513, + 国: 642, + 型: 1389, + 場: 1219, + 外: -241, + 妻: 2016, + 学: -1356, + 安: -423, + 実: -1008, + 家: 1078, + 小: -513, + 少: -3102, + 州: 1155, + 市: 3197, + 平: -1804, + 年: 2416, + 広: -1030, + 府: 1605, + 度: 1452, + 建: -2352, + 当: -3885, + 得: 1905, + 思: -1291, + 性: 1822, + 戸: -488, + 指: -3973, + 政: -2013, + 教: -1479, + 数: 3222, + 文: -1489, + 新: 1764, + 日: 2099, + 旧: 5792, + 昨: -661, + 時: -1248, + 曜: -951, + 最: -937, + 月: 4125, + 期: 360, + 李: 3094, + 村: 364, + 東: -805, + 核: 5156, + 森: 2438, + 業: 484, + 氏: 2613, + 民: -1694, + 決: -1073, + 法: 1868, + 海: -495, + 無: 979, + 物: 461, + 特: -3850, + 生: -273, + 用: 914, + 町: 1215, + 的: 7313, + 直: -1835, + 省: 792, + 県: 6293, + 知: -1528, + 私: 4231, + 税: 401, + 立: -960, + 第: 1201, + 米: 7767, + 系: 3066, + 約: 3663, + 級: 1384, + 統: -4229, + 総: 1163, + 線: 1255, + 者: 6457, + 能: 725, + 自: -2869, + 英: 785, + 見: 1044, + 調: -562, + 財: -733, + 費: 1777, + 車: 1835, + 軍: 1375, + 込: -1504, + 通: -1136, + 選: -681, + 郎: 1026, + 郡: 4404, + 部: 1200, + 金: 2163, + 長: 421, + 開: -1432, + 間: 1302, + 関: -1282, + 雨: 2009, + 電: -1045, + 非: 2066, + 駅: 1620, + "１": -800, + "｣": 2670, + "･": -3794, + ｯ: -1350, + ｱ: 551, + ｸﾞ: 1319, + ｽ: 874, + ﾄ: 521, + ﾑ: 1109, + ﾙ: 1591, + ﾛ: 2201, + ﾝ: 278, + }; + this.UW4__ = { + ",": 3930, + ".": 3508, + "―": -4841, + "、": 3930, + "。": 3508, + 〇: 4999, + "「": 1895, + "」": 3798, + "〓": -5156, + あ: 4752, + い: -3435, + う: -640, + え: -2514, + お: 2405, + か: 530, + が: 6006, + き: -4482, + ぎ: -3821, + く: -3788, + け: -4376, + げ: -4734, + こ: 2255, + ご: 1979, + さ: 2864, + し: -843, + じ: -2506, + す: -731, + ず: 1251, + せ: 181, + そ: 4091, + た: 5034, + だ: 5408, + ち: -3654, + っ: -5882, + つ: -1659, + て: 3994, + で: 7410, + と: 4547, + な: 5433, + に: 6499, + ぬ: 1853, + ね: 1413, + の: 7396, + は: 8578, + ば: 1940, + ひ: 4249, + び: -4134, + ふ: 1345, + へ: 6665, + べ: -744, + ほ: 1464, + ま: 1051, + み: -2082, + む: -882, + め: -5046, + も: 4169, + ゃ: -2666, + や: 2795, + ょ: -1544, + よ: 3351, + ら: -2922, + り: -9726, + る: -14896, + れ: -2613, + ろ: -4570, + わ: -1783, + を: 13150, + ん: -2352, + カ: 2145, + コ: 1789, + セ: 1287, + ッ: -724, + ト: -403, + メ: -1635, + ラ: -881, + リ: -541, + ル: -856, + ン: -3637, + "・": -4371, + ー: -11870, + 一: -2069, + 中: 2210, + 予: 782, + 事: -190, + 井: -1768, + 人: 1036, + 以: 544, + 会: 950, + 体: -1286, + 作: 530, + 側: 4292, + 先: 601, + 党: -2006, + 共: -1212, + 内: 584, + 円: 788, + 初: 1347, + 前: 1623, + 副: 3879, + 力: -302, + 動: -740, + 務: -2715, + 化: 776, + 区: 4517, + 協: 1013, + 参: 1555, + 合: -1834, + 和: -681, + 員: -910, + 器: -851, + 回: 1500, + 国: -619, + 園: -1200, + 地: 866, + 場: -1410, + 塁: -2094, + 士: -1413, + 多: 1067, + 大: 571, + 子: -4802, + 学: -1397, + 定: -1057, + 寺: -809, + 小: 1910, + 屋: -1328, + 山: -1500, + 島: -2056, + 川: -2667, + 市: 2771, + 年: 374, + 庁: -4556, + 後: 456, + 性: 553, + 感: 916, + 所: -1566, + 支: 856, + 改: 787, + 政: 2182, + 教: 704, + 文: 522, + 方: -856, + 日: 1798, + 時: 1829, + 最: 845, + 月: -9066, + 木: -485, + 来: -442, + 校: -360, + 業: -1043, + 氏: 5388, + 民: -2716, + 気: -910, + 沢: -939, + 済: -543, + 物: -735, + 率: 672, + 球: -1267, + 生: -1286, + 産: -1101, + 田: -2900, + 町: 1826, + 的: 2586, + 目: 922, + 省: -3485, + 県: 2997, + 空: -867, + 立: -2112, + 第: 788, + 米: 2937, + 系: 786, + 約: 2171, + 経: 1146, + 統: -1169, + 総: 940, + 線: -994, + 署: 749, + 者: 2145, + 能: -730, + 般: -852, + 行: -792, + 規: 792, + 警: -1184, + 議: -244, + 谷: -1000, + 賞: 730, + 車: -1481, + 軍: 1158, + 輪: -1433, + 込: -3370, + 近: 929, + 道: -1291, + 選: 2596, + 郎: -4866, + 都: 1192, + 野: -1100, + 銀: -2213, + 長: 357, + 間: -2344, + 院: -2297, + 際: -2604, + 電: -878, + 領: -1659, + 題: -792, + 館: -1984, + 首: 1749, + 高: 2120, + "｢": 1895, + "｣": 3798, + "･": -4371, + ｯ: -724, + ｰ: -11870, + ｶ: 2145, + ｺ: 1789, + ｾ: 1287, + ﾄ: -403, + ﾒ: -1635, + ﾗ: -881, + ﾘ: -541, + ﾙ: -856, + ﾝ: -3637, + }; + this.UW5__ = { + ",": 465, + ".": -299, + 1: -514, + E2: -32768, + "]": -2762, + "、": 465, + "。": -299, + "「": 363, + あ: 1655, + い: 331, + う: -503, + え: 1199, + お: 527, + か: 647, + が: -421, + き: 1624, + ぎ: 1971, + く: 312, + げ: -983, + さ: -1537, + し: -1371, + す: -852, + だ: -1186, + ち: 1093, + っ: 52, + つ: 921, + て: -18, + で: -850, + と: -127, + ど: 1682, + な: -787, + に: -1224, + の: -635, + は: -578, + べ: 1001, + み: 502, + め: 865, + ゃ: 3350, + ょ: 854, + り: -208, + る: 429, + れ: 504, + わ: 419, + を: -1264, + ん: 327, + イ: 241, + ル: 451, + ン: -343, + 中: -871, + 京: 722, + 会: -1153, + 党: -654, + 務: 3519, + 区: -901, + 告: 848, + 員: 2104, + 大: -1296, + 学: -548, + 定: 1785, + 嵐: -1304, + 市: -2991, + 席: 921, + 年: 1763, + 思: 872, + 所: -814, + 挙: 1618, + 新: -1682, + 日: 218, + 月: -4353, + 査: 932, + 格: 1356, + 機: -1508, + 氏: -1347, + 田: 240, + 町: -3912, + 的: -3149, + 相: 1319, + 省: -1052, + 県: -4003, + 研: -997, + 社: -278, + 空: -813, + 統: 1955, + 者: -2233, + 表: 663, + 語: -1073, + 議: 1219, + 選: -1018, + 郎: -368, + 長: 786, + 間: 1191, + 題: 2368, + 館: -689, + "１": -514, + Ｅ２: -32768, + "｢": 363, + ｲ: 241, + ﾙ: 451, + ﾝ: -343, + }; + this.UW6__ = { + ",": 227, + ".": 808, + 1: -270, + E1: 306, + "、": 227, + "。": 808, + あ: -307, + う: 189, + か: 241, + が: -73, + く: -121, + こ: -200, + じ: 1782, + す: 383, + た: -428, + っ: 573, + て: -1014, + で: 101, + と: -105, + な: -253, + に: -149, + の: -417, + は: -236, + も: -206, + り: 187, + る: -135, + を: 195, + ル: -673, + ン: -496, + 一: -277, + 中: 201, + 件: -800, + 会: 624, + 前: 302, + 区: 1792, + 員: -1212, + 委: 798, + 学: -960, + 市: 887, + 広: -695, + 後: 535, + 業: -697, + 相: 753, + 社: -507, + 福: 974, + 空: -822, + 者: 1811, + 連: 463, + 郎: 1082, + "１": -270, + Ｅ１: 306, + ﾙ: -673, + ﾝ: -496, + }; + return this; +} +TinySegmenter.prototype.ctype_ = function (str) { + for (var i in this.chartype_) { + if (str.match(this.chartype_[i][0])) { + return this.chartype_[i][1]; + } + } + return "O"; +}; +TinySegmenter.prototype.ts_ = function (v) { + if (v) { + return v; + } + return 0; +}; +TinySegmenter.prototype.segment = function (input) { + if (input == null || input == undefined || input == "") { + return []; + } + var result = []; + var seg = ["B3", "B2", "B1"]; + var ctype = ["O", "O", "O"]; + var o = input.split(""); + for (i = 0; i < o.length; ++i) { + seg.push(o[i]); + ctype.push(this.ctype_(o[i])); + } + seg.push("E1"); + seg.push("E2"); + seg.push("E3"); + ctype.push("O"); + ctype.push("O"); + ctype.push("O"); + var word = seg[3]; + var p1 = "U"; + var p2 = "U"; + var p3 = "U"; + for (var i = 4; i < seg.length - 3; ++i) { + var score = this.BIAS__; + var w1 = seg[i - 3]; + var w2 = seg[i - 2]; + var w3 = seg[i - 1]; + var w4 = seg[i]; + var w5 = seg[i + 1]; + var w6 = seg[i + 2]; + var c1 = ctype[i - 3]; + var c2 = ctype[i - 2]; + var c3 = ctype[i - 1]; + var c4 = ctype[i]; + var c5 = ctype[i + 1]; + var c6 = ctype[i + 2]; + score += this.ts_(this.UP1__[p1]); + score += this.ts_(this.UP2__[p2]); + score += this.ts_(this.UP3__[p3]); + score += this.ts_(this.BP1__[p1 + p2]); + score += this.ts_(this.BP2__[p2 + p3]); + score += this.ts_(this.UW1__[w1]); + score += this.ts_(this.UW2__[w2]); + score += this.ts_(this.UW3__[w3]); + score += this.ts_(this.UW4__[w4]); + score += this.ts_(this.UW5__[w5]); + score += this.ts_(this.UW6__[w6]); + score += this.ts_(this.BW1__[w2 + w3]); + score += this.ts_(this.BW2__[w3 + w4]); + score += this.ts_(this.BW3__[w4 + w5]); + score += this.ts_(this.TW1__[w1 + w2 + w3]); + score += this.ts_(this.TW2__[w2 + w3 + w4]); + score += this.ts_(this.TW3__[w3 + w4 + w5]); + score += this.ts_(this.TW4__[w4 + w5 + w6]); + score += this.ts_(this.UC1__[c1]); + score += this.ts_(this.UC2__[c2]); + score += this.ts_(this.UC3__[c3]); + score += this.ts_(this.UC4__[c4]); + score += this.ts_(this.UC5__[c5]); + score += this.ts_(this.UC6__[c6]); + score += this.ts_(this.BC1__[c2 + c3]); + score += this.ts_(this.BC2__[c3 + c4]); + score += this.ts_(this.BC3__[c4 + c5]); + score += this.ts_(this.TC1__[c1 + c2 + c3]); + score += this.ts_(this.TC2__[c2 + c3 + c4]); + score += this.ts_(this.TC3__[c3 + c4 + c5]); + score += this.ts_(this.TC4__[c4 + c5 + c6]); + // score += this.ts_(this.TC5__[c4 + c5 + c6]); + score += this.ts_(this.UQ1__[p1 + c1]); + score += this.ts_(this.UQ2__[p2 + c2]); + score += this.ts_(this.UQ3__[p3 + c3]); + score += this.ts_(this.BQ1__[p2 + c2 + c3]); + score += this.ts_(this.BQ2__[p2 + c3 + c4]); + score += this.ts_(this.BQ3__[p3 + c2 + c3]); + score += this.ts_(this.BQ4__[p3 + c3 + c4]); + score += this.ts_(this.TQ1__[p2 + c1 + c2 + c3]); + score += this.ts_(this.TQ2__[p2 + c2 + c3 + c4]); + score += this.ts_(this.TQ3__[p3 + c1 + c2 + c3]); + score += this.ts_(this.TQ4__[p3 + c2 + c3 + c4]); + var p = "O"; + if (score > 0) { + result.push(word); + word = ""; + p = "B"; + } + p1 = p2; + p2 = p3; + p3 = p; + word += seg[i]; + } + result.push(word); + return result; +}; + +// @ts-ignore +const segmenter = new TinySegmenter(); +function pickTokensAsJapanese(content, trimPattern) { + return content + .split(trimPattern) + .filter((x) => x !== "") + .flatMap((x) => segmenter.segment(x)); +} +/** + * Japanese needs original logic. + */ +class JapaneseTokenizer { + tokenize(content, raw) { + return pickTokensAsJapanese(content, raw ? / /g : this.getTrimPattern()); + } + recursiveTokenize(content) { + const tokens = segmenter + .segment(content) + // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/77 + .flatMap((x) => x === " " ? x : x.split(" ").map((t) => (t === "" ? " " : t))); + const ret = []; + for (let i = 0; i < tokens.length; i++) { + if (i === 0 || + tokens[i].length !== 1 || + !Boolean(tokens[i].match(this.getTrimPattern()))) { + ret.push({ + word: tokens.slice(i).join(""), + offset: tokens.slice(0, i).join("").length, + }); + } + } + return ret; + } + getTrimPattern() { + return TRIM_CHAR_PATTERN; + } + shouldIgnoreOnCurrent(str) { + return Boolean(str.match(/^[ぁ-んａ-ｚＡ-Ｚ。、ー　]*$/)); + } +} + +const ENGLISH_PATTERN = /[a-zA-Z0-9_\-\\]/; +class EnglishOnlyTokenizer extends DefaultTokenizer { + tokenize(content, raw) { + const tokenized = Array.from(this._tokenize(content)).filter((x) => x.word.match(ENGLISH_PATTERN)); + return raw + ? tokenized.map((x) => x.word) + : tokenized + .map((x) => x.word) + .filter((x) => !x.match(this.getTrimPattern())); + } + recursiveTokenize(content) { + const offsets = Array.from(this._tokenize(content)) + .filter((x) => !x.word.match(this.getTrimPattern())) + .map((x) => x.offset); + return [ + ...offsets.map((i) => ({ + word: content.slice(i), + offset: i, + })), + ]; + } + *_tokenize(content) { + let startIndex = 0; + let previousType = "none"; + for (let i = 0; i < content.length; i++) { + if (content[i].match(super.getTrimPattern())) { + yield { word: content.slice(startIndex, i), offset: startIndex }; + previousType = "trim"; + startIndex = i; + continue; + } + if (content[i].match(ENGLISH_PATTERN)) { + if (previousType === "english" || previousType === "none") { + previousType = "english"; + continue; + } + yield { word: content.slice(startIndex, i), offset: startIndex }; + previousType = "english"; + startIndex = i; + continue; + } + if (previousType === "others" || previousType === "none") { + previousType = "others"; + continue; + } + yield { word: content.slice(startIndex, i), offset: startIndex }; + previousType = "others"; + startIndex = i; + } + yield { + word: content.slice(startIndex, content.length), + offset: startIndex, + }; + } +} + +var main = {}; + +var prettifyPinyin = {}; + +// Quick guide for typing Chinese pinyin on Mac OS X + +// Tone 1 (flat) mā – Option + a, then hit a vowel key +// Tone 2 (rising) má – Option + e, then hit a vowel key +// Tone 3 (falling-rising) mǎ – Option + v, then hit a vowel key +// Tone 4 (falling) mà – Option + `, then hit a vowel key + +// ǚ – Option + V, then hit V (submitted by QA) +// ǜ – Option + `, then hit V (submitted by QA) + + +var replacements = { + 'a': ['ā', 'á', 'ǎ', 'à'], + 'e': ['ē', 'é', 'ě', 'è'], + 'u': ['ū', 'ú', 'ǔ', 'ù'], + 'i': ['ī', 'í', 'ǐ', 'ì'], + 'o': ['ō', 'ó', 'ǒ', 'ò'], + 'ü': ['ǖ', 'ǘ', 'ǚ', 'ǜ'] +}; + +var medials = ['i', 'u', 'ü']; + +var prettify$1 = function(str){ + str = str.replace('v', 'ü'); + var syllables = str.split(' '); + + for (var i = 0; i < syllables.length; i++){ + var syllable = syllables[i]; + var tone = parseInt(syllable[syllable.length-1]); + + if (tone <= 0 || tone > 5) { + console.error('invalid tone number:', tone, 'in', syllable); + } else if (tone === 5){ + syllables[i] = syllable.slice(0, syllable.length - 1); + } else { + for (var j = 0; j < syllable.length; j++){ + var currentLetter = syllable[j]; + var nextLetter = syllable[j + 1]; + + // found a vowel + if (replacements[currentLetter]){ + var replaced; + var letterToReplace; + + // two consecutive vowels + if (replacements[nextLetter] && medials.indexOf(currentLetter) >= 0){ + letterToReplace = nextLetter; + } else { + letterToReplace = currentLetter; + } + + replaced = syllable.replace(letterToReplace, replacements[letterToReplace][tone - 1]); + syllables[i] = replaced.slice(0, replaced.length - 1); + break; + } + } + } + + } + return syllables.join(' '); +}; + +prettifyPinyin.prettify = prettify$1; + +class Trie$1 { + constructor() { + this.content = {}; + } + + getKeyObject(key, create = false) { + key = key.toString(); + + let chars = key === '' ? [key] : Array.from(key); + let obj = this.content; + + for (let char of chars) { + if (obj[char] == null) { + if (create) obj[char] = {}; + else return {} + } + + obj = obj[char]; + } + + return obj + } + + get(key) { + let obj = this.getKeyObject(key); + + return obj.values || [] + } + + getPrefix(key) { + let inner = (key, obj = null) => { + if (obj == null) obj = this.getKeyObject(key); + let result = obj.values ? [...obj.values] : []; + + for (let char in obj) { + if (char === 'values' || obj[char] == null) continue + + result.push(...inner(key + char, obj[char])); + } + + return result + }; + + return inner(key) + } + + push(key, value) { + let obj = this.getKeyObject(key, true); + + if (obj.values == null) obj.values = []; + if (!obj.values.includes(value)) obj.values.push(value); + + return this + } +} + +var trie = Trie$1; + +const {prettify} = prettifyPinyin; +const Trie = trie; + +function parseLine(line) { + let match = line.match(/^(\S+)\s(\S+)\s\[([^\]]+)\]\s\/(.+)\//); + if (match == null) return + + let [, traditional, simplified, pinyin, english] = match; + + pinyin = pinyin.replace(/u:/g, 'ü'); + let pinyinPretty = prettify(pinyin); + + return {traditional, simplified, pinyin, pinyinPretty, english} +} + +class Cedict$1 { + load(contents) { + this.simplifiedTrie = new Trie(); + this.traditionalTrie = new Trie(); + + let lines = contents.split('\n'); + + for (let line of lines) { + if (line.trim() === '' || line[0] === '#') continue + + let entry = parseLine(line); + if (entry == null) continue + + this.simplifiedTrie.push(entry.simplified, entry); + this.traditionalTrie.push(entry.traditional, entry); + } + } + + get(word, traditional = false) { + return traditional ? this.traditionalTrie.get(word) : this.simplifiedTrie.get(word) + } + + getPrefix(word, traditional = false) { + return traditional ? this.traditionalTrie.getPrefix(word) : this.simplifiedTrie.getPrefix(word) + } +} + +var cedict = Cedict$1; + +const Cedict = cedict; + +const chinesePunctuation = [ + "·", + "×", + "—", + "‘", + "’", + "“", + "”", + "…", + "、", + "。", + "《", + "》", + "『", + "』", + "【", + "】", + "！", + "（", + "）", + "，", + "：", + "；", + "？", +]; + +main.load = function (contents) { + let dictionary = new Cedict(); + dictionary.load(contents); + + return function tokenize(text) { + text = Array.from(text.replace(/\r/g, "")); + + let result = []; + let i = 0; + let [offset, line, column] = [0, 1, 1]; + let [simplifiedPreference, traditionalPreference] = [0, 0]; + + let pushToken = (word) => { + let simplifiedEntries = dictionary.get(word, false); + let traditionalEntries = dictionary.get(word, true); + + let entries = + simplifiedEntries.length === 0 + ? traditionalEntries + : traditionalEntries.length === 0 + ? simplifiedEntries + : simplifiedPreference < traditionalPreference + ? traditionalEntries + : simplifiedPreference > traditionalPreference + ? simplifiedEntries + : traditionalEntries; + + if (traditionalEntries.length === 0 && simplifiedEntries.length > 0) { + simplifiedPreference++; + } else if ( + simplifiedEntries.length === 0 && + traditionalEntries.length > 0 + ) { + traditionalPreference++; + } + + result.push({ + text: word, + traditional: entries[0] ? entries[0].traditional : word, + simplified: entries[0] ? entries[0].simplified : word, + + position: { + offset, + line, + column, + }, + + matches: entries.map(({ pinyin, pinyinPretty, english }) => ({ + pinyin, + pinyinPretty, + english, + })), + }); + + let wordArr = Array.from(word); + let lastLineBreakIndex = word.lastIndexOf("\n"); + + i += wordArr.length; + offset += word.length; + line += wordArr.filter((x) => x === "\n").length; + column = + lastLineBreakIndex >= 0 + ? word.length - lastLineBreakIndex + : column + word.length; + }; + + while (i < text.length) { + // Try to match two or more characters + + if (i !== text.length - 1) { + let getTwo = text.slice(i, i + 2).join(""); + let simplifiedEntries = dictionary.getPrefix(getTwo, false); + let traditionalEntries = dictionary.getPrefix(getTwo, true); + let foundWord = null; + let foundEntries = null; + + for (let entries of [traditionalEntries, simplifiedEntries]) { + for (let entry of entries) { + let matchText = + entries === traditionalEntries + ? entry.traditional + : entry.simplified; + let word = text.slice(i, i + Array.from(matchText).length).join(""); + + if ( + matchText === word && + (foundWord == null || + Array.from(word).length > Array.from(foundWord).length) + ) { + foundWord = word; + foundEntries = entries; + } + } + } + + if (foundWord != null) { + pushToken(foundWord); + + if (foundEntries === simplifiedEntries) { + simplifiedPreference++; + } else if (foundEntries === traditionalEntries) { + traditionalPreference++; + } + + continue; + } + } + + // If it fails, match one character + + let character = text[i]; + let isChinese = (character) => + chinesePunctuation.includes(character) || + dictionary.get(character, false).length > 0 || + dictionary.get(character, true).length > 0; + + if (isChinese(character) || character.match(/\s/) != null) { + pushToken(character); + continue; + } + + // Handle non-Chinese characters + + let end = i + 1; + + for (; end < text.length; end++) { + if (text[end].match(/\s/) != null || isChinese(text[end])) break; + } + + let word = text.slice(i, end).join(""); + pushToken(word); + } + + return result; + }; +}; + +/** + * Chinese needs original logic. + */ +class ChineseTokenizer { + static create(dict) { + const ins = new ChineseTokenizer(); + ins._tokenize = main.load(dict); + return ins; + } + tokenize(content, raw) { + return content + .split(raw ? / /g : this.getTrimPattern()) + .filter((x) => x !== "") + .flatMap((x) => this._tokenize(x)) + .map((x) => x.text); + } + recursiveTokenize(content) { + const tokens = this._tokenize(content).map((x) => x.text); + const ret = []; + for (let i = 0; i < tokens.length; i++) { + if (i === 0 || + tokens[i].length !== 1 || + !Boolean(tokens[i].match(this.getTrimPattern()))) { + ret.push({ + word: tokens.slice(i).join(""), + offset: tokens.slice(0, i).join("").length, + }); + } + } + return ret; + } + getTrimPattern() { + return TRIM_CHAR_PATTERN; + } + shouldIgnoreOnCurrent(str) { + return false; + } +} + +function createTokenizer(strategy, app) { + return __awaiter(this, void 0, void 0, function* () { + switch (strategy.name) { + case "default": + return new DefaultTokenizer(); + case "english-only": + return new EnglishOnlyTokenizer(); + case "arabic": + return new ArabicTokenizer(); + case "japanese": + return new JapaneseTokenizer(); + case "chinese": + const hasCedict = yield app.vault.adapter.exists("./cedict_ts.u8"); + if (!hasCedict) { + return Promise.reject(new Error("cedict_ts.U8 doesn't exist in your vault root.")); + } + const dict = yield app.vault.adapter.read("./cedict_ts.u8"); + return ChineseTokenizer.create(dict); + } + }); +} + +class TokenizeStrategy { + constructor(name, triggerThreshold, indexingThreshold) { + this.name = name; + this.triggerThreshold = triggerThreshold; + this.indexingThreshold = indexingThreshold; + TokenizeStrategy._values.push(this); + } + static fromName(name) { + return TokenizeStrategy._values.find((x) => x.name === name); + } + static values() { + return TokenizeStrategy._values; + } +} +TokenizeStrategy._values = []; +TokenizeStrategy.DEFAULT = new TokenizeStrategy("default", 3, 5); +TokenizeStrategy.ENGLISH_ONLY = new TokenizeStrategy("english-only", 3, 5); +TokenizeStrategy.JAPANESE = new TokenizeStrategy("japanese", 2, 2); +TokenizeStrategy.ARABIC = new TokenizeStrategy("arabic", 3, 3); +TokenizeStrategy.CHINESE = new TokenizeStrategy("chinese", 1, 2); + +class AppHelper { + constructor(app) { + this.unsafeApp = app; + } + equalsAsEditorPostion(one, other) { + return one.line === other.line && one.ch === other.ch; + } + getAliases(file) { + var _a, _b; + return ((_b = obsidian.parseFrontMatterAliases((_a = this.unsafeApp.metadataCache.getFileCache(file)) === null || _a === void 0 ? void 0 : _a.frontmatter)) !== null && _b !== void 0 ? _b : []); + } + getFrontMatter(file) { + var _a, _b, _c, _d; + const frontMatter = (_a = this.unsafeApp.metadataCache.getFileCache(file)) === null || _a === void 0 ? void 0 : _a.frontmatter; + if (!frontMatter) { + return undefined; + } + // remove # + const tags = (_c = (_b = obsidian.parseFrontMatterTags(frontMatter)) === null || _b === void 0 ? void 0 : _b.map((x) => x.slice(1))) !== null && _c !== void 0 ? _c : []; + const aliases = (_d = obsidian.parseFrontMatterAliases(frontMatter)) !== null && _d !== void 0 ? _d : []; + const rest = __rest(frontMatter, ["position"]); + return Object.assign(Object.assign({}, Object.fromEntries(Object.entries(rest).map(([k, _v]) => [ + k, + obsidian.parseFrontMatterStringArray(frontMatter, k), + ]))), { tags, tag: tags, aliases, alias: aliases }); + } + getMarkdownViewInActiveLeaf() { + if (!this.unsafeApp.workspace.getActiveViewOfType(obsidian.MarkdownView)) { + return null; + } + return this.unsafeApp.workspace.activeLeaf.view; + } + getActiveFile() { + return this.unsafeApp.workspace.getActiveFile(); + } + isActiveFile(file) { + var _a; + return ((_a = this.getActiveFile()) === null || _a === void 0 ? void 0 : _a.path) === file.path; + } + getPreviousFile() { + var _a; + const fName = (_a = this.unsafeApp.workspace.getLastOpenFiles()) === null || _a === void 0 ? void 0 : _a[1]; + if (!fName) { + return null; + } + return this.getMarkdownFileByPath(fName); + } + getCurrentDirname() { + var _a, _b; + return (_b = (_a = this.getActiveFile()) === null || _a === void 0 ? void 0 : _a.parent.path) !== null && _b !== void 0 ? _b : null; + } + getCurrentEditor() { + var _a, _b; + return (_b = (_a = this.getMarkdownViewInActiveLeaf()) === null || _a === void 0 ? void 0 : _a.editor) !== null && _b !== void 0 ? _b : null; + } + getSelection() { + var _a; + return (_a = this.getCurrentEditor()) === null || _a === void 0 ? void 0 : _a.getSelection(); + } + getCurrentOffset(editor) { + return editor.posToOffset(editor.getCursor()); + } + getCurrentLine(editor) { + return editor.getLine(editor.getCursor().line); + } + getCurrentLineUntilCursor(editor) { + return this.getCurrentLine(editor).slice(0, editor.getCursor().ch); + } + optimizeMarkdownLinkText(linkText) { + const activeFile = this.getActiveFile(); + if (!activeFile) { + return null; + } + const path = this.linkText2Path(linkText); + if (!path) { + return linkText; + } + const file = this.getMarkdownFileByPath(path); + if (!file) { + return null; + } + const markdownLink = this.unsafeApp.fileManager.generateMarkdownLink(file, activeFile.path); + return markdownLink.startsWith("[[") + ? markdownLink.replace("[[", "").replace("]]", "") + : markdownLink.replace("[", "").replace(/\]\(.+\)/g, ""); + } + linkText2Path(linkText) { + var _a, _b; + const activeFile = this.getActiveFile(); + if (!activeFile) { + return null; + } + return ((_b = (_a = this.unsafeApp.metadataCache.getFirstLinkpathDest(linkText, activeFile.path)) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : null); + } + searchPhantomLinks() { + return Object.entries(this.unsafeApp.metadataCache.unresolvedLinks).flatMap(([path, obj]) => Object.keys(obj).map((link) => ({ path, link }))); + } + getMarkdownFileByPath(path) { + if (!path.endsWith(".md")) { + return null; + } + const abstractFile = this.unsafeApp.vault.getAbstractFileByPath(path); + if (!abstractFile) { + return null; + } + return abstractFile; + } + openMarkdownFile(file, newLeaf, offset = 0) { + var _a; + const leaf = this.unsafeApp.workspace.getLeaf(newLeaf); + leaf + .openFile(file, (_a = this.unsafeApp.workspace.activeLeaf) === null || _a === void 0 ? void 0 : _a.getViewState()) + .then(() => { + this.unsafeApp.workspace.setActiveLeaf(leaf, true, true); + const viewOfType = this.unsafeApp.workspace.getActiveViewOfType(obsidian.MarkdownView); + if (viewOfType) { + const editor = viewOfType.editor; + const pos = editor.offsetToPos(offset); + editor.setCursor(pos); + editor.scrollIntoView({ from: pos, to: pos }, true); + } + }); + } + getCurrentFrontMatter() { + const editor = this.getCurrentEditor(); + if (!editor) { + return null; + } + if (!this.getActiveFile()) { + return null; + } + if (editor.getLine(0) !== "---") { + return null; + } + const endPosition = editor.getValue().indexOf("---", 3); + const currentOffset = this.getCurrentOffset(editor); + if (endPosition !== -1 && currentOffset >= endPosition) { + return null; + } + const keyLocations = Array.from(editor.getValue().matchAll(/.+:/g)); + if (keyLocations.length === 0) { + return null; + } + const currentKeyLocation = keyLocations + .filter((x) => x.index < currentOffset) + .last(); + if (!currentKeyLocation) { + return null; + } + return currentKeyLocation[0].split(":")[0]; + } + /** + * Unsafe method + */ + isIMEOn() { + var _a, _b, _c; + if (!this.unsafeApp.workspace.getActiveViewOfType(obsidian.MarkdownView)) { + return false; + } + const markdownView = this.unsafeApp.workspace.activeLeaf + .view; + const cm5or6 = markdownView.editor.cm; + // cm6 + if (((_a = cm5or6 === null || cm5or6 === void 0 ? void 0 : cm5or6.inputState) === null || _a === void 0 ? void 0 : _a.composing) > 0) { + return true; + } + // cm5 + return !!((_c = (_b = cm5or6 === null || cm5or6 === void 0 ? void 0 : cm5or6.display) === null || _b === void 0 ? void 0 : _b.input) === null || _c === void 0 ? void 0 : _c.composing); + } + writeLog(log) { + return __awaiter(this, void 0, void 0, function* () { + yield this.unsafeApp.vault.adapter.append(obsidian.normalizePath("log.md"), log); + }); + } + get useWikiLinks() { + return !this.unsafeApp.vault.config.useMarkdownLinks; + } +} + +const groupBy = (values, toKey) => values.reduce((prev, cur, _1, _2, k = toKey(cur)) => ((prev[k] || (prev[k] = [])).push(cur), prev), {}); +function uniq(values) { + return [...new Set(values)]; +} +function uniqBy(values, fn) { + const m = new Map(); + values.forEach((x) => { + const k = fn(x); + if (!m.has(k)) { + m.set(k, x); + } + }); + return Array.from(m.values()); +} +function uniqWith(arr, fn) { + return arr.filter((element, index) => arr.findIndex((step) => fn(element, step)) === index); +} +function mirrorMap(collection, toValue) { + return collection.reduce((p, c) => (Object.assign(Object.assign({}, p), { [toValue(c)]: toValue(c) })), {}); +} + +class WordTypeMeta { + constructor(type, priority, group) { + this.type = type; + this.priority = priority; + this.group = group; + WordTypeMeta._values.push(this); + WordTypeMeta._dict[type] = this; + } + static of(type) { + return WordTypeMeta._dict[type]; + } + static values() { + return WordTypeMeta._values; + } +} +WordTypeMeta._values = []; +WordTypeMeta._dict = {}; +WordTypeMeta.FRONT_MATTER = new WordTypeMeta("frontMatter", 100, "frontMatter"); +WordTypeMeta.INTERNAL_LINK = new WordTypeMeta("internalLink", 90, "internalLink"); +WordTypeMeta.CUSTOM_DICTIONARY = new WordTypeMeta("customDictionary", 80, "suggestion"); +WordTypeMeta.CURRENT_FILE = new WordTypeMeta("currentFile", 70, "suggestion"); +WordTypeMeta.CURRENT_VAULT = new WordTypeMeta("currentVault", 60, "suggestion"); + +function pushWord(wordsByFirstLetter, key, word) { + if (wordsByFirstLetter[key] === undefined) { + wordsByFirstLetter[key] = [word]; + return; + } + wordsByFirstLetter[key].push(word); +} +// Public for tests +function judge(word, query, queryStartWithUpper) { + var _a; + if (query === "") { + return { + word: Object.assign(Object.assign({}, word), { hit: word.value }), + value: word.value, + alias: false, + }; + } + if (lowerStartsWith(word.value, query)) { + if (queryStartWithUpper && + word.type !== "internalLink" && + word.type !== "frontMatter") { + const c = capitalizeFirstLetter(word.value); + return { + word: Object.assign(Object.assign({}, word), { value: c, hit: c }), + value: c, + alias: false, + }; + } + else { + return { + word: Object.assign(Object.assign({}, word), { hit: word.value }), + value: word.value, + alias: false, + }; + } + } + const matchedAlias = (_a = word.aliases) === null || _a === void 0 ? void 0 : _a.find((a) => lowerStartsWith(a, query)); + if (matchedAlias) { + return { + word: Object.assign(Object.assign({}, word), { hit: matchedAlias }), + value: matchedAlias, + alias: true, + }; + } + return { + word, + alias: false, + }; +} +function suggestWords(indexedWords, query, max, option = {}) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r; + const { frontMatter, selectionHistoryStorage } = option; + const queryStartWithUpper = capitalizeFirstLetter(query) === query; + const flattenFrontMatterWords = () => { + var _a, _b; + if (frontMatter === "alias" || frontMatter === "aliases") { + return []; + } + if (frontMatter && ((_a = indexedWords.frontMatter) === null || _a === void 0 ? void 0 : _a[frontMatter])) { + return Object.values((_b = indexedWords.frontMatter) === null || _b === void 0 ? void 0 : _b[frontMatter]).flat(); + } + return []; + }; + const words = queryStartWithUpper + ? frontMatter + ? flattenFrontMatterWords() + : [ + ...((_a = indexedWords.currentFile[query.charAt(0)]) !== null && _a !== void 0 ? _a : []), + ...((_b = indexedWords.currentFile[query.charAt(0).toLowerCase()]) !== null && _b !== void 0 ? _b : []), + ...((_c = indexedWords.currentVault[query.charAt(0)]) !== null && _c !== void 0 ? _c : []), + ...((_d = indexedWords.currentVault[query.charAt(0).toLowerCase()]) !== null && _d !== void 0 ? _d : []), + ...((_e = indexedWords.customDictionary[query.charAt(0)]) !== null && _e !== void 0 ? _e : []), + ...((_f = indexedWords.customDictionary[query.charAt(0).toLowerCase()]) !== null && _f !== void 0 ? _f : []), + ...((_g = indexedWords.internalLink[query.charAt(0)]) !== null && _g !== void 0 ? _g : []), + ...((_h = indexedWords.internalLink[query.charAt(0).toLowerCase()]) !== null && _h !== void 0 ? _h : []), + ] + : frontMatter + ? flattenFrontMatterWords() + : [ + ...((_j = indexedWords.currentFile[query.charAt(0)]) !== null && _j !== void 0 ? _j : []), + ...((_k = indexedWords.currentFile[query.charAt(0).toUpperCase()]) !== null && _k !== void 0 ? _k : []), + ...((_l = indexedWords.currentVault[query.charAt(0)]) !== null && _l !== void 0 ? _l : []), + ...((_m = indexedWords.currentVault[query.charAt(0).toUpperCase()]) !== null && _m !== void 0 ? _m : []), + ...((_o = indexedWords.customDictionary[query.charAt(0)]) !== null && _o !== void 0 ? _o : []), + ...((_p = indexedWords.customDictionary[query.charAt(0).toUpperCase()]) !== null && _p !== void 0 ? _p : []), + ...((_q = indexedWords.internalLink[query.charAt(0)]) !== null && _q !== void 0 ? _q : []), + ...((_r = indexedWords.internalLink[query.charAt(0).toUpperCase()]) !== null && _r !== void 0 ? _r : []), + ]; + const candidate = Array.from(words) + .map((x) => judge(x, query, queryStartWithUpper)) + .filter((x) => x.value !== undefined) + .sort((a, b) => { + const aWord = a.word; + const bWord = b.word; + const notSameWordType = aWord.type !== bWord.type; + if (frontMatter && notSameWordType) { + return bWord.type === "frontMatter" ? 1 : -1; + } + if (selectionHistoryStorage) { + const ret = selectionHistoryStorage.compare(aWord, bWord); + if (ret !== 0) { + return ret; + } + } + if (a.value.length !== b.value.length) { + return a.value.length > b.value.length ? 1 : -1; + } + if (notSameWordType) { + return WordTypeMeta.of(bWord.type).priority > + WordTypeMeta.of(aWord.type).priority + ? 1 + : -1; + } + if (a.alias !== b.alias) { + return a.alias ? 1 : -1; + } + return 0; + }) + .map((x) => x.word) + .slice(0, max); + // XXX: There is no guarantee that equals with max, but it is important for performance + return uniqWith(candidate, (a, b) => a.value === b.value && + WordTypeMeta.of(a.type).group === WordTypeMeta.of(b.type).group); +} +// TODO: refactoring +// Public for tests +function judgeByPartialMatch(word, query, queryStartWithUpper) { + var _a, _b; + if (query === "") { + return { + word: Object.assign(Object.assign({}, word), { hit: word.value }), + value: word.value, + alias: false, + }; + } + if (lowerStartsWith(word.value, query)) { + if (queryStartWithUpper && + word.type !== "internalLink" && + word.type !== "frontMatter") { + const c = capitalizeFirstLetter(word.value); + return { word: Object.assign(Object.assign({}, word), { value: c, hit: c }), value: c, alias: false }; + } + else { + return { + word: Object.assign(Object.assign({}, word), { hit: word.value }), + value: word.value, + alias: false, + }; + } + } + const matchedAliasStarts = (_a = word.aliases) === null || _a === void 0 ? void 0 : _a.find((a) => lowerStartsWith(a, query)); + if (matchedAliasStarts) { + return { + word: Object.assign(Object.assign({}, word), { hit: matchedAliasStarts }), + value: matchedAliasStarts, + alias: true, + }; + } + if (lowerIncludes(word.value, query)) { + return { + word: Object.assign(Object.assign({}, word), { hit: word.value }), + value: word.value, + alias: false, + }; + } + const matchedAliasIncluded = (_b = word.aliases) === null || _b === void 0 ? void 0 : _b.find((a) => lowerIncludes(a, query)); + if (matchedAliasIncluded) { + return { + word: Object.assign(Object.assign({}, word), { hit: matchedAliasIncluded }), + value: matchedAliasIncluded, + alias: true, + }; + } + return { word: word, alias: false }; +} +function suggestWordsByPartialMatch(indexedWords, query, max, option = {}) { + const { frontMatter, selectionHistoryStorage } = option; + const queryStartWithUpper = capitalizeFirstLetter(query) === query; + const flatObjectValues = (object) => Object.values(object).flat(); + const flattenFrontMatterWords = () => { + var _a, _b; + if (frontMatter === "alias" || frontMatter === "aliases") { + return []; + } + if (frontMatter && ((_a = indexedWords.frontMatter) === null || _a === void 0 ? void 0 : _a[frontMatter])) { + return Object.values((_b = indexedWords.frontMatter) === null || _b === void 0 ? void 0 : _b[frontMatter]).flat(); + } + return []; + }; + const words = frontMatter + ? flattenFrontMatterWords() + : [ + ...flatObjectValues(indexedWords.currentFile), + ...flatObjectValues(indexedWords.currentVault), + ...flatObjectValues(indexedWords.customDictionary), + ...flatObjectValues(indexedWords.internalLink), + ]; + const candidate = Array.from(words) + .map((x) => judgeByPartialMatch(x, query, queryStartWithUpper)) + .filter((x) => x.value !== undefined) + .sort((a, b) => { + const aWord = a.word; + const bWord = b.word; + const notSameWordType = aWord.type !== bWord.type; + if (frontMatter && notSameWordType) { + return bWord.type === "frontMatter" ? 1 : -1; + } + if (selectionHistoryStorage) { + const ret = selectionHistoryStorage.compare(aWord, bWord); + if (ret !== 0) { + return ret; + } + } + const as = lowerStartsWith(a.value, query); + const bs = lowerStartsWith(b.value, query); + if (as !== bs) { + return bs ? 1 : -1; + } + if (a.value.length !== b.value.length) { + return a.value.length > b.value.length ? 1 : -1; + } + if (notSameWordType) { + return WordTypeMeta.of(bWord.type).priority > + WordTypeMeta.of(aWord.type).priority + ? 1 + : -1; + } + if (a.alias !== b.alias) { + return a.alias ? 1 : -1; + } + return 0; + }) + .map((x) => x.word) + .slice(0, max); + // XXX: There is no guarantee that equals with max, but it is important for performance + return uniqWith(candidate, (a, b) => a.value === b.value && + WordTypeMeta.of(a.type).group === WordTypeMeta.of(b.type).group); +} + +function basename(path, ext) { + var _a, _b; + const name = (_b = (_a = path.match(/.+[\\/]([^\\/]+)[\\/]?$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : path; + return ext && name.endsWith(ext) ? name.replace(ext, "") : name; +} +function dirname(path) { + var _a, _b; + return (_b = (_a = path.match(/(.+)[\\/].+$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "."; +} +function isURL(path) { + return Boolean(path.match(new RegExp("^https?://"))); +} + +function escape(value) { + // This tricky logics for Safari + // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/56 + return value + .replace(/\\/g, "__VariousComplementsEscape__") + .replace(/\n/g, "\\n") + .replace(/\t/g, "\\t") + .replace(/__VariousComplementsEscape__/g, "\\\\"); +} +function unescape(value) { + // This tricky logics for Safari + // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/56 + return value + .replace(/\\\\/g, "__VariousComplementsEscape__") + .replace(/\\n/g, "\n") + .replace(/\\t/g, "\t") + .replace(/__VariousComplementsEscape__/g, "\\"); +} +function jsonToWords(json, path, systemCaretSymbol) { + return json.words.map((x) => { + var _a; + return ({ + value: x.displayed || x.value, + description: x.description, + aliases: x.aliases, + type: "customDictionary", + createdPath: path, + insertedText: x.displayed ? x.value : undefined, + caretSymbol: (_a = json.caretSymbol) !== null && _a !== void 0 ? _a : systemCaretSymbol, + ignoreSpaceAfterCompletion: json.ignoreSpaceAfterCompletion, + }); + }); +} +function lineToWord(line, delimiter, path, delimiterForDisplay, delimiterForHide, systemCaretSymbol) { + const [v, description, ...aliases] = line.split(delimiter.value); + let value = unescape(v); + let insertedText; + let displayedText = value; + if (delimiterForDisplay && value.includes(delimiterForDisplay)) { + [displayedText, insertedText] = value.split(delimiterForDisplay); + } + if (delimiterForHide && value.includes(delimiterForHide)) { + insertedText = value.replace(delimiterForHide, ""); + displayedText = `${value.split(delimiterForHide)[0]} ...`; + } + return { + value: displayedText, + description, + aliases, + type: "customDictionary", + createdPath: path, + insertedText, + caretSymbol: systemCaretSymbol, + }; +} +function wordToLine(word, delimiter, dividerForDisplay) { + const value = word.insertedText && dividerForDisplay + ? `${word.value}${dividerForDisplay}${word.insertedText}` + : word.value; + const escapedValue = escape(value); + if (!word.description && !word.aliases) { + return escapedValue; + } + if (!word.aliases) { + return [escapedValue, word.description].join(delimiter.value); + } + return [escapedValue, word.description, ...word.aliases].join(delimiter.value); +} +function synonymAliases$1(name) { + const lessEmojiValue = excludeEmoji(name); + return name === lessEmojiValue ? [] : [lessEmojiValue]; +} +class CustomDictionaryWordProvider { + constructor(app, appHelper) { + this.words = []; + this.wordByValue = {}; + this.wordsByFirstLetter = {}; + this.appHelper = appHelper; + this.fileSystemAdapter = app.vault.adapter; + } + get editablePaths() { + return this.paths.filter((x) => !isURL(x) && !x.endsWith(".json")); + } + loadWords(path, option) { + return __awaiter(this, void 0, void 0, function* () { + const contents = isURL(path) + ? yield obsidian.request({ url: path }) + : yield this.fileSystemAdapter.read(path); + const words = path.endsWith(".json") + ? jsonToWords(JSON.parse(contents), path, option.caretSymbol) + : contents + .split(/\r\n|\n/) + .map((x) => x.replace(/%%.*%%/g, "")) + .filter((x) => x) + .map((x) => lineToWord(x, this.delimiter, path, option.delimiterForDisplay, option.delimiterForHide, option.caretSymbol)); + return words.filter((x) => !option.regexp || x.value.match(new RegExp(option.regexp))); + }); + } + refreshCustomWords(option) { + return __awaiter(this, void 0, void 0, function* () { + this.clearWords(); + for (const path of this.paths) { + try { + const words = yield this.loadWords(path, option); + words.forEach((x) => this.addWord(x)); + } + catch (e) { + // noinspection ObjectAllocationIgnored + new obsidian.Notice(`⚠ Fail to load ${path} -- Various Complements Plugin -- \n ${e}`, 0); + } + } + }); + } + addWordWithDictionary(word, dictionaryPath) { + return __awaiter(this, void 0, void 0, function* () { + this.addWord(word); + yield this.fileSystemAdapter.append(dictionaryPath, "\n" + wordToLine(word, this.delimiter, this.dividerForDisplay)); + }); + } + addWord(word) { + var _a, _b; + this.words.push(word); + // Add aliases as a synonym + const wordWithSynonym = Object.assign(Object.assign({}, word), { aliases: [...((_a = word.aliases) !== null && _a !== void 0 ? _a : []), ...synonymAliases$1(word.value)] }); + this.wordByValue[wordWithSynonym.value] = wordWithSynonym; + pushWord(this.wordsByFirstLetter, wordWithSynonym.value.charAt(0), wordWithSynonym); + (_b = wordWithSynonym.aliases) === null || _b === void 0 ? void 0 : _b.forEach((a) => pushWord(this.wordsByFirstLetter, a.charAt(0), wordWithSynonym)); + } + clearWords() { + this.words = []; + this.wordByValue = {}; + this.wordsByFirstLetter = {}; + } + get wordCount() { + return this.words.length; + } + setSettings(paths, delimiter, dividerForDisplay) { + this.paths = paths; + this.delimiter = delimiter; + this.dividerForDisplay = dividerForDisplay; + } +} + +class CurrentFileWordProvider { + constructor(app, appHelper) { + this.app = app; + this.appHelper = appHelper; + this.wordsByFirstLetter = {}; + this.words = []; + } + refreshWords(onlyEnglish, minNumberOfCharacters) { + return __awaiter(this, void 0, void 0, function* () { + this.clearWords(); + const editor = this.appHelper.getCurrentEditor(); + if (!editor) { + return; + } + const file = this.app.workspace.getActiveFile(); + if (!file) { + return; + } + const currentToken = this.tokenizer + .tokenize(editor.getLine(editor.getCursor().line).slice(0, editor.getCursor().ch)) + .last(); + const content = yield this.app.vault.cachedRead(file); + const tokens = this.tokenizer + .tokenize(content) + .filter((x) => { + if (x.length < minNumberOfCharacters) { + return false; + } + if (this.tokenizer.shouldIgnoreOnCurrent(x)) { + return false; + } + return onlyEnglish ? allAlphabets(x) : true; + }) + .map((x) => (startsSmallLetterOnlyFirst(x) ? x.toLowerCase() : x)); + this.words = uniq(tokens) + .filter((x) => x !== currentToken) + .map((x) => ({ + value: x, + type: "currentFile", + createdPath: file.path, + })); + this.wordsByFirstLetter = groupBy(this.words, (x) => x.value.charAt(0)); + }); + } + clearWords() { + this.words = []; + this.wordsByFirstLetter = {}; + } + get wordCount() { + return this.words.length; + } + setSettings(tokenizer) { + this.tokenizer = tokenizer; + } +} + +class InternalLinkWordProvider { + constructor(app, appHelper) { + this.app = app; + this.appHelper = appHelper; + this.words = []; + this.wordsByFirstLetter = {}; + } + refreshWords(wordAsInternalLinkAlias, excludePathPrefixPatterns) { + var _a; + this.clearWords(); + const synonymAliases = (name) => { + const lessEmojiValue = excludeEmoji(name); + return name === lessEmojiValue ? [] : [lessEmojiValue]; + }; + const resolvedInternalLinkWords = this.app.vault + .getMarkdownFiles() + .filter((f) => excludePathPrefixPatterns.every((x) => !f.path.startsWith(x))) + .flatMap((x) => { + const aliases = this.appHelper.getAliases(x); + if (wordAsInternalLinkAlias) { + return [ + { + value: x.basename, + type: "internalLink", + createdPath: x.path, + aliases: synonymAliases(x.basename), + description: x.path, + }, + ...aliases.map((a) => ({ + value: a, + type: "internalLink", + createdPath: x.path, + aliases: synonymAliases(a), + description: x.path, + aliasMeta: { + origin: x.basename, + }, + })), + ]; + } + else { + return [ + { + value: x.basename, + type: "internalLink", + createdPath: x.path, + aliases: [ + ...synonymAliases(x.basename), + ...aliases, + ...aliases.flatMap(synonymAliases), + ], + description: x.path, + }, + ]; + } + }); + const unresolvedInternalLinkWords = this.appHelper + .searchPhantomLinks() + .map(({ path, link }) => { + return { + value: link, + type: "internalLink", + createdPath: path, + aliases: synonymAliases(link), + description: `Appeared in -> ${path}`, + phantom: true, + }; + }); + this.words = [...resolvedInternalLinkWords, ...unresolvedInternalLinkWords]; + for (const word of this.words) { + pushWord(this.wordsByFirstLetter, word.value.charAt(0), word); + (_a = word.aliases) === null || _a === void 0 ? void 0 : _a.forEach((a) => pushWord(this.wordsByFirstLetter, a.charAt(0), word)); + } + } + clearWords() { + this.words = []; + this.wordsByFirstLetter = {}; + } + get wordCount() { + return this.words.length; + } +} + +class MatchStrategy { + constructor(name, handler) { + this.name = name; + this.handler = handler; + MatchStrategy._values.push(this); + } + static fromName(name) { + return MatchStrategy._values.find((x) => x.name === name); + } + static values() { + return MatchStrategy._values; + } +} +MatchStrategy._values = []; +MatchStrategy.PREFIX = new MatchStrategy("prefix", suggestWords); +MatchStrategy.PARTIAL = new MatchStrategy("partial", suggestWordsByPartialMatch); + +class CycleThroughSuggestionsKeys { + constructor(name, nextKey, previousKey) { + this.name = name; + this.nextKey = nextKey; + this.previousKey = previousKey; + CycleThroughSuggestionsKeys._values.push(this); + } + static fromName(name) { + return CycleThroughSuggestionsKeys._values.find((x) => x.name === name); + } + static values() { + return CycleThroughSuggestionsKeys._values; + } +} +CycleThroughSuggestionsKeys._values = []; +CycleThroughSuggestionsKeys.NONE = new CycleThroughSuggestionsKeys("None", { modifiers: [], key: null }, { modifiers: [], key: null }); +CycleThroughSuggestionsKeys.TAB = new CycleThroughSuggestionsKeys("Tab, Shift+Tab", { modifiers: [], key: "Tab" }, { modifiers: ["Shift"], key: "Tab" }); +CycleThroughSuggestionsKeys.EMACS = new CycleThroughSuggestionsKeys("Ctrl/Cmd+N, Ctrl/Cmd+P", { modifiers: ["Mod"], key: "N" }, { modifiers: ["Mod"], key: "P" }); +CycleThroughSuggestionsKeys.VIM = new CycleThroughSuggestionsKeys("Ctrl/Cmd+J, Ctrl/Cmd+K", { modifiers: ["Mod"], key: "J" }, { modifiers: ["Mod"], key: "K" }); + +class ColumnDelimiter { + constructor(name, value) { + this.name = name; + this.value = value; + ColumnDelimiter._values.push(this); + } + static fromName(name) { + return ColumnDelimiter._values.find((x) => x.name === name); + } + static values() { + return ColumnDelimiter._values; + } +} +ColumnDelimiter._values = []; +ColumnDelimiter.TAB = new ColumnDelimiter("Tab", "\t"); +ColumnDelimiter.COMMA = new ColumnDelimiter("Comma", ","); +ColumnDelimiter.PIPE = new ColumnDelimiter("Pipe", "|"); + +class SelectSuggestionKey { + constructor(name, keyBind) { + this.name = name; + this.keyBind = keyBind; + SelectSuggestionKey._values.push(this); + } + static fromName(name) { + return SelectSuggestionKey._values.find((x) => x.name === name); + } + static values() { + return SelectSuggestionKey._values; + } +} +SelectSuggestionKey._values = []; +SelectSuggestionKey.ENTER = new SelectSuggestionKey("Enter", { + modifiers: [], + key: "Enter", +}); +SelectSuggestionKey.TAB = new SelectSuggestionKey("Tab", { + modifiers: [], + key: "Tab", +}); +SelectSuggestionKey.MOD_ENTER = new SelectSuggestionKey("Ctrl/Cmd+Enter", { + modifiers: ["Mod"], + key: "Enter", +}); +SelectSuggestionKey.ALT_ENTER = new SelectSuggestionKey("Alt+Enter", { + modifiers: ["Alt"], + key: "Enter", +}); +SelectSuggestionKey.SHIFT_ENTER = new SelectSuggestionKey("Shift+Enter", { + modifiers: ["Shift"], + key: "Enter", +}); +SelectSuggestionKey.SPACE = new SelectSuggestionKey("Space", { + modifiers: [], + key: " ", +}); +SelectSuggestionKey.SHIFT_SPACE = new SelectSuggestionKey("Shift+Space", { + modifiers: ["Shift"], + key: " ", +}); +SelectSuggestionKey.BACKQUOTE = new SelectSuggestionKey("Backquote", { + modifiers: [], + key: "`", +}); +SelectSuggestionKey.None = new SelectSuggestionKey("None", { + modifiers: [], + key: "", +}); + +class CurrentVaultWordProvider { + constructor(app, appHelper) { + this.app = app; + this.appHelper = appHelper; + this.wordsByFirstLetter = {}; + this.words = []; + } + refreshWords(minNumberOfCharacters) { + return __awaiter(this, void 0, void 0, function* () { + this.clearWords(); + const currentDirname = this.appHelper.getCurrentDirname(); + const markdownFilePaths = this.app.vault + .getMarkdownFiles() + .map((x) => x.path) + .filter((p) => this.includePrefixPatterns.every((x) => p.startsWith(x))) + .filter((p) => this.excludePrefixPatterns.every((x) => !p.startsWith(x))) + .filter((p) => !this.onlyUnderCurrentDirectory || dirname(p) === currentDirname); + let wordByValue = {}; + for (const path of markdownFilePaths) { + const content = yield this.app.vault.adapter.read(path); + const tokens = this.tokenizer + .tokenize(content) + .filter((x) => x.length >= minNumberOfCharacters && + !this.tokenizer.shouldIgnoreOnCurrent(x)) + .map((x) => (startsSmallLetterOnlyFirst(x) ? x.toLowerCase() : x)); + for (const token of tokens) { + wordByValue[token] = { + value: token, + type: "currentVault", + createdPath: path, + description: path, + }; + } + } + this.words = Object.values(wordByValue); + this.wordsByFirstLetter = groupBy(this.words, (x) => x.value.charAt(0)); + }); + } + clearWords() { + this.words = []; + this.wordsByFirstLetter = {}; + } + get wordCount() { + return this.words.length; + } + setSettings(tokenizer, includePrefixPatterns, excludePrefixPatterns, onlyUnderCurrentDirectory) { + this.tokenizer = tokenizer; + this.includePrefixPatterns = includePrefixPatterns; + this.excludePrefixPatterns = excludePrefixPatterns; + this.onlyUnderCurrentDirectory = onlyUnderCurrentDirectory; + } +} + +class OpenSourceFileKeys { + constructor(name, keyBind) { + this.name = name; + this.keyBind = keyBind; + OpenSourceFileKeys._values.push(this); + } + static fromName(name) { + return OpenSourceFileKeys._values.find((x) => x.name === name); + } + static values() { + return OpenSourceFileKeys._values; + } +} +OpenSourceFileKeys._values = []; +OpenSourceFileKeys.NONE = new OpenSourceFileKeys("None", { + modifiers: [], + key: null, +}); +OpenSourceFileKeys.MOD_ENTER = new OpenSourceFileKeys("Ctrl/Cmd+Enter", { + modifiers: ["Mod"], + key: "Enter", +}); +OpenSourceFileKeys.ALT_ENTER = new OpenSourceFileKeys("Alt+Enter", { + modifiers: ["Alt"], + key: "Enter", +}); +OpenSourceFileKeys.SHIFT_ENTER = new OpenSourceFileKeys("Shift+Enter", { + modifiers: ["Shift"], + key: "Enter", +}); + +class DescriptionOnSuggestion { + constructor(name, toDisplay) { + this.name = name; + this.toDisplay = toDisplay; + DescriptionOnSuggestion._values.push(this); + } + static fromName(name) { + return DescriptionOnSuggestion._values.find((x) => x.name === name); + } + static values() { + return DescriptionOnSuggestion._values; + } +} +DescriptionOnSuggestion._values = []; +DescriptionOnSuggestion.NONE = new DescriptionOnSuggestion("None", () => null); +DescriptionOnSuggestion.SHORT = new DescriptionOnSuggestion("Short", (word) => { + if (!word.description) { + return null; + } + return word.type === "customDictionary" + ? word.description + : basename(word.description); +}); +DescriptionOnSuggestion.FULL = new DescriptionOnSuggestion("Full", (word) => { var _a; return (_a = word.description) !== null && _a !== void 0 ? _a : null; }); + +function synonymAliases(name) { + const lessEmojiValue = excludeEmoji(name); + return name === lessEmojiValue ? [] : [lessEmojiValue]; +} +function frontMatterToWords(file, key, values) { + return values.map((x) => ({ + key, + value: x, + type: "frontMatter", + createdPath: file.path, + aliases: synonymAliases(x), + })); +} +function pickWords(file, fm) { + return Object.entries(fm) + .filter(([_key, value]) => value != null && + (typeof value === "string" || typeof value[0] === "string")) + .flatMap(([key, value]) => frontMatterToWords(file, key, value)); +} +// noinspection FunctionWithMultipleLoopsJS +function extractAndUniqWords(wordsByCreatedPath) { + return uniqBy(Object.values(wordsByCreatedPath).flat(), (w) => w.key + w.value.toLowerCase()); +} +function indexingWords(words) { + const wordsByKey = groupBy(words, (x) => x.key); + return Object.fromEntries(Object.entries(wordsByKey).map(([key, words]) => [ + key, + groupBy(words, (w) => w.value.charAt(0)), + ])); +} +class FrontMatterWordProvider { + constructor(app, appHelper) { + this.app = app; + this.appHelper = appHelper; + this.wordsByCreatedPath = {}; + } + refreshWords() { + this.clearWords(); + this.app.vault.getMarkdownFiles().forEach((f) => { + const fm = this.appHelper.getFrontMatter(f); + if (!fm) { + return; + } + this.wordsByCreatedPath[f.path] = pickWords(f, fm); + }); + this.words = extractAndUniqWords(this.wordsByCreatedPath); + this.wordsByFirstLetterByKey = indexingWords(this.words); + } + updateWordIndex(file) { + const fm = this.appHelper.getFrontMatter(file); + if (!fm) { + return; + } + this.wordsByCreatedPath[file.path] = pickWords(file, fm); + } + updateWords() { + this.words = extractAndUniqWords(this.wordsByCreatedPath); + this.wordsByFirstLetterByKey = indexingWords(this.words); + } + clearWords() { + this.wordsByCreatedPath = {}; + this.words = []; + this.wordsByFirstLetterByKey = {}; + } + get wordCount() { + return this.words.length; + } +} + +const neverUsedHandler = (..._args) => []; +class SpecificMatchStrategy { + constructor(name, handler) { + this.name = name; + this.handler = handler; + SpecificMatchStrategy._values.push(this); + } + static fromName(name) { + return SpecificMatchStrategy._values.find((x) => x.name === name); + } + static values() { + return SpecificMatchStrategy._values; + } +} +SpecificMatchStrategy._values = []; +SpecificMatchStrategy.INHERIT = new SpecificMatchStrategy("inherit", neverUsedHandler); +SpecificMatchStrategy.PREFIX = new SpecificMatchStrategy("prefix", suggestWords); +SpecificMatchStrategy.PARTIAL = new SpecificMatchStrategy("partial", suggestWordsByPartialMatch); + +const SEC = 1000; +const MIN = SEC * 60; +const HOUR = MIN * 60; +const DAY = HOUR * 24; +const WEEK = DAY * 7; +function calcScore(history) { + if (!history) { + return 0; + } + const behind = Date.now() - history.lastUpdated; + // noinspection IfStatementWithTooManyBranchesJS + if (behind < MIN) { + return 8 * history.count; + } + else if (behind < HOUR) { + return 4 * history.count; + } + else if (behind < DAY) { + return 2 * history.count; + } + else if (behind < WEEK) { + return 0.5 * history.count; + } + else { + return 0.25 * history.count; + } +} +class SelectionHistoryStorage { + constructor(data = {}) { + this.data = data; + const now = Date.now(); + this.version = now; + this.persistedVersion = now; + } + // noinspection FunctionWithMultipleLoopsJS + purge() { + for (const hit of Object.keys(this.data)) { + for (const value of Object.keys(this.data[hit])) { + for (const kind of Object.keys(this.data[hit][value])) { + if (Date.now() - this.data[hit][value][kind].lastUpdated > 4 * WEEK) { + delete this.data[hit][value][kind]; + } + } + if (Object.isEmpty(this.data[hit][value])) { + delete this.data[hit][value]; + } + } + if (Object.isEmpty(this.data[hit])) { + delete this.data[hit]; + } + } + } + getSelectionHistory(word) { + var _a, _b; + return (_b = (_a = this.data[word.hit]) === null || _a === void 0 ? void 0 : _a[word.value]) === null || _b === void 0 ? void 0 : _b[word.type]; + } + increment(word) { + if (!this.data[word.hit]) { + this.data[word.hit] = {}; + } + if (!this.data[word.hit][word.value]) { + this.data[word.hit][word.value] = {}; + } + if (this.data[word.hit][word.value][word.type]) { + this.data[word.hit][word.value][word.type] = { + count: this.data[word.hit][word.value][word.type].count + 1, + lastUpdated: Date.now(), + }; + } + else { + this.data[word.hit][word.value][word.type] = { + count: 1, + lastUpdated: Date.now(), + }; + } + this.version = Date.now(); + } + compare(w1, w2) { + const score1 = calcScore(this.getSelectionHistory(w1)); + const score2 = calcScore(this.getSelectionHistory(w2)); + if (score1 === score2) { + return 0; + } + return score1 > score2 ? -1 : 1; + } + get shouldPersist() { + return this.version > this.persistedVersion; + } + syncPersistVersion() { + this.persistedVersion = this.version; + } +} + +function buildLogMessage(message, msec) { + return `${message}: ${Math.round(msec)}[ms]`; +} +class AutoCompleteSuggest extends obsidian.EditorSuggest { + constructor(app, statusBar) { + super(app); + this.previousCurrentLine = ""; + this.keymapEventHandler = []; + this.appHelper = new AppHelper(app); + this.statusBar = statusBar; + } + triggerComplete() { + const editor = this.appHelper.getCurrentEditor(); + const activeFile = this.app.workspace.getActiveFile(); + if (!editor || !activeFile) { + return; + } + // XXX: Unsafe + this.runManually = true; + this.trigger(editor, activeFile, true); + } + static new(app, settings, statusBar, onPersistSelectionHistory) { + return __awaiter(this, void 0, void 0, function* () { + const ins = new AutoCompleteSuggest(app, statusBar); + ins.currentFileWordProvider = new CurrentFileWordProvider(ins.app, ins.appHelper); + ins.currentVaultWordProvider = new CurrentVaultWordProvider(ins.app, ins.appHelper); + ins.customDictionaryWordProvider = new CustomDictionaryWordProvider(ins.app, ins.appHelper); + ins.internalLinkWordProvider = new InternalLinkWordProvider(ins.app, ins.appHelper); + ins.frontMatterWordProvider = new FrontMatterWordProvider(ins.app, ins.appHelper); + ins.selectionHistoryStorage = new SelectionHistoryStorage(settings.selectionHistoryTree); + ins.selectionHistoryStorage.purge(); + yield ins.updateSettings(settings); + ins.modifyEventRef = app.vault.on("modify", (_) => __awaiter(this, void 0, void 0, function* () { + var _a; + yield ins.refreshCurrentFileTokens(); + if ((_a = ins.selectionHistoryStorage) === null || _a === void 0 ? void 0 : _a.shouldPersist) { + ins.settings.selectionHistoryTree = ins.selectionHistoryStorage.data; + ins.selectionHistoryStorage.syncPersistVersion(); + onPersistSelectionHistory(); + } + })); + ins.activeLeafChangeRef = app.workspace.on("active-leaf-change", (_) => __awaiter(this, void 0, void 0, function* () { + yield ins.refreshCurrentFileTokens(); + ins.refreshInternalLinkTokens(); + ins.updateFrontMatterToken(); + })); + ins.metadataCacheChangeRef = app.metadataCache.on("changed", (f) => { + ins.updateFrontMatterTokenIndex(f); + if (!ins.appHelper.isActiveFile(f)) { + ins.updateFrontMatterToken(); + } + }); + // Avoid referring to incorrect cache + const cacheResolvedRef = app.metadataCache.on("resolved", () => __awaiter(this, void 0, void 0, function* () { + ins.refreshInternalLinkTokens(); + ins.refreshFrontMatterTokens(); + // noinspection ES6MissingAwait + ins.refreshCustomDictionaryTokens(); + // noinspection ES6MissingAwait + ins.refreshCurrentVaultTokens(); + ins.app.metadataCache.offref(cacheResolvedRef); + })); + return ins; + }); + } + predictableComplete() { + const editor = this.appHelper.getCurrentEditor(); + if (!editor) { + return; + } + const cursor = editor.getCursor(); + const currentToken = this.tokenizer + .tokenize(editor.getLine(cursor.line).slice(0, cursor.ch)) + .last(); + if (!currentToken) { + return; + } + let suggestion = this.tokenizer + .tokenize(editor.getRange({ line: Math.max(cursor.line - 50, 0), ch: 0 }, cursor)) + .reverse() + .slice(1) + .find((x) => x.startsWith(currentToken)); + if (!suggestion) { + suggestion = this.tokenizer + .tokenize(editor.getRange(cursor, { + line: Math.min(cursor.line + 50, editor.lineCount() - 1), + ch: 0, + })) + .find((x) => x.startsWith(currentToken)); + } + if (!suggestion) { + return; + } + editor.replaceRange(suggestion, { line: cursor.line, ch: cursor.ch - currentToken.length }, { line: cursor.line, ch: cursor.ch }); + this.close(); + this.debounceClose(); + } + unregister() { + this.app.vault.offref(this.modifyEventRef); + this.app.workspace.offref(this.activeLeafChangeRef); + this.app.metadataCache.offref(this.metadataCacheChangeRef); + } + // settings getters + get tokenizerStrategy() { + return TokenizeStrategy.fromName(this.settings.strategy); + } + get matchStrategy() { + return MatchStrategy.fromName(this.settings.matchStrategy); + } + get frontMatterComplementStrategy() { + return SpecificMatchStrategy.fromName(this.settings.frontMatterComplementMatchStrategy); + } + get minNumberTriggered() { + return (this.settings.minNumberOfCharactersTriggered || + this.tokenizerStrategy.triggerThreshold); + } + get currentFileMinNumberOfCharacters() { + return (this.settings.currentFileMinNumberOfCharacters || + this.tokenizerStrategy.indexingThreshold); + } + get currentVaultMinNumberOfCharacters() { + return (this.settings.currentVaultMinNumberOfCharacters || + this.tokenizerStrategy.indexingThreshold); + } + get descriptionOnSuggestion() { + return DescriptionOnSuggestion.fromName(this.settings.descriptionOnSuggestion); + } + get excludeInternalLinkPrefixPathPatterns() { + return this.settings.excludeInternalLinkPathPrefixPatterns + .split("\n") + .filter((x) => x); + } + // --- end --- + get indexedWords() { + return { + currentFile: this.currentFileWordProvider.wordsByFirstLetter, + currentVault: this.currentVaultWordProvider.wordsByFirstLetter, + customDictionary: this.customDictionaryWordProvider.wordsByFirstLetter, + internalLink: this.internalLinkWordProvider.wordsByFirstLetter, + frontMatter: this.frontMatterWordProvider.wordsByFirstLetterByKey, + }; + } + updateSettings(settings) { + return __awaiter(this, void 0, void 0, function* () { + this.settings = settings; + this.statusBar.setMatchStrategy(this.matchStrategy); + this.statusBar.setComplementAutomatically(this.settings.complementAutomatically); + try { + this.tokenizer = yield createTokenizer(this.tokenizerStrategy, this.app); + } + catch (e) { + new obsidian.Notice(e.message, 0); + } + this.currentFileWordProvider.setSettings(this.tokenizer); + this.currentVaultWordProvider.setSettings(this.tokenizer, settings.includeCurrentVaultPathPrefixPatterns + .split("\n") + .filter((x) => x), settings.excludeCurrentVaultPathPrefixPatterns + .split("\n") + .filter((x) => x), settings.includeCurrentVaultOnlyFilesUnderCurrentDirectory); + this.customDictionaryWordProvider.setSettings(settings.customDictionaryPaths.split("\n").filter((x) => x), ColumnDelimiter.fromName(settings.columnDelimiter), settings.delimiterToDivideSuggestionsForDisplayFromInsertion || null); + this.debounceGetSuggestions = obsidian.debounce((context, cb) => { + const start = performance.now(); + this.showDebugLog(() => `[context.query]: ${context.query}`); + const parsedQuery = JSON.parse(context.query); + const words = parsedQuery.queries + .filter((x, i, xs) => parsedQuery.currentFrontMatter || + (this.settings.minNumberOfWordsTriggeredPhrase + i - 1 < + xs.length && + x.word.length >= this.minNumberTriggered && + !x.word.endsWith(" "))) + .map((q) => { + const handler = parsedQuery.currentFrontMatter && + this.frontMatterComplementStrategy !== + SpecificMatchStrategy.INHERIT + ? this.frontMatterComplementStrategy.handler + : this.matchStrategy.handler; + return handler(this.indexedWords, q.word, this.settings.maxNumberOfSuggestions, { + frontMatter: parsedQuery.currentFrontMatter, + selectionHistoryStorage: this.selectionHistoryStorage, + }).map((word) => (Object.assign(Object.assign({}, word), { offset: q.offset }))); + }) + .flat(); + cb(uniqWith(words, (a, b) => a.value === b.value && a.type === b.type).slice(0, this.settings.maxNumberOfSuggestions)); + this.showDebugLog(() => buildLogMessage("Get suggestions", performance.now() - start)); + }, this.settings.delayMilliSeconds, true); + this.debounceClose = obsidian.debounce(() => { + this.close(); + }, this.settings.delayMilliSeconds + 50); + this.registerKeymaps(); + }); + } + registerKeymaps() { + const registerKeyAsIgnored = (modifiers, key) => { + this.keymapEventHandler.push(this.scope.register(modifiers, key, () => { + this.close(); + return true; + })); + }; + // Clear + this.keymapEventHandler.forEach((x) => this.scope.unregister(x)); + this.keymapEventHandler = []; + this.scope.unregister(this.scope.keys.find((x) => x.key === "Enter")); + this.scope.unregister(this.scope.keys.find((x) => x.key === "ArrowUp")); + this.scope.unregister(this.scope.keys.find((x) => x.key === "ArrowDown")); + // selectSuggestionKeys + const selectSuggestionKey = SelectSuggestionKey.fromName(this.settings.selectSuggestionKeys); + if (selectSuggestionKey !== SelectSuggestionKey.ENTER) { + registerKeyAsIgnored(SelectSuggestionKey.ENTER.keyBind.modifiers, SelectSuggestionKey.ENTER.keyBind.key); + } + if (selectSuggestionKey !== SelectSuggestionKey.TAB) { + registerKeyAsIgnored(SelectSuggestionKey.TAB.keyBind.modifiers, SelectSuggestionKey.TAB.keyBind.key); + } + if (selectSuggestionKey !== SelectSuggestionKey.None) { + this.keymapEventHandler.push(this.scope.register(selectSuggestionKey.keyBind.modifiers, selectSuggestionKey.keyBind.key, () => { + this.suggestions.useSelectedItem({}); + return false; + })); + } + // propagateESC + this.scope.keys.find((x) => x.key === "Escape").func = () => { + this.close(); + return this.settings.propagateEsc; + }; + // cycleThroughSuggestionsKeys + const selectNext = () => { + this.suggestions.setSelectedItem(this.suggestions.selectedItem + 1, true); + return false; + }; + const selectPrevious = () => { + this.suggestions.setSelectedItem(this.suggestions.selectedItem - 1, true); + return false; + }; + const cycleThroughSuggestionsKeys = CycleThroughSuggestionsKeys.fromName(this.settings.additionalCycleThroughSuggestionsKeys); + if (this.settings.disableUpDownKeysForCycleThroughSuggestionsKeys) { + this.keymapEventHandler.push(this.scope.register([], "ArrowDown", () => { + this.close(); + return true; + }), this.scope.register([], "ArrowUp", () => { + this.close(); + return true; + })); + } + else { + this.keymapEventHandler.push(this.scope.register([], "ArrowDown", selectNext), this.scope.register([], "ArrowUp", selectPrevious)); + } + if (cycleThroughSuggestionsKeys !== CycleThroughSuggestionsKeys.NONE) { + if (cycleThroughSuggestionsKeys === CycleThroughSuggestionsKeys.TAB) { + this.scope.unregister(this.scope.keys.find((x) => x.modifiers === "" && x.key === "Tab")); + } + this.keymapEventHandler.push(this.scope.register(cycleThroughSuggestionsKeys.nextKey.modifiers, cycleThroughSuggestionsKeys.nextKey.key, selectNext), this.scope.register(cycleThroughSuggestionsKeys.previousKey.modifiers, cycleThroughSuggestionsKeys.previousKey.key, selectPrevious)); + } + const openSourceFileKey = OpenSourceFileKeys.fromName(this.settings.openSourceFileKey); + if (openSourceFileKey !== OpenSourceFileKeys.NONE) { + this.keymapEventHandler.push(this.scope.register(openSourceFileKey.keyBind.modifiers, openSourceFileKey.keyBind.key, () => { + const item = this.suggestions.values[this.suggestions.selectedItem]; + if (item.type !== "currentVault" && + item.type !== "internalLink" && + item.type !== "frontMatter") { + return false; + } + const markdownFile = this.appHelper.getMarkdownFileByPath(item.createdPath); + if (!markdownFile) { + // noinspection ObjectAllocationIgnored + new obsidian.Notice(`Can't open ${item.createdPath}`); + return false; + } + this.appHelper.openMarkdownFile(markdownFile, true); + return false; + })); + } + } + refreshCurrentFileTokens() { + return __awaiter(this, void 0, void 0, function* () { + const start = performance.now(); + this.statusBar.setCurrentFileIndexing(); + if (!this.settings.enableCurrentFileComplement) { + this.statusBar.setCurrentFileDisabled(); + this.currentFileWordProvider.clearWords(); + this.showDebugLog(() => buildLogMessage("👢 Skip: Index current file tokens", performance.now() - start)); + return; + } + yield this.currentFileWordProvider.refreshWords(this.settings.onlyComplementEnglishOnCurrentFileComplement, this.currentFileMinNumberOfCharacters); + this.statusBar.setCurrentFileIndexed(this.currentFileWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Index current file tokens", performance.now() - start)); + }); + } + refreshCurrentVaultTokens() { + return __awaiter(this, void 0, void 0, function* () { + const start = performance.now(); + this.statusBar.setCurrentVaultIndexing(); + if (!this.settings.enableCurrentVaultComplement) { + this.statusBar.setCurrentVaultDisabled(); + this.currentVaultWordProvider.clearWords(); + this.showDebugLog(() => buildLogMessage("👢 Skip: Index current vault tokens", performance.now() - start)); + return; + } + yield this.currentVaultWordProvider.refreshWords(this.currentVaultMinNumberOfCharacters); + this.statusBar.setCurrentVaultIndexed(this.currentVaultWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Index current vault tokens", performance.now() - start)); + }); + } + refreshCustomDictionaryTokens() { + return __awaiter(this, void 0, void 0, function* () { + const start = performance.now(); + this.statusBar.setCustomDictionaryIndexing(); + if (!this.settings.enableCustomDictionaryComplement) { + this.statusBar.setCustomDictionaryDisabled(); + this.customDictionaryWordProvider.clearWords(); + this.showDebugLog(() => buildLogMessage("👢Skip: Index custom dictionary tokens", performance.now() - start)); + return; + } + yield this.customDictionaryWordProvider.refreshCustomWords({ + regexp: this.settings.customDictionaryWordRegexPattern, + delimiterForHide: this.settings.delimiterToHideSuggestion || undefined, + delimiterForDisplay: this.settings.delimiterToDivideSuggestionsForDisplayFromInsertion || + undefined, + caretSymbol: this.settings.caretLocationSymbolAfterComplement || undefined, + }); + this.statusBar.setCustomDictionaryIndexed(this.customDictionaryWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Index custom dictionary tokens", performance.now() - start)); + }); + } + refreshInternalLinkTokens() { + const start = performance.now(); + this.statusBar.setInternalLinkIndexing(); + if (!this.settings.enableInternalLinkComplement) { + this.statusBar.setInternalLinkDisabled(); + this.internalLinkWordProvider.clearWords(); + this.showDebugLog(() => buildLogMessage("👢Skip: Index internal link tokens", performance.now() - start)); + return; + } + this.internalLinkWordProvider.refreshWords(this.settings.suggestInternalLinkWithAlias, this.excludeInternalLinkPrefixPathPatterns); + this.statusBar.setInternalLinkIndexed(this.internalLinkWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Index internal link tokens", performance.now() - start)); + } + refreshFrontMatterTokens() { + const start = performance.now(); + this.statusBar.setFrontMatterIndexing(); + if (!this.settings.enableFrontMatterComplement) { + this.statusBar.setFrontMatterDisabled(); + this.frontMatterWordProvider.clearWords(); + this.showDebugLog(() => buildLogMessage("👢Skip: Index front matter tokens", performance.now() - start)); + return; + } + this.frontMatterWordProvider.refreshWords(); + this.statusBar.setFrontMatterIndexed(this.frontMatterWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Index front matter tokens", performance.now() - start)); + } + updateFrontMatterTokenIndex(file) { + const start = performance.now(); + if (!this.settings.enableFrontMatterComplement) { + this.showDebugLog(() => buildLogMessage("👢Skip: Update front matter token index", performance.now() - start)); + return; + } + this.frontMatterWordProvider.updateWordIndex(file); + this.showDebugLog(() => buildLogMessage("Update front matter token index", performance.now() - start)); + } + updateFrontMatterToken() { + const start = performance.now(); + if (!this.settings.enableFrontMatterComplement) { + this.showDebugLog(() => buildLogMessage("👢Skip: Update front matter token", performance.now() - start)); + return; + } + this.frontMatterWordProvider.updateWords(); + this.statusBar.setFrontMatterIndexed(this.frontMatterWordProvider.wordCount); + this.showDebugLog(() => buildLogMessage("Update front matter token", performance.now() - start)); + } + onTrigger(cursor, editor, file) { + var _a, _b, _c, _d, _e, _f; + const start = performance.now(); + const showDebugLog = (message) => { + this.showDebugLog(() => `[onTrigger] ${message}`); + }; + const onReturnNull = (message) => { + showDebugLog(message); + this.runManually = false; + this.close(); + }; + if (!this.settings.complementAutomatically && + !this.isOpen && + !this.runManually) { + onReturnNull("Don't show suggestions"); + return null; + } + if (this.settings.disableSuggestionsDuringImeOn && + this.appHelper.isIMEOn() && + !this.runManually) { + onReturnNull("Don't show suggestions for IME"); + return null; + } + const cl = this.appHelper.getCurrentLine(editor); + if (this.previousCurrentLine === cl && !this.runManually) { + this.previousCurrentLine = cl; + onReturnNull("Don't show suggestions because there are no changes"); + return null; + } + this.previousCurrentLine = cl; + const currentLineUntilCursor = this.appHelper.getCurrentLineUntilCursor(editor); + if (currentLineUntilCursor.startsWith("---")) { + onReturnNull("Don't show suggestions because it supposes front matter or horizontal line"); + return null; + } + if (currentLineUntilCursor.startsWith("~~~") || + currentLineUntilCursor.startsWith("```")) { + onReturnNull("Don't show suggestions because it supposes front code block"); + return null; + } + const tokens = this.tokenizer.tokenize(currentLineUntilCursor, true); + showDebugLog(`tokens is ${tokens}`); + const tokenized = this.tokenizer.recursiveTokenize(currentLineUntilCursor); + const currentTokens = tokenized.slice(tokenized.length > this.settings.maxNumberOfWordsAsPhrase + ? tokenized.length - this.settings.maxNumberOfWordsAsPhrase + : 0); + showDebugLog(`currentTokens is ${JSON.stringify(currentTokens)}`); + const currentToken = (_a = currentTokens[0]) === null || _a === void 0 ? void 0 : _a.word; + showDebugLog(`currentToken is ${currentToken}`); + if (!currentToken) { + onReturnNull(`Don't show suggestions because currentToken is empty`); + return null; + } + const currentTokenSeparatedWhiteSpace = (_b = currentLineUntilCursor.split(" ").last()) !== null && _b !== void 0 ? _b : ""; + if (new RegExp(`^[${this.settings.firstCharactersDisableSuggestions}]`).test(currentTokenSeparatedWhiteSpace)) { + onReturnNull(`Don't show suggestions for avoiding to conflict with the other commands.`); + return null; + } + if (currentToken.length === 1 && + Boolean(currentToken.match(this.tokenizer.getTrimPattern()))) { + onReturnNull(`Don't show suggestions because currentToken is TRIM_PATTERN`); + return null; + } + const currentFrontMatter = this.settings.enableFrontMatterComplement + ? this.appHelper.getCurrentFrontMatter() + : undefined; + showDebugLog(`Current front matter is ${currentFrontMatter}`); + if (!this.runManually && + !currentFrontMatter && + currentToken.length < this.minNumberTriggered) { + onReturnNull("Don't show suggestions because currentToken is less than minNumberTriggered option"); + return null; + } + showDebugLog(buildLogMessage("onTrigger", performance.now() - start)); + this.runManually = false; + // Hack implementation for Front matter complement + if (currentFrontMatter && ((_c = currentTokens.last()) === null || _c === void 0 ? void 0 : _c.word.match(/[^ ] $/))) { + currentTokens.push({ word: "", offset: currentLineUntilCursor.length }); + } + // For multi-word completion + this.contextStartCh = cursor.ch - currentToken.length; + return { + start: { + ch: cursor.ch - ((_f = (_e = (_d = currentTokens.last()) === null || _d === void 0 ? void 0 : _d.word) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0), + line: cursor.line, + }, + end: cursor, + query: JSON.stringify({ + currentFrontMatter, + queries: currentTokens.map((x) => (Object.assign(Object.assign({}, x), { offset: x.offset - currentTokens[0].offset }))), + }), + }; + } + getSuggestions(context) { + return new Promise((resolve) => { + this.debounceGetSuggestions(context, (words) => { + resolve(words); + }); + }); + } + renderSuggestion(word, el) { + const base = createDiv(); + let text = word.value; + if (word.type === "customDictionary" && + word.insertedText && + this.settings.displayedTextSuffix) { + text += this.settings.displayedTextSuffix; + } + base.createDiv({ + text, + cls: word.type === "internalLink" && word.aliasMeta + ? "various-complements__suggestion-item__content__alias" + : undefined, + }); + const description = this.descriptionOnSuggestion.toDisplay(word); + if (description) { + base.createDiv({ + cls: "various-complements__suggestion-item__description", + text: `${description}`, + }); + } + el.appendChild(base); + el.addClass("various-complements__suggestion-item"); + switch (word.type) { + case "currentFile": + el.addClass("various-complements__suggestion-item__current-file"); + break; + case "currentVault": + el.addClass("various-complements__suggestion-item__current-vault"); + break; + case "customDictionary": + el.addClass("various-complements__suggestion-item__custom-dictionary"); + break; + case "internalLink": + el.addClass("various-complements__suggestion-item__internal-link"); + if (word.phantom) { + el.addClass("various-complements__suggestion-item__phantom"); + } + break; + case "frontMatter": + el.addClass("various-complements__suggestion-item__front-matter"); + break; + } + } + selectSuggestion(word, evt) { + var _a, _b; + if (!this.context) { + return; + } + let insertedText = word.value; + if (word.type === "internalLink") { + if (this.settings.suggestInternalLinkWithAlias && word.aliasMeta) { + const linkText = this.appHelper.optimizeMarkdownLinkText(word.aliasMeta.origin); + insertedText = this.appHelper.useWikiLinks + ? `[[${linkText}|${word.value}]]` + : `[${word.value}](${linkText}.md)`; + } + else { + const linkText = this.appHelper.optimizeMarkdownLinkText(word.value); + insertedText = this.appHelper.useWikiLinks + ? `[[${linkText}]]` + : `[${linkText}](${linkText}.md)`; + } + } + if (word.type === "frontMatter" && + this.settings.insertCommaAfterFrontMatterCompletion) { + insertedText = `${insertedText}, `; + } + else { + if (this.settings.insertAfterCompletion && + !(word.type === "customDictionary" && word.ignoreSpaceAfterCompletion)) { + insertedText = `${insertedText} `; + } + } + let positionToMove = -1; + if (word.type === "customDictionary") { + if (word.insertedText) { + insertedText = word.insertedText; + } + const caret = word.caretSymbol; + if (caret) { + positionToMove = insertedText.indexOf(caret); + insertedText = insertedText.replace(caret, ""); + } + } + const editor = this.context.editor; + editor.replaceRange(insertedText, Object.assign(Object.assign({}, this.context.start), { ch: this.contextStartCh + word.offset }), this.context.end); + if (positionToMove !== -1) { + editor.setCursor(editor.offsetToPos(editor.posToOffset(editor.getCursor()) - + insertedText.length + + positionToMove)); + } + // The workaround of strange behavior for that cursor doesn't move after completion only if it doesn't input any word. + if (this.appHelper.equalsAsEditorPostion(this.context.start, this.context.end)) { + editor.setCursor(editor.offsetToPos(editor.posToOffset(editor.getCursor()) + insertedText.length)); + } + (_a = this.selectionHistoryStorage) === null || _a === void 0 ? void 0 : _a.increment(word); + if (this.settings.showLogAboutPerformanceInConsole) { + console.log("--- history ---"); + console.log((_b = this.selectionHistoryStorage) === null || _b === void 0 ? void 0 : _b.data); + } + this.close(); + this.debounceClose(); + } + showDebugLog(toMessage) { + if (this.settings.showLogAboutPerformanceInConsole) { + console.log(toMessage()); + } + } +} + +const DEFAULT_SETTINGS = { + // general + strategy: "default", + matchStrategy: "prefix", + maxNumberOfSuggestions: 5, + maxNumberOfWordsAsPhrase: 3, + minNumberOfCharactersTriggered: 0, + minNumberOfWordsTriggeredPhrase: 1, + complementAutomatically: true, + delayMilliSeconds: 0, + disableSuggestionsDuringImeOn: false, + insertAfterCompletion: true, + firstCharactersDisableSuggestions: ":/^", + // appearance + showMatchStrategy: true, + showComplementAutomatically: true, + showIndexingStatus: true, + descriptionOnSuggestion: "Short", + // key customization + selectSuggestionKeys: "Enter", + additionalCycleThroughSuggestionsKeys: "None", + disableUpDownKeysForCycleThroughSuggestionsKeys: false, + openSourceFileKey: "None", + propagateEsc: false, + // current file complement + enableCurrentFileComplement: true, + currentFileMinNumberOfCharacters: 0, + onlyComplementEnglishOnCurrentFileComplement: false, + // current vault complement + enableCurrentVaultComplement: false, + currentVaultMinNumberOfCharacters: 0, + includeCurrentVaultPathPrefixPatterns: "", + excludeCurrentVaultPathPrefixPatterns: "", + includeCurrentVaultOnlyFilesUnderCurrentDirectory: false, + // custom dictionary complement + enableCustomDictionaryComplement: false, + customDictionaryPaths: `https://raw.githubusercontent.com/first20hours/google-10000-english/master/google-10000-english-no-swears.txt`, + columnDelimiter: "Tab", + customDictionaryWordRegexPattern: "", + delimiterToHideSuggestion: "", + delimiterToDivideSuggestionsForDisplayFromInsertion: "", + caretLocationSymbolAfterComplement: "", + displayedTextSuffix: " => ...", + // internal link complement + enableInternalLinkComplement: true, + suggestInternalLinkWithAlias: false, + excludeInternalLinkPathPrefixPatterns: "", + // front matter complement + enableFrontMatterComplement: true, + frontMatterComplementMatchStrategy: "inherit", + insertCommaAfterFrontMatterCompletion: false, + // debug + showLogAboutPerformanceInConsole: false, + // others + selectionHistoryTree: {}, +}; +class VariousComplementsSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Various Complements - Settings" }); + this.addMainSettings(containerEl); + this.addAppearanceSettings(containerEl); + this.addKeyCustomizationSettings(containerEl); + this.addCurrentFileComplementSettings(containerEl); + this.addCurrentVaultComplementSettings(containerEl); + this.addCustomDictionaryComplementSettings(containerEl); + this.addInternalLinkComplementSettings(containerEl); + this.addFrontMatterComplementSettings(containerEl); + this.addDebugSettings(containerEl); + } + addMainSettings(containerEl) { + containerEl.createEl("h3", { text: "Main" }); + new obsidian.Setting(containerEl).setName("Strategy").addDropdown((tc) => tc + .addOptions(mirrorMap(TokenizeStrategy.values(), (x) => x.name)) + .setValue(this.plugin.settings.strategy) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.strategy = value; + this.display(); + yield this.plugin.saveSettings({ + currentFile: true, + currentVault: true, + }); + }))); + if (this.plugin.settings.strategy === TokenizeStrategy.CHINESE.name) { + const el = containerEl.createEl("div", { + cls: "various-complements__settings__warning", + }); + el.createSpan({ + text: "⚠ You need to download `cedict_ts.u8` from", + }); + el.createEl("a", { + href: "https://www.mdbg.net/chinese/dictionary?page=cc-cedict", + text: " the site ", + }); + el.createSpan({ + text: "and store it in vault root.", + }); + } + new obsidian.Setting(containerEl).setName("Match strategy").addDropdown((tc) => tc + .addOptions(mirrorMap(MatchStrategy.values(), (x) => x.name)) + .setValue(this.plugin.settings.matchStrategy) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.matchStrategy = value; + yield this.plugin.saveSettings(); + this.display(); + }))); + if (this.plugin.settings.matchStrategy === MatchStrategy.PARTIAL.name) { + containerEl.createEl("div", { + text: "⚠ `partial` is more than 10 times slower than `prefix`", + cls: "various-complements__settings__warning", + }); + } + new obsidian.Setting(containerEl) + .setName("Max number of suggestions") + .addSlider((sc) => sc + .setLimits(1, 255, 1) + .setValue(this.plugin.settings.maxNumberOfSuggestions) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.maxNumberOfSuggestions = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Max number of words as a phrase") + .setDesc(`[⚠Warning] It makes slower more than N times (N is set value)`) + .addSlider((sc) => sc + .setLimits(1, 10, 1) + .setValue(this.plugin.settings.maxNumberOfWordsAsPhrase) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.maxNumberOfWordsAsPhrase = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Min number of characters for trigger") + .setDesc("It uses a default value of Strategy if set 0.") + .addSlider((sc) => sc + .setLimits(0, 10, 1) + .setValue(this.plugin.settings.minNumberOfCharactersTriggered) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.minNumberOfCharactersTriggered = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Min number of words for trigger") + .addSlider((sc) => sc + .setLimits(1, 10, 1) + .setValue(this.plugin.settings.minNumberOfWordsTriggeredPhrase) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.minNumberOfWordsTriggeredPhrase = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Complement automatically") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.complementAutomatically).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.complementAutomatically = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Delay milli-seconds for trigger") + .addSlider((sc) => sc + .setLimits(0, 1000, 10) + .setValue(this.plugin.settings.delayMilliSeconds) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.delayMilliSeconds = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Disable suggestions during IME on") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.disableSuggestionsDuringImeOn).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.disableSuggestionsDuringImeOn = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Insert space after completion") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.insertAfterCompletion).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.insertAfterCompletion = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("First characters to disable suggestions") + .addText((cb) => { + cb.setValue(this.plugin.settings.firstCharactersDisableSuggestions).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.firstCharactersDisableSuggestions = value; + yield this.plugin.saveSettings(); + })); + }); + } + addAppearanceSettings(containerEl) { + containerEl.createEl("h3", { text: "Appearance" }); + new obsidian.Setting(containerEl) + .setName("Show Match strategy") + .setDesc("Show Match strategy at the status bar. Changing this option requires a restart to take effect.") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.showMatchStrategy).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.showMatchStrategy = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Show Complement automatically") + .setDesc("Show complement automatically at the status bar. Changing this option requires a restart to take effect.") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.showComplementAutomatically).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.showComplementAutomatically = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Show Indexing status") + .setDesc("Show indexing status at the status bar. Changing this option requires a restart to take effect.") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.showIndexingStatus).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.showIndexingStatus = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Description on a suggestion") + .addDropdown((tc) => tc + .addOptions(mirrorMap(DescriptionOnSuggestion.values(), (x) => x.name)) + .setValue(this.plugin.settings.descriptionOnSuggestion) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.descriptionOnSuggestion = value; + yield this.plugin.saveSettings(); + }))); + } + addKeyCustomizationSettings(containerEl) { + containerEl.createEl("h3", { text: "Key customization" }); + new obsidian.Setting(containerEl) + .setName("Select a suggestion key") + .addDropdown((tc) => tc + .addOptions(mirrorMap(SelectSuggestionKey.values(), (x) => x.name)) + .setValue(this.plugin.settings.selectSuggestionKeys) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.selectSuggestionKeys = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Additional cycle through suggestions keys") + .addDropdown((tc) => tc + .addOptions(mirrorMap(CycleThroughSuggestionsKeys.values(), (x) => x.name)) + .setValue(this.plugin.settings.additionalCycleThroughSuggestionsKeys) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.additionalCycleThroughSuggestionsKeys = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Disable the up/down keys for cycle through suggestions keys") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.disableUpDownKeysForCycleThroughSuggestionsKeys).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.disableUpDownKeysForCycleThroughSuggestionsKeys = + value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl).setName("Open source file key").addDropdown((tc) => tc + .addOptions(mirrorMap(OpenSourceFileKeys.values(), (x) => x.name)) + .setValue(this.plugin.settings.openSourceFileKey) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.openSourceFileKey = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Propagate ESC") + .setDesc("It is handy if you use Vim mode because you can switch to Normal mode by one ESC, whether it shows suggestions or not.") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.propagateEsc).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.propagateEsc = value; + yield this.plugin.saveSettings(); + })); + }); + } + addCurrentFileComplementSettings(containerEl) { + containerEl.createEl("h3", { + text: "Current file complement", + cls: "various-complements__settings__header various-complements__settings__header__current-file", + }); + new obsidian.Setting(containerEl) + .setName("Enable Current file complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.enableCurrentFileComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableCurrentFileComplement = value; + yield this.plugin.saveSettings({ currentFile: true }); + this.display(); + })); + }); + if (this.plugin.settings.enableCurrentFileComplement) { + new obsidian.Setting(containerEl) + .setName("Min number of characters for indexing") + .setDesc("It uses a default value of Strategy if set 0.") + .addSlider((sc) => sc + .setLimits(0, 15, 1) + .setValue(this.plugin.settings.currentFileMinNumberOfCharacters) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.currentFileMinNumberOfCharacters = value; + yield this.plugin.saveSettings({ currentFile: true }); + }))); + new obsidian.Setting(containerEl) + .setName("Only complement English on current file complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.onlyComplementEnglishOnCurrentFileComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.onlyComplementEnglishOnCurrentFileComplement = + value; + yield this.plugin.saveSettings({ currentFile: true }); + })); + }); + } + } + addCurrentVaultComplementSettings(containerEl) { + containerEl.createEl("h3", { + text: "Current vault complement", + cls: "various-complements__settings__header various-complements__settings__header__current-vault", + }); + new obsidian.Setting(containerEl) + .setName("Enable Current vault complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.enableCurrentVaultComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableCurrentVaultComplement = value; + this.display(); + yield this.plugin.saveSettings({ currentVault: true }); + })); + }); + if (this.plugin.settings.enableCurrentVaultComplement) { + new obsidian.Setting(containerEl) + .setName("Min number of characters for indexing") + .setDesc("It uses a default value of Strategy if set 0.") + .addSlider((sc) => sc + .setLimits(0, 15, 1) + .setValue(this.plugin.settings.currentVaultMinNumberOfCharacters) + .setDynamicTooltip() + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.currentVaultMinNumberOfCharacters = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Include prefix path patterns") + .setDesc("Prefix match path patterns to include files.") + .addTextArea((tac) => { + const el = tac + .setValue(this.plugin.settings.includeCurrentVaultPathPrefixPatterns) + .setPlaceholder("Private/") + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.includeCurrentVaultPathPrefixPatterns = + value; + yield this.plugin.saveSettings(); + })); + el.inputEl.className = + "various-complements__settings__text-area-path"; + return el; + }); + new obsidian.Setting(containerEl) + .setName("Exclude prefix path patterns") + .setDesc("Prefix match path patterns to exclude files.") + .addTextArea((tac) => { + const el = tac + .setValue(this.plugin.settings.excludeCurrentVaultPathPrefixPatterns) + .setPlaceholder("Private/") + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.excludeCurrentVaultPathPrefixPatterns = + value; + yield this.plugin.saveSettings(); + })); + el.inputEl.className = + "various-complements__settings__text-area-path"; + return el; + }); + new obsidian.Setting(containerEl) + .setName("Include only files under current directory") + .addToggle((tc) => { + tc.setValue(this.plugin.settings + .includeCurrentVaultOnlyFilesUnderCurrentDirectory).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.includeCurrentVaultOnlyFilesUnderCurrentDirectory = + value; + yield this.plugin.saveSettings(); + })); + }); + } + } + addCustomDictionaryComplementSettings(containerEl) { + containerEl.createEl("h3", { + text: "Custom dictionary complement", + cls: "various-complements__settings__header various-complements__settings__header__custom-dictionary", + }); + new obsidian.Setting(containerEl) + .setName("Enable Custom dictionary complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.enableCustomDictionaryComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableCustomDictionaryComplement = value; + yield this.plugin.saveSettings({ customDictionary: true }); + this.display(); + })); + }); + if (this.plugin.settings.enableCustomDictionaryComplement) { + new obsidian.Setting(containerEl) + .setName("Custom dictionary paths") + .setDesc("Specify either a relative path from Vault root or URL for each line.") + .addTextArea((tac) => { + const el = tac + .setValue(this.plugin.settings.customDictionaryPaths) + .setPlaceholder("dictionary.md") + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.customDictionaryPaths = value; + yield this.plugin.saveSettings(); + })); + el.inputEl.className = + "various-complements__settings__text-area-path"; + return el; + }); + new obsidian.Setting(containerEl).setName("Column delimiter").addDropdown((tc) => tc + .addOptions(mirrorMap(ColumnDelimiter.values(), (x) => x.name)) + .setValue(this.plugin.settings.columnDelimiter) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.columnDelimiter = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Word regex pattern") + .setDesc("Only load words that match the regular expression pattern.") + .addText((cb) => { + cb.setValue(this.plugin.settings.customDictionaryWordRegexPattern).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.customDictionaryWordRegexPattern = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Delimiter to hide a suggestion") + .setDesc("If set ';;;', 'abcd;;;efg' is shown as 'abcd' on suggestions, but completes to 'abcdefg'.") + .addText((cb) => { + cb.setValue(this.plugin.settings.delimiterToHideSuggestion).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.delimiterToHideSuggestion = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Delimiter to divide suggestions for display from ones for insertion") + .setDesc("If set ' >>> ', 'displayed >>> inserted' is shown as 'displayed' on suggestions, but completes to 'inserted'.") + .addText((cb) => { + cb.setValue(this.plugin.settings + .delimiterToDivideSuggestionsForDisplayFromInsertion).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.delimiterToDivideSuggestionsForDisplayFromInsertion = + value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Caret location symbol after complement") + .setDesc("If set '' and there is '
    • ' in custom dictionary, it complements '
  • ' and move a caret where between '
  • ' and `
    • `.") + .addText((cb) => { + cb.setValue(this.plugin.settings.caretLocationSymbolAfterComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.caretLocationSymbolAfterComplement = value; + yield this.plugin.saveSettings(); + })); + }); + new obsidian.Setting(containerEl) + .setName("Displayed text suffix") + .setDesc("It shows as a suffix of displayed text if there is a difference between displayed and inserted") + .addText((cb) => { + cb.setValue(this.plugin.settings.displayedTextSuffix).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.displayedTextSuffix = value; + yield this.plugin.saveSettings(); + })); + }); + } + } + addInternalLinkComplementSettings(containerEl) { + containerEl.createEl("h3", { + text: "Internal link complement", + cls: "various-complements__settings__header various-complements__settings__header__internal-link", + }); + new obsidian.Setting(containerEl) + .setName("Enable Internal link complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.enableInternalLinkComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableInternalLinkComplement = value; + yield this.plugin.saveSettings({ internalLink: true }); + this.display(); + })); + }); + if (this.plugin.settings.enableInternalLinkComplement) { + new obsidian.Setting(containerEl) + .setName("Suggest with an alias") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.suggestInternalLinkWithAlias).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.suggestInternalLinkWithAlias = value; + yield this.plugin.saveSettings({ internalLink: true }); + })); + }); + new obsidian.Setting(containerEl) + .setName("Exclude prefix path patterns") + .setDesc("Prefix match path patterns to exclude files.") + .addTextArea((tac) => { + const el = tac + .setValue(this.plugin.settings.excludeInternalLinkPathPrefixPatterns) + .setPlaceholder("Private/") + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.excludeInternalLinkPathPrefixPatterns = + value; + yield this.plugin.saveSettings(); + })); + el.inputEl.className = + "various-complements__settings__text-area-path"; + return el; + }); + } + } + addFrontMatterComplementSettings(containerEl) { + containerEl.createEl("h3", { + text: "Front matter complement", + cls: "various-complements__settings__header various-complements__settings__header__front-matter", + }); + new obsidian.Setting(containerEl) + .setName("Enable Front matter complement") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.enableFrontMatterComplement).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableFrontMatterComplement = value; + yield this.plugin.saveSettings({ frontMatter: true }); + this.display(); + })); + }); + if (this.plugin.settings.enableFrontMatterComplement) { + new obsidian.Setting(containerEl) + .setName("Match strategy in the front matter") + .addDropdown((tc) => tc + .addOptions(mirrorMap(SpecificMatchStrategy.values(), (x) => x.name)) + .setValue(this.plugin.settings.frontMatterComplementMatchStrategy) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.frontMatterComplementMatchStrategy = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Insert comma after completion") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.insertCommaAfterFrontMatterCompletion).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.insertCommaAfterFrontMatterCompletion = value; + yield this.plugin.saveSettings(); + })); + }); + } + } + addDebugSettings(containerEl) { + containerEl.createEl("h3", { text: "Debug" }); + new obsidian.Setting(containerEl) + .setName("Show log about performance in a console") + .addToggle((tc) => { + tc.setValue(this.plugin.settings.showLogAboutPerformanceInConsole).onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.showLogAboutPerformanceInConsole = value; + yield this.plugin.saveSettings(); + })); + }); + } + toggleMatchStrategy() { + return __awaiter(this, void 0, void 0, function* () { + switch (this.plugin.settings.matchStrategy) { + case "prefix": + this.plugin.settings.matchStrategy = "partial"; + break; + case "partial": + this.plugin.settings.matchStrategy = "prefix"; + break; + default: + // noinspection ObjectAllocationIgnored + new obsidian.Notice("⚠Unexpected error"); + } + yield this.plugin.saveSettings(); + }); + } + toggleComplementAutomatically() { + return __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.complementAutomatically = + !this.plugin.settings.complementAutomatically; + yield this.plugin.saveSettings(); + }); + } + ensureCustomDictionaryPath(path, state) { + return __awaiter(this, void 0, void 0, function* () { + const paths = this.plugin.settings.customDictionaryPaths.split("\n"); + const exists = paths.some((x) => x === path); + if ((exists && state === "present") || (!exists && state === "absent")) { + return false; + } + const newPaths = state === "present" ? [...paths, path] : paths.filter((x) => x !== path); + this.plugin.settings.customDictionaryPaths = newPaths.join("\n"); + yield this.plugin.saveSettings({ customDictionary: true }); + return true; + }); + } + getPluginSettingsAsJsonString() { + return JSON.stringify({ + version: this.plugin.manifest.version, + mobile: this.app.isMobile, + settings: Object.assign(Object.assign({}, this.plugin.settings), { selectionHistoryTree: null }), + }, null, 4); + } +} + +class ProviderStatusBar { + constructor(currentFile, currentVault, customDictionary, internalLink, frontMatter, matchStrategy, complementAutomatically) { + this.currentFile = currentFile; + this.currentVault = currentVault; + this.customDictionary = customDictionary; + this.internalLink = internalLink; + this.frontMatter = frontMatter; + this.matchStrategy = matchStrategy; + this.complementAutomatically = complementAutomatically; + } + static new(statusBar, showMatchStrategy, showIndexingStatus, showComplementAutomatically) { + const currentFile = showIndexingStatus + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__current-file", + }) + : null; + const currentVault = showIndexingStatus + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__current-vault", + }) + : null; + const customDictionary = showIndexingStatus + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__custom-dictionary", + }) + : null; + const internalLink = showIndexingStatus + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__internal-link", + }) + : null; + const frontMatter = showIndexingStatus + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__front-matter", + }) + : null; + const matchStrategy = showMatchStrategy + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__match-strategy", + }) + : null; + const complementAutomatically = showComplementAutomatically + ? statusBar.createEl("span", { + text: "---", + cls: "various-complements__footer various-complements__footer__complement-automatically", + }) + : null; + return new ProviderStatusBar(currentFile, currentVault, customDictionary, internalLink, frontMatter, matchStrategy, complementAutomatically); + } + setOnClickStrategyListener(listener) { + var _a; + (_a = this.matchStrategy) === null || _a === void 0 ? void 0 : _a.addEventListener("click", listener); + } + setOnClickComplementAutomatically(listener) { + var _a; + (_a = this.complementAutomatically) === null || _a === void 0 ? void 0 : _a.addEventListener("click", listener); + } + setCurrentFileDisabled() { + var _a; + (_a = this.currentFile) === null || _a === void 0 ? void 0 : _a.setText("---"); + } + setCurrentVaultDisabled() { + var _a; + (_a = this.currentVault) === null || _a === void 0 ? void 0 : _a.setText("---"); + } + setCustomDictionaryDisabled() { + var _a; + (_a = this.customDictionary) === null || _a === void 0 ? void 0 : _a.setText("---"); + } + setInternalLinkDisabled() { + var _a; + (_a = this.internalLink) === null || _a === void 0 ? void 0 : _a.setText("---"); + } + setFrontMatterDisabled() { + var _a; + (_a = this.frontMatter) === null || _a === void 0 ? void 0 : _a.setText("---"); + } + setCurrentFileIndexing() { + var _a; + (_a = this.currentFile) === null || _a === void 0 ? void 0 : _a.setText("indexing..."); + } + setCurrentVaultIndexing() { + var _a; + (_a = this.currentVault) === null || _a === void 0 ? void 0 : _a.setText("indexing..."); + } + setCustomDictionaryIndexing() { + var _a; + (_a = this.customDictionary) === null || _a === void 0 ? void 0 : _a.setText("indexing..."); + } + setInternalLinkIndexing() { + var _a; + (_a = this.internalLink) === null || _a === void 0 ? void 0 : _a.setText("indexing..."); + } + setFrontMatterIndexing() { + var _a; + (_a = this.frontMatter) === null || _a === void 0 ? void 0 : _a.setText("indexing..."); + } + setCurrentFileIndexed(count) { + var _a; + (_a = this.currentFile) === null || _a === void 0 ? void 0 : _a.setText(String(count)); + } + setCurrentVaultIndexed(count) { + var _a; + (_a = this.currentVault) === null || _a === void 0 ? void 0 : _a.setText(String(count)); + } + setCustomDictionaryIndexed(count) { + var _a; + (_a = this.customDictionary) === null || _a === void 0 ? void 0 : _a.setText(String(count)); + } + setInternalLinkIndexed(count) { + var _a; + (_a = this.internalLink) === null || _a === void 0 ? void 0 : _a.setText(String(count)); + } + setFrontMatterIndexed(count) { + var _a; + (_a = this.frontMatter) === null || _a === void 0 ? void 0 : _a.setText(String(count)); + } + setMatchStrategy(strategy) { + var _a; + (_a = this.matchStrategy) === null || _a === void 0 ? void 0 : _a.setText(strategy.name); + } + setComplementAutomatically(automatically) { + var _a; + (_a = this.complementAutomatically) === null || _a === void 0 ? void 0 : _a.setText(automatically ? "auto" : "manual"); + } +} + +function noop() { } +function assign(tar, src) { + // @ts-ignore + for (const k in src) + tar[k] = src[k]; + return tar; +} +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 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_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_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 get_all_dirty_from_scope($$scope) { + if ($$scope.ctx.length > 32) { + const dirty = []; + const length = $$scope.ctx.length / 32; + for (let i = 0; i < length; i++) { + dirty[i] = -1; + } + return dirty; + } + return -1; +} +function exclude_internal_props(props) { + const result = {}; + for (const k in props) + if (k[0] !== '$') + result[k] = props[k]; + return result; +} +function compute_rest_props(props, keys) { + const rest = {}; + keys = new Set(keys); + for (const k in props) + if (!keys.has(k) && k[0] !== '$') + rest[k] = props[k]; + return rest; +} +function null_to_empty(value) { + return value == null ? '' : value; +} +function append(target, node) { + target.appendChild(node); +} +function append_styles(target, style_sheet_id, styles) { + const append_styles_to = get_root_for_style(target); + if (!append_styles_to.getElementById(style_sheet_id)) { + const style = element('style'); + style.id = style_sheet_id; + style.textContent = styles; + append_stylesheet(append_styles_to, style); + } +} +function get_root_for_style(node) { + if (!node) + return document; + const root = node.getRootNode ? node.getRootNode() : node.ownerDocument; + if (root && root.host) { + return root; + } + return node.ownerDocument; +} +function append_stylesheet(node, style) { + append(node.head || node, style); +} +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 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_svg_attributes(node, attributes) { + for (const key in attributes) { + 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 set_input_value(input, value) { + input.value = value == null ? '' : value; +} +function set_style(node, key, value, important) { + if (value === null) { + node.style.removeProperty(key); + } + else { + node.style.setProperty(key, value, important ? 'important' : ''); + } +} +function select_option(select, value) { + for (let i = 0; i < select.options.length; i += 1) { + const option = select.options[i]; + if (option.__value === value) { + option.selected = true; + return; + } + } + select.selectedIndex = -1; // no option should be selected +} +function select_value(select) { + const selected_option = select.querySelector(':checked') || select.options[0]; + return selected_option && selected_option.__value; +} +function toggle_class(element, name, toggle) { + element.classList[toggle ? 'add' : 'remove'](name); +} +function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) { + const e = document.createEvent('CustomEvent'); + e.initCustomEvent(type, bubbles, cancelable, detail); + return e; +} + +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; +} +function onMount(fn) { + get_current_component().$$.on_mount.push(fn); +} +function createEventDispatcher() { + const component = get_current_component(); + return (type, detail, { cancelable = false } = {}) => { + const callbacks = component.$$.callbacks[type]; + if (callbacks) { + // TODO are there situations where events could be dispatched + // in a server (non-DOM) environment? + const event = custom_event(type, detail, { cancelable }); + callbacks.slice().forEach(fn => { + fn.call(component, event); + }); + return !event.defaultPrevented; + } + return true; + }; +} + +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); +} +// flush() calls callbacks in this order: +// 1. All beforeUpdate callbacks, in order: parents before children +// 2. All bind:this callbacks, in reverse order: children before parents. +// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT +// for afterUpdates called during the initial onMount, which are called in +// reverse order: children before parents. +// Since callbacks might update component values, which could trigger another +// call to flush(), the following steps guard against this: +// 1. During beforeUpdate, any updated components will be added to the +// dirty_components array and will cause a reentrant call to flush(). Because +// the flush index is kept outside the function, the reentrant call will pick +// up where the earlier call left off and go through all dirty components. The +// current_component value is saved and restored so that the reentrant call will +// not interfere with the "parent" flush() call. +// 2. bind:this callbacks cannot trigger new flush() calls. +// 3. During afterUpdate, any updated components will NOT have their afterUpdate +// callback called a second time; the seen_callbacks set, outside the flush() +// function, guarantees this behavior. +const seen_callbacks = new Set(); +let flushidx = 0; // Do *not* move this inside the flush() function +function flush() { + const saved_component = current_component; + do { + // first, call beforeUpdate functions + // and update components + while (flushidx < dirty_components.length) { + const component = dirty_components[flushidx]; + flushidx++; + set_current_component(component); + update(component.$$); + } + set_current_component(null); + dirty_components.length = 0; + flushidx = 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; + seen_callbacks.clear(); + set_current_component(saved_component); +} +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 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); + } + else if (callback) { + callback(); + } +} + +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 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, append_styles, 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(options.context || (parent_component ? parent_component.$$.context : [])), + // everything else + callbacks: blank_object(), + dirty, + skip_bound: false, + root: options.target || parent_component.$$.root + }; + append_styles && append_styles($$.root); + 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; + } + } +} + +/* src/ui/component/ObsidianButton.svelte generated by Svelte v3.49.0 */ + +function create_fragment$3(ctx) { + let button; + let current; + let mounted; + let dispose; + const default_slot_template = /*#slots*/ ctx[4].default; + const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[3], null); + + return { + c() { + button = element("button"); + if (default_slot) default_slot.c(); + attr(button, "aria-label", /*popup*/ ctx[0]); + button.disabled = /*disabled*/ ctx[1]; + toggle_class(button, "mod-cta", !/*disabled*/ ctx[1]); + }, + m(target, anchor) { + insert(target, button, anchor); + + if (default_slot) { + default_slot.m(button, null); + } + + current = true; + + if (!mounted) { + dispose = listen(button, "click", /*handleClick*/ ctx[2]); + mounted = true; + } + }, + p(ctx, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ 8)) { + update_slot_base( + default_slot, + default_slot_template, + ctx, + /*$$scope*/ ctx[3], + !current + ? get_all_dirty_from_scope(/*$$scope*/ ctx[3]) + : get_slot_changes(default_slot_template, /*$$scope*/ ctx[3], dirty, null), + null + ); + } + } + + if (!current || dirty & /*popup*/ 1) { + attr(button, "aria-label", /*popup*/ ctx[0]); + } + + if (!current || dirty & /*disabled*/ 2) { + button.disabled = /*disabled*/ ctx[1]; + } + + if (dirty & /*disabled*/ 2) { + toggle_class(button, "mod-cta", !/*disabled*/ ctx[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 (detaching) detach(button); + if (default_slot) default_slot.d(detaching); + mounted = false; + dispose(); + } + }; +} + +function instance$3($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { popup } = $$props; + let { disabled = false } = $$props; + const dispatcher = createEventDispatcher(); + + const handleClick = () => { + dispatcher("click"); + }; + + $$self.$$set = $$props => { + if ('popup' in $$props) $$invalidate(0, popup = $$props.popup); + if ('disabled' in $$props) $$invalidate(1, disabled = $$props.disabled); + if ('$$scope' in $$props) $$invalidate(3, $$scope = $$props.$$scope); + }; + + return [popup, disabled, handleClick, $$scope, slots]; +} + +class ObsidianButton extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$3, create_fragment$3, safe_not_equal, { popup: 0, disabled: 1 }); + } +} + +/* node_modules/svelte-lucide-icons/icons/File.svelte generated by Svelte v3.49.0 */ + +function create_fragment$2(ctx) { + let svg; + let path; + let polyline; + let current; + const default_slot_template = /*#slots*/ ctx[3].default; + const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[2], null); + + let svg_levels = [ + { xmlns: "http://www.w3.org/2000/svg" }, + { width: /*size*/ ctx[0] }, + { height: /*size*/ ctx[0] }, + { viewBox: "0 0 24 24" }, + { fill: "none" }, + { stroke: "currentColor" }, + { "stroke-width": "2" }, + { "stroke-linecap": "round" }, + { "stroke-linejoin": "round" }, + /*$$restProps*/ ctx[1] + ]; + + let svg_data = {}; + + for (let i = 0; i < svg_levels.length; i += 1) { + svg_data = assign(svg_data, svg_levels[i]); + } + + return { + c() { + svg = svg_element("svg"); + if (default_slot) default_slot.c(); + path = svg_element("path"); + polyline = svg_element("polyline"); + attr(path, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"); + attr(polyline, "points", "14 2 14 8 20 8"); + set_svg_attributes(svg, svg_data); + }, + m(target, anchor) { + insert(target, svg, anchor); + + if (default_slot) { + default_slot.m(svg, null); + } + + append(svg, path); + append(svg, polyline); + current = true; + }, + p(ctx, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx, + /*$$scope*/ ctx[2], + !current + ? get_all_dirty_from_scope(/*$$scope*/ ctx[2]) + : get_slot_changes(default_slot_template, /*$$scope*/ ctx[2], dirty, null), + null + ); + } + } + + set_svg_attributes(svg, svg_data = get_spread_update(svg_levels, [ + { xmlns: "http://www.w3.org/2000/svg" }, + (!current || dirty & /*size*/ 1) && { width: /*size*/ ctx[0] }, + (!current || dirty & /*size*/ 1) && { height: /*size*/ ctx[0] }, + { viewBox: "0 0 24 24" }, + { fill: "none" }, + { stroke: "currentColor" }, + { "stroke-width": "2" }, + { "stroke-linecap": "round" }, + { "stroke-linejoin": "round" }, + dirty & /*$$restProps*/ 2 && /*$$restProps*/ ctx[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 (detaching) detach(svg); + if (default_slot) default_slot.d(detaching); + } + }; +} + +function instance$2($$self, $$props, $$invalidate) { + const omit_props_names = ["size"]; + let $$restProps = compute_rest_props($$props, omit_props_names); + let { $$slots: slots = {}, $$scope } = $$props; + let { size = 24 } = $$props; + + $$self.$$set = $$new_props => { + $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)); + $$invalidate(1, $$restProps = compute_rest_props($$props, omit_props_names)); + if ('size' in $$new_props) $$invalidate(0, size = $$new_props.size); + if ('$$scope' in $$new_props) $$invalidate(2, $$scope = $$new_props.$$scope); + }; + + return [size, $$restProps, $$scope, slots]; +} + +class File extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$2, create_fragment$2, safe_not_equal, { size: 0 }); + } +} + +/* src/ui/component/ObsidianIconButton.svelte generated by Svelte v3.49.0 */ + +function add_css(target) { + append_styles(target, "svelte-12yh6aw", ".wrapper.svelte-12yh6aw{display:flex;justify-content:center;margin:0}.button-enabled.svelte-12yh6aw:hover{color:var(--interactive-accent)}.button-disabled.svelte-12yh6aw{color:var(--text-muted)}"); +} + +function create_fragment$1(ctx) { + let div; + let button; + let button_class_value; + let current; + let mounted; + let dispose; + const default_slot_template = /*#slots*/ ctx[4].default; + const default_slot = create_slot(default_slot_template, ctx, /*$$scope*/ ctx[3], null); + + return { + c() { + div = element("div"); + button = element("button"); + if (default_slot) default_slot.c(); + attr(button, "aria-label", /*popup*/ ctx[0]); + button.disabled = /*disabled*/ ctx[1]; + + attr(button, "class", button_class_value = "" + (null_to_empty(/*disabled*/ ctx[1] + ? "button-disabled" + : "button-enabled") + " svelte-12yh6aw")); + + set_style(button, "background-color", "transparent"); + set_style(button, "padding", "0"); + attr(div, "class", "wrapper svelte-12yh6aw"); + }, + m(target, anchor) { + insert(target, div, anchor); + append(div, button); + + if (default_slot) { + default_slot.m(button, null); + } + + current = true; + + if (!mounted) { + dispose = listen(button, "click", /*handleClick*/ ctx[2]); + mounted = true; + } + }, + p(ctx, [dirty]) { + if (default_slot) { + if (default_slot.p && (!current || dirty & /*$$scope*/ 8)) { + update_slot_base( + default_slot, + default_slot_template, + ctx, + /*$$scope*/ ctx[3], + !current + ? get_all_dirty_from_scope(/*$$scope*/ ctx[3]) + : get_slot_changes(default_slot_template, /*$$scope*/ ctx[3], dirty, null), + null + ); + } + } + + if (!current || dirty & /*popup*/ 1) { + attr(button, "aria-label", /*popup*/ ctx[0]); + } + + if (!current || dirty & /*disabled*/ 2) { + button.disabled = /*disabled*/ ctx[1]; + } + + if (!current || dirty & /*disabled*/ 2 && button_class_value !== (button_class_value = "" + (null_to_empty(/*disabled*/ ctx[1] + ? "button-disabled" + : "button-enabled") + " svelte-12yh6aw"))) { + attr(button, "class", button_class_value); + } + }, + i(local) { + if (current) return; + transition_in(default_slot, local); + current = true; + }, + o(local) { + transition_out(default_slot, local); + current = false; + }, + d(detaching) { + if (detaching) detach(div); + if (default_slot) default_slot.d(detaching); + mounted = false; + dispose(); + } + }; +} + +function instance$1($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props; + let { popup } = $$props; + let { disabled = false } = $$props; + const dispatcher = createEventDispatcher(); + + const handleClick = () => { + if (!disabled) { + dispatcher("click"); + } + }; + + $$self.$$set = $$props => { + if ('popup' in $$props) $$invalidate(0, popup = $$props.popup); + if ('disabled' in $$props) $$invalidate(1, disabled = $$props.disabled); + if ('$$scope' in $$props) $$invalidate(3, $$scope = $$props.$$scope); + }; + + return [popup, disabled, handleClick, $$scope, slots]; +} + +class ObsidianIconButton extends SvelteComponent { + constructor(options) { + super(); + init(this, options, instance$1, create_fragment$1, safe_not_equal, { popup: 0, disabled: 1 }, add_css); + } +} + +/* src/ui/component/CustomDictionaryWordAdd.svelte generated by Svelte v3.49.0 */ + +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice(); + child_ctx[26] = list[i]; + return child_ctx; +} + +// (48:6) {#each dictionaries as dictionary} +function create_each_block(ctx) { + let option; + let t0_value = /*dictionary*/ ctx[26].path + ""; + let t0; + let t1; + let option_value_value; + + return { + c() { + option = element("option"); + t0 = text(t0_value); + t1 = space(); + option.__value = option_value_value = /*dictionary*/ ctx[26]; + option.value = option.__value; + }, + m(target, anchor) { + insert(target, option, anchor); + append(option, t0); + append(option, t1); + }, + p(ctx, dirty) { + if (dirty & /*dictionaries*/ 32 && t0_value !== (t0_value = /*dictionary*/ ctx[26].path + "")) set_data(t0, t0_value); + + if (dirty & /*dictionaries*/ 32 && option_value_value !== (option_value_value = /*dictionary*/ ctx[26])) { + option.__value = option_value_value; + option.value = option.__value; + } + }, + d(detaching) { + if (detaching) detach(option); + } + }; +} + +// (54:4) onClickFileIcon(selectedDictionary.path)} > +function create_default_slot_1(ctx) { + let file; + let current; + file = new File({}); + + return { + c() { + create_component(file.$$.fragment); + }, + m(target, anchor) { + mount_component(file, target, anchor); + current = true; + }, + i(local) { + if (current) return; + transition_in(file.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(file.$$.fragment, local); + current = false; + }, + d(detaching) { + destroy_component(file, detaching); + } + }; +} + +// (70:2) {#if enableDisplayedWord} +function create_if_block_1(ctx) { + let label; + let input; + let t; + let mounted; + let dispose; + + return { + c() { + label = element("label"); + input = element("input"); + t = text("\n Distinguish between display and insertion"); + attr(input, "type", "checkbox"); + }, + m(target, anchor) { + insert(target, label, anchor); + append(label, input); + input.checked = /*useDisplayedWord*/ ctx[1]; + append(label, t); + + if (!mounted) { + dispose = listen(input, "change", /*input_change_handler*/ ctx[21]); + mounted = true; + } + }, + p(ctx, dirty) { + if (dirty & /*useDisplayedWord*/ 2) { + input.checked = /*useDisplayedWord*/ ctx[1]; + } + }, + d(detaching) { + if (detaching) detach(label); + mounted = false; + dispose(); + } + }; +} + +// (77:2) {#if useDisplayedWord} +function create_if_block(ctx) { + let h3; + let t1; + let textarea; + let mounted; + let dispose; + + return { + c() { + h3 = element("h3"); + h3.textContent = "Displayed Word"; + t1 = space(); + textarea = element("textarea"); + set_style(textarea, "width", "100%"); + attr(textarea, "rows", "3"); + }, + m(target, anchor) { + insert(target, h3, anchor); + insert(target, t1, anchor); + insert(target, textarea, anchor); + set_input_value(textarea, /*displayedWord*/ ctx[3]); + /*textarea_binding*/ ctx[23](textarea); + + if (!mounted) { + dispose = listen(textarea, "input", /*textarea_input_handler*/ ctx[22]); + mounted = true; + } + }, + p(ctx, dirty) { + if (dirty & /*displayedWord*/ 8) { + set_input_value(textarea, /*displayedWord*/ ctx[3]); + } + }, + d(detaching) { + if (detaching) detach(h3); + if (detaching) detach(t1); + if (detaching) detach(textarea); + /*textarea_binding*/ ctx[23](null); + mounted = false; + dispose(); + } + }; +} + +// (94:4) +function create_default_slot(ctx) { + let t; + + return { + c() { + t = text("Submit"); + }, + m(target, anchor) { + insert(target, t, anchor); + }, + d(detaching) { + if (detaching) detach(t); + } + }; +} + +function create_fragment(ctx) { + let div2; + let h2; + let t1; + let h30; + let t3; + let div0; + let select; + let t4; + let obsidianiconbutton; + let t5; + let h31; + let t6; + let t7; + let textarea0; + let t8; + let t9; + let t10; + let h32; + let t12; + let input; + let t13; + let h33; + let t15; + let textarea1; + let t16; + let div1; + let obsidianbutton; + let current; + let mounted; + let dispose; + let each_value = /*dictionaries*/ ctx[5]; + let each_blocks = []; + + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)); + } + + obsidianiconbutton = new ObsidianIconButton({ + props: { + popup: "Open the file", + $$slots: { default: [create_default_slot_1] }, + $$scope: { ctx } + } + }); + + obsidianiconbutton.$on("click", /*click_handler*/ ctx[18]); + let if_block0 = /*enableDisplayedWord*/ ctx[11] && create_if_block_1(ctx); + let if_block1 = /*useDisplayedWord*/ ctx[1] && create_if_block(ctx); + + obsidianbutton = new ObsidianButton({ + props: { + disabled: !/*enableSubmit*/ ctx[12], + $$slots: { default: [create_default_slot] }, + $$scope: { ctx } + } + }); + + obsidianbutton.$on("click", /*handleSubmit*/ ctx[13]); + + return { + c() { + div2 = element("div"); + h2 = element("h2"); + h2.textContent = "Add a word to a custom dictionary"; + t1 = space(); + h30 = element("h3"); + h30.textContent = "Dictionary"; + t3 = space(); + div0 = element("div"); + select = element("select"); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c(); + } + + t4 = space(); + create_component(obsidianiconbutton.$$.fragment); + t5 = space(); + h31 = element("h3"); + t6 = text(/*firstWordTitle*/ ctx[10]); + t7 = space(); + textarea0 = element("textarea"); + t8 = space(); + if (if_block0) if_block0.c(); + t9 = space(); + if (if_block1) if_block1.c(); + t10 = space(); + h32 = element("h3"); + h32.textContent = "Description"; + t12 = space(); + input = element("input"); + t13 = space(); + h33 = element("h3"); + h33.textContent = "Aliases (for each line)"; + t15 = space(); + textarea1 = element("textarea"); + t16 = space(); + div1 = element("div"); + create_component(obsidianbutton.$$.fragment); + attr(select, "class", "dropdown"); + if (/*selectedDictionary*/ ctx[2] === void 0) add_render_callback(() => /*select_change_handler*/ ctx[17].call(select)); + set_style(div0, "display", "flex"); + set_style(div0, "gap", "10px"); + set_style(textarea0, "width", "100%"); + attr(textarea0, "rows", "3"); + attr(input, "type", "text"); + set_style(input, "width", "100%"); + set_style(textarea1, "width", "100%"); + attr(textarea1, "rows", "3"); + set_style(div1, "text-align", "center"); + set_style(div1, "width", "100%"); + set_style(div1, "padding-top", "15px"); + }, + m(target, anchor) { + insert(target, div2, anchor); + append(div2, h2); + append(div2, t1); + append(div2, h30); + append(div2, t3); + append(div2, div0); + append(div0, select); + + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(select, null); + } + + select_option(select, /*selectedDictionary*/ ctx[2]); + append(div0, t4); + mount_component(obsidianiconbutton, div0, null); + append(div2, t5); + append(div2, h31); + append(h31, t6); + append(div2, t7); + append(div2, textarea0); + set_input_value(textarea0, /*inputWord*/ ctx[0]); + /*textarea0_binding*/ ctx[20](textarea0); + append(div2, t8); + if (if_block0) if_block0.m(div2, null); + append(div2, t9); + if (if_block1) if_block1.m(div2, null); + append(div2, t10); + append(div2, h32); + append(div2, t12); + append(div2, input); + set_input_value(input, /*description*/ ctx[4]); + append(div2, t13); + append(div2, h33); + append(div2, t15); + append(div2, textarea1); + set_input_value(textarea1, /*aliasesStr*/ ctx[8]); + append(div2, t16); + append(div2, div1); + mount_component(obsidianbutton, div1, null); + current = true; + + if (!mounted) { + dispose = [ + listen(select, "change", /*select_change_handler*/ ctx[17]), + listen(textarea0, "input", /*textarea0_input_handler*/ ctx[19]), + listen(input, "input", /*input_input_handler*/ ctx[24]), + listen(textarea1, "input", /*textarea1_input_handler*/ ctx[25]) + ]; + + mounted = true; + } + }, + p(ctx, [dirty]) { + if (dirty & /*dictionaries*/ 32) { + each_value = /*dictionaries*/ ctx[5]; + let i; + + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx, each_value, i); + + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty); + } else { + each_blocks[i] = create_each_block(child_ctx); + each_blocks[i].c(); + each_blocks[i].m(select, null); + } + } + + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1); + } + + each_blocks.length = each_value.length; + } + + if (dirty & /*selectedDictionary, dictionaries*/ 36) { + select_option(select, /*selectedDictionary*/ ctx[2]); + } + + const obsidianiconbutton_changes = {}; + + if (dirty & /*$$scope*/ 536870912) { + obsidianiconbutton_changes.$$scope = { dirty, ctx }; + } + + obsidianiconbutton.$set(obsidianiconbutton_changes); + if (!current || dirty & /*firstWordTitle*/ 1024) set_data(t6, /*firstWordTitle*/ ctx[10]); + + if (dirty & /*inputWord*/ 1) { + set_input_value(textarea0, /*inputWord*/ ctx[0]); + } + + if (/*enableDisplayedWord*/ ctx[11]) { + if (if_block0) { + if_block0.p(ctx, dirty); + } else { + if_block0 = create_if_block_1(ctx); + if_block0.c(); + if_block0.m(div2, t9); + } + } else if (if_block0) { + if_block0.d(1); + if_block0 = null; + } + + if (/*useDisplayedWord*/ ctx[1]) { + if (if_block1) { + if_block1.p(ctx, dirty); + } else { + if_block1 = create_if_block(ctx); + if_block1.c(); + if_block1.m(div2, t10); + } + } else if (if_block1) { + if_block1.d(1); + if_block1 = null; + } + + if (dirty & /*description*/ 16 && input.value !== /*description*/ ctx[4]) { + set_input_value(input, /*description*/ ctx[4]); + } + + if (dirty & /*aliasesStr*/ 256) { + set_input_value(textarea1, /*aliasesStr*/ ctx[8]); + } + + const obsidianbutton_changes = {}; + if (dirty & /*enableSubmit*/ 4096) obsidianbutton_changes.disabled = !/*enableSubmit*/ ctx[12]; + + if (dirty & /*$$scope*/ 536870912) { + obsidianbutton_changes.$$scope = { dirty, ctx }; + } + + obsidianbutton.$set(obsidianbutton_changes); + }, + i(local) { + if (current) return; + transition_in(obsidianiconbutton.$$.fragment, local); + transition_in(obsidianbutton.$$.fragment, local); + current = true; + }, + o(local) { + transition_out(obsidianiconbutton.$$.fragment, local); + transition_out(obsidianbutton.$$.fragment, local); + current = false; + }, + d(detaching) { + if (detaching) detach(div2); + destroy_each(each_blocks, detaching); + destroy_component(obsidianiconbutton); + /*textarea0_binding*/ ctx[20](null); + if (if_block0) if_block0.d(); + if (if_block1) if_block1.d(); + destroy_component(obsidianbutton); + mounted = false; + run_all(dispose); + } + }; +} + +function instance($$self, $$props, $$invalidate) { + let enableSubmit; + let enableDisplayedWord; + let firstWordTitle; + let { dictionaries } = $$props; + let { selectedDictionary } = $$props; + let { inputWord = "" } = $$props; + let { useDisplayedWord = false } = $$props; + let { displayedWord = "" } = $$props; + let { description = "" } = $$props; + let { aliases = [] } = $$props; + let { dividerForDisplay = "" } = $$props; + let { onSubmit } = $$props; + let { onClickFileIcon } = $$props; + let aliasesStr = aliases.join("\n"); + let wordRef = null; + let displayedWordRef = null; + + const handleSubmit = () => { + onSubmit(selectedDictionary.path, { + value: displayedWord || inputWord, + description, + aliases: aliasesStr.split("\n"), + type: "customDictionary", + createdPath: selectedDictionary.path, + insertedText: displayedWord ? inputWord : undefined + }); + }; + + onMount(() => { + setTimeout(() => wordRef.focus(), 50); + }); + + function select_change_handler() { + selectedDictionary = select_value(this); + $$invalidate(2, selectedDictionary); + $$invalidate(5, dictionaries); + } + + const click_handler = () => onClickFileIcon(selectedDictionary.path); + + function textarea0_input_handler() { + inputWord = this.value; + $$invalidate(0, inputWord); + } + + function textarea0_binding($$value) { + binding_callbacks[$$value ? 'unshift' : 'push'](() => { + wordRef = $$value; + $$invalidate(9, wordRef); + }); + } + + function input_change_handler() { + useDisplayedWord = this.checked; + $$invalidate(1, useDisplayedWord); + } + + function textarea_input_handler() { + displayedWord = this.value; + $$invalidate(3, displayedWord); + } + + function textarea_binding($$value) { + binding_callbacks[$$value ? 'unshift' : 'push'](() => { + displayedWordRef = $$value; + $$invalidate(7, displayedWordRef); + }); + } + + function input_input_handler() { + description = this.value; + $$invalidate(4, description); + } + + function textarea1_input_handler() { + aliasesStr = this.value; + $$invalidate(8, aliasesStr); + } + + $$self.$$set = $$props => { + if ('dictionaries' in $$props) $$invalidate(5, dictionaries = $$props.dictionaries); + if ('selectedDictionary' in $$props) $$invalidate(2, selectedDictionary = $$props.selectedDictionary); + if ('inputWord' in $$props) $$invalidate(0, inputWord = $$props.inputWord); + if ('useDisplayedWord' in $$props) $$invalidate(1, useDisplayedWord = $$props.useDisplayedWord); + if ('displayedWord' in $$props) $$invalidate(3, displayedWord = $$props.displayedWord); + if ('description' in $$props) $$invalidate(4, description = $$props.description); + if ('aliases' in $$props) $$invalidate(14, aliases = $$props.aliases); + if ('dividerForDisplay' in $$props) $$invalidate(15, dividerForDisplay = $$props.dividerForDisplay); + if ('onSubmit' in $$props) $$invalidate(16, onSubmit = $$props.onSubmit); + if ('onClickFileIcon' in $$props) $$invalidate(6, onClickFileIcon = $$props.onClickFileIcon); + }; + + $$self.$$.update = () => { + if ($$self.$$.dirty & /*inputWord*/ 1) { + $$invalidate(12, enableSubmit = inputWord.length > 0); + } + + if ($$self.$$.dirty & /*dividerForDisplay*/ 32768) { + $$invalidate(11, enableDisplayedWord = Boolean(dividerForDisplay)); + } + + if ($$self.$$.dirty & /*useDisplayedWord*/ 2) { + $$invalidate(10, firstWordTitle = useDisplayedWord ? "Inserted word" : "Word"); + } + + if ($$self.$$.dirty & /*useDisplayedWord, displayedWordRef*/ 130) { + { + if (useDisplayedWord) { + displayedWordRef === null || displayedWordRef === void 0 + ? void 0 + : displayedWordRef.focus(); + } + } + } + }; + + return [ + inputWord, + useDisplayedWord, + selectedDictionary, + displayedWord, + description, + dictionaries, + onClickFileIcon, + displayedWordRef, + aliasesStr, + wordRef, + firstWordTitle, + enableDisplayedWord, + enableSubmit, + handleSubmit, + aliases, + dividerForDisplay, + onSubmit, + select_change_handler, + click_handler, + textarea0_input_handler, + textarea0_binding, + input_change_handler, + textarea_input_handler, + textarea_binding, + input_input_handler, + textarea1_input_handler + ]; +} + +class CustomDictionaryWordAdd extends SvelteComponent { + constructor(options) { + super(); + + init(this, options, instance, create_fragment, safe_not_equal, { + dictionaries: 5, + selectedDictionary: 2, + inputWord: 0, + useDisplayedWord: 1, + displayedWord: 3, + description: 4, + aliases: 14, + dividerForDisplay: 15, + onSubmit: 16, + onClickFileIcon: 6 + }); + } +} + +class CustomDictionaryWordAddModal extends obsidian.Modal { + constructor(app, dictionaryPaths, initialValue = "", dividerForDisplay = "", onSubmit) { + super(app); + const appHelper = new AppHelper(app); + const dictionaries = dictionaryPaths.map((x) => ({ id: x, path: x })); + const { contentEl } = this; + this.component = new CustomDictionaryWordAdd({ + target: contentEl, + props: { + dictionaries, + selectedDictionary: dictionaries[0], + inputWord: initialValue, + dividerForDisplay, + onSubmit, + onClickFileIcon: (dictionaryPath) => { + const markdownFile = appHelper.getMarkdownFileByPath(dictionaryPath); + if (!markdownFile) { + // noinspection ObjectAllocationIgnored + new obsidian.Notice(`Can't open ${dictionaryPath}`); + return; + } + this.close(); + appHelper.openMarkdownFile(markdownFile, true); + }, + }, + }); + } + onClose() { + super.onClose(); + this.component.$destroy(); + } +} + +class VariousComponents extends obsidian.Plugin { + onunload() { + super.onunload(); + this.suggester.unregister(); + } + onload() { + return __awaiter(this, void 0, void 0, function* () { + this.appHelper = new AppHelper(this.app); + this.registerEvent(this.app.workspace.on("editor-menu", (menu) => { + if (!this.appHelper.getSelection()) { + return; + } + menu.addItem((item) => item + .setTitle("Add to custom dictionary") + .setIcon("stacked-levels") + .onClick(() => { + this.addWordToCustomDictionary(); + })); + })); + yield this.loadSettings(); + this.settingTab = new VariousComplementsSettingTab(this.app, this); + this.addSettingTab(this.settingTab); + this.statusBar = ProviderStatusBar.new(this.addStatusBarItem(), this.settings.showMatchStrategy, this.settings.showIndexingStatus, this.settings.showComplementAutomatically); + this.statusBar.setOnClickStrategyListener(() => __awaiter(this, void 0, void 0, function* () { + yield this.settingTab.toggleMatchStrategy(); + })); + this.statusBar.setOnClickComplementAutomatically(() => __awaiter(this, void 0, void 0, function* () { + yield this.settingTab.toggleComplementAutomatically(); + })); + const debouncedSaveData = obsidian.debounce(() => __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }), 5000); + this.suggester = yield AutoCompleteSuggest.new(this.app, this.settings, this.statusBar, debouncedSaveData); + this.registerEditorSuggest(this.suggester); + this.addCommand({ + id: "reload-custom-dictionaries", + name: "Reload custom dictionaries", + hotkeys: [{ modifiers: ["Mod", "Shift"], key: "r" }], + callback: () => __awaiter(this, void 0, void 0, function* () { + yield this.suggester.refreshCustomDictionaryTokens(); + }), + }); + this.addCommand({ + id: "reload-current-vault", + name: "Reload current vault", + callback: () => __awaiter(this, void 0, void 0, function* () { + yield this.suggester.refreshCurrentVaultTokens(); + }), + }); + this.addCommand({ + id: "toggle-match-strategy", + name: "Toggle Match strategy", + callback: () => __awaiter(this, void 0, void 0, function* () { + yield this.settingTab.toggleMatchStrategy(); + }), + }); + this.addCommand({ + id: "toggle-complement-automatically", + name: "Toggle Complement automatically", + callback: () => __awaiter(this, void 0, void 0, function* () { + yield this.settingTab.toggleComplementAutomatically(); + }), + }); + this.addCommand({ + id: "show-suggestions", + name: "Show suggestions", + hotkeys: [{ modifiers: ["Mod"], key: " " }], + callback: () => __awaiter(this, void 0, void 0, function* () { + this.suggester.triggerComplete(); + }), + }); + this.addCommand({ + id: "add-word-custom-dictionary", + name: "Add a word to a custom dictionary", + hotkeys: [{ modifiers: ["Mod", "Shift"], key: " " }], + callback: () => __awaiter(this, void 0, void 0, function* () { + this.addWordToCustomDictionary(); + }), + }); + this.addCommand({ + id: "predictable-complements", + name: "Predictable complement", + callback: () => __awaiter(this, void 0, void 0, function* () { + this.suggester.predictableComplete(); + }), + }); + this.addCommand({ + id: "copy-plugin-settings", + name: "Copy plugin settings", + callback: () => __awaiter(this, void 0, void 0, function* () { + yield navigator.clipboard.writeText(this.settingTab.getPluginSettingsAsJsonString()); + // noinspection ObjectAllocationIgnored + new obsidian.Notice("Copy settings of Various Complements"); + }), + }); + }); + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), (yield this.loadData())); + }); + } + saveSettings(needUpdateTokens = {}) { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + yield this.suggester.updateSettings(this.settings); + if (needUpdateTokens.currentFile) { + yield this.suggester.refreshCurrentFileTokens(); + } + if (needUpdateTokens.currentVault) { + yield this.suggester.refreshCurrentVaultTokens(); + } + if (needUpdateTokens.customDictionary) { + yield this.suggester.refreshCustomDictionaryTokens(); + } + if (needUpdateTokens.internalLink) { + yield this.suggester.refreshInternalLinkTokens(); + } + if (needUpdateTokens.frontMatter) { + yield this.suggester.refreshFrontMatterTokens(); + } + }); + } + addWordToCustomDictionary() { + const selectedWord = this.appHelper.getSelection(); + const provider = this.suggester.customDictionaryWordProvider; + const modal = new CustomDictionaryWordAddModal(this.app, provider.editablePaths, selectedWord, this.settings.delimiterToDivideSuggestionsForDisplayFromInsertion, (dictionaryPath, _word) => __awaiter(this, void 0, void 0, function* () { + // TODO: If support for JSON, this implementation doesn't work correctly + const word = Object.assign(Object.assign({}, _word), { caretSymbol: this.settings.caretLocationSymbolAfterComplement }); + if (provider.wordByValue[word.value]) { + // noinspection ObjectAllocationIgnored + new obsidian.Notice(`⚠ ${word.value} already exists`, 0); + return; + } + yield provider.addWordWithDictionary(word, dictionaryPath); + // noinspection ObjectAllocationIgnored + new obsidian.Notice(`Added ${word.value}`); + modal.close(); + })); + modal.open(); + } +} + +module.exports = VariousComponents; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/util/strings.ts","src/tokenizer/tokenizers/DefaultTokenizer.ts","src/tokenizer/tokenizers/ArabicTokenizer.ts","src/external/tiny-segmenter.ts","src/tokenizer/tokenizers/JapaneseTokenizer.ts","src/tokenizer/tokenizers/EnglishOnlyTokenizer.ts","node_modules/prettify-pinyin/index.js","node_modules/chinese-tokenizer/src/trie.js","node_modules/chinese-tokenizer/src/cedict.js","node_modules/chinese-tokenizer/src/main.js","src/tokenizer/tokenizers/ChineseTokenizer.ts","src/tokenizer/tokenizer.ts","src/tokenizer/TokenizeStrategy.ts","src/app-helper.ts","src/util/collection-helper.ts","src/model/Word.ts","src/provider/suggester.ts","src/util/path.ts","src/provider/CustomDictionaryWordProvider.ts","src/provider/CurrentFileWordProvider.ts","src/provider/InternalLinkWordProvider.ts","src/provider/MatchStrategy.ts","src/option/CycleThroughSuggestionsKeys.ts","src/option/ColumnDelimiter.ts","src/option/SelectSuggestionKey.ts","src/provider/CurrentVaultWordProvider.ts","src/option/OpenSourceFileKeys.ts","src/option/DescriptionOnSuggestion.ts","src/provider/FrontMatterWordProvider.ts","src/provider/SpecificMatchStrategy.ts","src/storage/SelectionHistoryStorage.ts","src/ui/AutoCompleteSuggest.ts","src/setting/settings.ts","src/ui/ProviderStatusBar.ts","node_modules/svelte/internal/index.mjs","src/ui/component/ObsidianButton.svelte","node_modules/svelte-lucide-icons/icons/File.svelte","src/ui/component/ObsidianIconButton.svelte","src/ui/component/CustomDictionaryWordAdd.svelte","src/ui/CustomDictionaryWordAddModal.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    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\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\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","const regEmoji = new RegExp(\n  /[\\u2700-\\u27BF]|[\\uE000-\\uF8FF]|\\uD83C[\\uDC00-\\uDFFF]|\\uD83D[\\uDC00-\\uDFFF]|[\\u2011-\\u26FF]|\\uD83E[\\uDD10-\\uDDFF]|[\\uFE0E-\\uFE0F]/,\n  \"g\"\n);\n\nexport function allAlphabets(text: string): boolean {\n  return Boolean(text.match(/^[a-zA-Z0-9_-]+$/));\n}\n\nexport function excludeEmoji(text: string): string {\n  return text.replace(regEmoji, \"\");\n}\n\nexport function excludeSpace(text: string): string {\n  return text.replace(/ /g, \"\");\n}\n\nexport function lowerIncludes(one: string, other: string): boolean {\n  return one.toLowerCase().includes(other.toLowerCase());\n}\n\nexport function lowerIncludesWithoutSpace(one: string, other: string): boolean {\n  return lowerIncludes(excludeSpace(one), excludeSpace(other));\n}\n\nexport function lowerStartsWith(a: string, b: string): boolean {\n  return a.toLowerCase().startsWith(b.toLowerCase());\n}\n\nexport function lowerStartsWithoutSpace(one: string, other: string): boolean {\n  return lowerStartsWith(excludeSpace(one), excludeSpace(other));\n}\n\nexport function capitalizeFirstLetter(str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nexport function startsSmallLetterOnlyFirst(str: string): boolean {\n  return Boolean(str.match(/^[A-Z][^A-Z]+$/));\n}\n\nexport function* splitRaw(\n  text: string,\n  regexp: RegExp\n): IterableIterator<string> {\n  let previousIndex = 0;\n  for (let r of text.matchAll(regexp)) {\n    if (previousIndex !== r.index!) {\n      yield text.slice(previousIndex, r.index!);\n    }\n    yield text[r.index!];\n    previousIndex = r.index! + 1;\n  }\n\n  if (previousIndex !== text.length) {\n    yield text.slice(previousIndex, text.length);\n  }\n}\n","import type { Tokenizer } from \"../tokenizer\";\nimport { splitRaw } from \"../../util/strings\";\n\nfunction pickTokens(content: string, trimPattern: RegExp): string[] {\n  return content.split(trimPattern).filter((x) => x !== \"\");\n}\n\nexport const TRIM_CHAR_PATTERN = /[\\n\\t\\[\\]$/:?!=()<>\"'.,|;*~ `]/g;\nexport class DefaultTokenizer implements Tokenizer {\n  tokenize(content: string, raw?: boolean): string[] {\n    return raw\n      ? Array.from(splitRaw(content, this.getTrimPattern())).filter(\n          (x) => x !== \" \"\n        )\n      : pickTokens(content, this.getTrimPattern());\n  }\n\n  recursiveTokenize(content: string): { word: string; offset: number }[] {\n    const trimIndexes = Array.from(content.matchAll(this.getTrimPattern()))\n      .sort((a, b) => a.index! - b.index!)\n      .map((x) => x.index!);\n    return [\n      { word: content, offset: 0 },\n      ...trimIndexes.map((i) => ({\n        word: content.slice(i + 1),\n        offset: i + 1,\n      })),\n    ];\n  }\n\n  getTrimPattern(): RegExp {\n    return TRIM_CHAR_PATTERN;\n  }\n\n  shouldIgnoreOnCurrent(str: string): boolean {\n    return false;\n  }\n}\n","import { DefaultTokenizer } from \"./DefaultTokenizer\";\n\nconst ARABIC_TRIM_CHAR_PATTERN = /[\\n\\t\\[\\]$/:?!=()<>\"'.,|;*~ `،؛]/g;\nexport class ArabicTokenizer extends DefaultTokenizer {\n  getTrimPattern(): RegExp {\n    return ARABIC_TRIM_CHAR_PATTERN;\n  }\n}\n","// @ts-nocheck\n// Because this code is originally javascript code.\n// noinspection FunctionTooLongJS,FunctionWithMultipleLoopsJS,EqualityComparisonWithCoercionJS,PointlessBooleanExpressionJS,JSDeclarationsAtScopeStart\n\n// TinySegmenter 0.1 -- Super compact Japanese tokenizer in Javascript\n// (c) 2008 Taku Kudo <taku@chasen.org>\n// TinySegmenter is freely distributable under the terms of a new BSD licence.\n// For details, see http://chasen.org/~taku/software/TinySegmenter/LICENCE.txt\n\nfunction TinySegmenter() {\n  var patterns = {\n    \"[一二三四五六七八九十百千万億兆]\": \"M\",\n    \"[一-龠々〆ヵヶ]\": \"H\",\n    \"[ぁ-ん]\": \"I\",\n    \"[ァ-ヴーｱ-ﾝﾞｰ]\": \"K\",\n    \"[a-zA-Zａ-ｚＡ-Ｚ]\": \"A\",\n    \"[0-9０-９]\": \"N\",\n  };\n  this.chartype_ = [];\n  for (var i in patterns) {\n    var regexp = new RegExp();\n    regexp.compile(i);\n    this.chartype_.push([regexp, patterns[i]]);\n  }\n\n  this.BIAS__ = -332;\n  this.BC1__ = { HH: 6, II: 2461, KH: 406, OH: -1378 };\n  this.BC2__ = {\n    AA: -3267,\n    AI: 2744,\n    AN: -878,\n    HH: -4070,\n    HM: -1711,\n    HN: 4012,\n    HO: 3761,\n    IA: 1327,\n    IH: -1184,\n    II: -1332,\n    IK: 1721,\n    IO: 5492,\n    KI: 3831,\n    KK: -8741,\n    MH: -3132,\n    MK: 3334,\n    OO: -2920,\n  };\n  this.BC3__ = {\n    HH: 996,\n    HI: 626,\n    HK: -721,\n    HN: -1307,\n    HO: -836,\n    IH: -301,\n    KK: 2762,\n    MK: 1079,\n    MM: 4034,\n    OA: -1652,\n    OH: 266,\n  };\n  this.BP1__ = { BB: 295, OB: 304, OO: -125, UB: 352 };\n  this.BP2__ = { BO: 60, OO: -1762 };\n  this.BQ1__ = {\n    BHH: 1150,\n    BHM: 1521,\n    BII: -1158,\n    BIM: 886,\n    BMH: 1208,\n    BNH: 449,\n    BOH: -91,\n    BOO: -2597,\n    OHI: 451,\n    OIH: -296,\n    OKA: 1851,\n    OKH: -1020,\n    OKK: 904,\n    OOO: 2965,\n  };\n  this.BQ2__ = {\n    BHH: 118,\n    BHI: -1159,\n    BHM: 466,\n    BIH: -919,\n    BKK: -1720,\n    BKO: 864,\n    OHH: -1139,\n    OHM: -181,\n    OIH: 153,\n    UHI: -1146,\n  };\n  this.BQ3__ = {\n    BHH: -792,\n    BHI: 2664,\n    BII: -299,\n    BKI: 419,\n    BMH: 937,\n    BMM: 8335,\n    BNN: 998,\n    BOH: 775,\n    OHH: 2174,\n    OHM: 439,\n    OII: 280,\n    OKH: 1798,\n    OKI: -793,\n    OKO: -2242,\n    OMH: -2402,\n    OOO: 11699,\n  };\n  this.BQ4__ = {\n    BHH: -3895,\n    BIH: 3761,\n    BII: -4654,\n    BIK: 1348,\n    BKK: -1806,\n    BMI: -3385,\n    BOO: -12396,\n    OAH: 926,\n    OHH: 266,\n    OHK: -2036,\n    ONN: -973,\n  };\n  this.BW1__ = {\n    \",と\": 660,\n    \",同\": 727,\n    B1あ: 1404,\n    B1同: 542,\n    \"、と\": 660,\n    \"、同\": 727,\n    \"」と\": 1682,\n    あっ: 1505,\n    いう: 1743,\n    いっ: -2055,\n    いる: 672,\n    うし: -4817,\n    うん: 665,\n    から: 3472,\n    がら: 600,\n    こう: -790,\n    こと: 2083,\n    こん: -1262,\n    さら: -4143,\n    さん: 4573,\n    した: 2641,\n    して: 1104,\n    すで: -3399,\n    そこ: 1977,\n    それ: -871,\n    たち: 1122,\n    ため: 601,\n    った: 3463,\n    つい: -802,\n    てい: 805,\n    てき: 1249,\n    でき: 1127,\n    です: 3445,\n    では: 844,\n    とい: -4915,\n    とみ: 1922,\n    どこ: 3887,\n    ない: 5713,\n    なっ: 3015,\n    など: 7379,\n    なん: -1113,\n    にし: 2468,\n    には: 1498,\n    にも: 1671,\n    に対: -912,\n    の一: -501,\n    の中: 741,\n    ませ: 2448,\n    まで: 1711,\n    まま: 2600,\n    まる: -2155,\n    やむ: -1947,\n    よっ: -2565,\n    れた: 2369,\n    れで: -913,\n    をし: 1860,\n    を見: 731,\n    亡く: -1886,\n    京都: 2558,\n    取り: -2784,\n    大き: -2604,\n    大阪: 1497,\n    平方: -2314,\n    引き: -1336,\n    日本: -195,\n    本当: -2423,\n    毎日: -2113,\n    目指: -724,\n    Ｂ１あ: 1404,\n    Ｂ１同: 542,\n    \"｣と\": 1682,\n  };\n  this.BW2__ = {\n    \"..\": -11822,\n    11: -669,\n    \"――\": -5730,\n    \"−−\": -13175,\n    いう: -1609,\n    うか: 2490,\n    かし: -1350,\n    かも: -602,\n    から: -7194,\n    かれ: 4612,\n    がい: 853,\n    がら: -3198,\n    きた: 1941,\n    くな: -1597,\n    こと: -8392,\n    この: -4193,\n    させ: 4533,\n    され: 13168,\n    さん: -3977,\n    しい: -1819,\n    しか: -545,\n    した: 5078,\n    して: 972,\n    しな: 939,\n    その: -3744,\n    たい: -1253,\n    たた: -662,\n    ただ: -3857,\n    たち: -786,\n    たと: 1224,\n    たは: -939,\n    った: 4589,\n    って: 1647,\n    っと: -2094,\n    てい: 6144,\n    てき: 3640,\n    てく: 2551,\n    ては: -3110,\n    ても: -3065,\n    でい: 2666,\n    でき: -1528,\n    でし: -3828,\n    です: -4761,\n    でも: -4203,\n    とい: 1890,\n    とこ: -1746,\n    とと: -2279,\n    との: 720,\n    とみ: 5168,\n    とも: -3941,\n    ない: -2488,\n    なが: -1313,\n    など: -6509,\n    なの: 2614,\n    なん: 3099,\n    にお: -1615,\n    にし: 2748,\n    にな: 2454,\n    によ: -7236,\n    に対: -14943,\n    に従: -4688,\n    に関: -11388,\n    のか: 2093,\n    ので: -7059,\n    のに: -6041,\n    のの: -6125,\n    はい: 1073,\n    はが: -1033,\n    はず: -2532,\n    ばれ: 1813,\n    まし: -1316,\n    まで: -6621,\n    まれ: 5409,\n    めて: -3153,\n    もい: 2230,\n    もの: -10713,\n    らか: -944,\n    らし: -1611,\n    らに: -1897,\n    りし: 651,\n    りま: 1620,\n    れた: 4270,\n    れて: 849,\n    れば: 4114,\n    ろう: 6067,\n    われ: 7901,\n    を通: -11877,\n    んだ: 728,\n    んな: -4115,\n    一人: 602,\n    一方: -1375,\n    一日: 970,\n    一部: -1051,\n    上が: -4479,\n    会社: -1116,\n    出て: 2163,\n    分の: -7758,\n    同党: 970,\n    同日: -913,\n    大阪: -2471,\n    委員: -1250,\n    少な: -1050,\n    年度: -8669,\n    年間: -1626,\n    府県: -2363,\n    手権: -1982,\n    新聞: -4066,\n    日新: -722,\n    日本: -7068,\n    日米: 3372,\n    曜日: -601,\n    朝鮮: -2355,\n    本人: -2697,\n    東京: -1543,\n    然と: -1384,\n    社会: -1276,\n    立て: -990,\n    第に: -1612,\n    米国: -4268,\n    \"１１\": -669,\n  };\n  this.BW3__ = {\n    あた: -2194,\n    あり: 719,\n    ある: 3846,\n    \"い.\": -1185,\n    \"い。\": -1185,\n    いい: 5308,\n    いえ: 2079,\n    いく: 3029,\n    いた: 2056,\n    いっ: 1883,\n    いる: 5600,\n    いわ: 1527,\n    うち: 1117,\n    うと: 4798,\n    えと: 1454,\n    \"か.\": 2857,\n    \"か。\": 2857,\n    かけ: -743,\n    かっ: -4098,\n    かに: -669,\n    から: 6520,\n    かり: -2670,\n    \"が,\": 1816,\n    \"が、\": 1816,\n    がき: -4855,\n    がけ: -1127,\n    がっ: -913,\n    がら: -4977,\n    がり: -2064,\n    きた: 1645,\n    けど: 1374,\n    こと: 7397,\n    この: 1542,\n    ころ: -2757,\n    さい: -714,\n    さを: 976,\n    \"し,\": 1557,\n    \"し、\": 1557,\n    しい: -3714,\n    した: 3562,\n    して: 1449,\n    しな: 2608,\n    しま: 1200,\n    \"す.\": -1310,\n    \"す。\": -1310,\n    する: 6521,\n    \"ず,\": 3426,\n    \"ず、\": 3426,\n    ずに: 841,\n    そう: 428,\n    \"た.\": 8875,\n    \"た。\": 8875,\n    たい: -594,\n    たの: 812,\n    たり: -1183,\n    たる: -853,\n    \"だ.\": 4098,\n    \"だ。\": 4098,\n    だっ: 1004,\n    った: -4748,\n    って: 300,\n    てい: 6240,\n    てお: 855,\n    ても: 302,\n    です: 1437,\n    でに: -1482,\n    では: 2295,\n    とう: -1387,\n    とし: 2266,\n    との: 541,\n    とも: -3543,\n    どう: 4664,\n    ない: 1796,\n    なく: -903,\n    など: 2135,\n    \"に,\": -1021,\n    \"に、\": -1021,\n    にし: 1771,\n    にな: 1906,\n    には: 2644,\n    \"の,\": -724,\n    \"の、\": -724,\n    の子: -1000,\n    \"は,\": 1337,\n    \"は、\": 1337,\n    べき: 2181,\n    まし: 1113,\n    ます: 6943,\n    まっ: -1549,\n    まで: 6154,\n    まれ: -793,\n    らし: 1479,\n    られ: 6820,\n    るる: 3818,\n    \"れ,\": 854,\n    \"れ、\": 854,\n    れた: 1850,\n    れて: 1375,\n    れば: -3246,\n    れる: 1091,\n    われ: -605,\n    んだ: 606,\n    んで: 798,\n    カ月: 990,\n    会議: 860,\n    入り: 1232,\n    大会: 2217,\n    始め: 1681,\n    市: 965,\n    新聞: -5055,\n    \"日,\": 974,\n    \"日、\": 974,\n    社会: 2024,\n    ｶ月: 990,\n  };\n  this.TC1__ = {\n    AAA: 1093,\n    HHH: 1029,\n    HHM: 580,\n    HII: 998,\n    HOH: -390,\n    HOM: -331,\n    IHI: 1169,\n    IOH: -142,\n    IOI: -1015,\n    IOM: 467,\n    MMH: 187,\n    OOI: -1832,\n  };\n  this.TC2__ = {\n    HHO: 2088,\n    HII: -1023,\n    HMM: -1154,\n    IHI: -1965,\n    KKH: 703,\n    OII: -2649,\n  };\n  this.TC3__ = {\n    AAA: -294,\n    HHH: 346,\n    HHI: -341,\n    HII: -1088,\n    HIK: 731,\n    HOH: -1486,\n    IHH: 128,\n    IHI: -3041,\n    IHO: -1935,\n    IIH: -825,\n    IIM: -1035,\n    IOI: -542,\n    KHH: -1216,\n    KKA: 491,\n    KKH: -1217,\n    KOK: -1009,\n    MHH: -2694,\n    MHM: -457,\n    MHO: 123,\n    MMH: -471,\n    NNH: -1689,\n    NNO: 662,\n    OHO: -3393,\n  };\n  this.TC4__ = {\n    HHH: -203,\n    HHI: 1344,\n    HHK: 365,\n    HHM: -122,\n    HHN: 182,\n    HHO: 669,\n    HIH: 804,\n    HII: 679,\n    HOH: 446,\n    IHH: 695,\n    IHO: -2324,\n    IIH: 321,\n    III: 1497,\n    IIO: 656,\n    IOO: 54,\n    KAK: 4845,\n    KKA: 3386,\n    KKK: 3065,\n    MHH: -405,\n    MHI: 201,\n    MMH: -241,\n    MMM: 661,\n    MOM: 841,\n  };\n  this.TQ1__ = {\n    BHHH: -227,\n    BHHI: 316,\n    BHIH: -132,\n    BIHH: 60,\n    BIII: 1595,\n    BNHH: -744,\n    BOHH: 225,\n    BOOO: -908,\n    OAKK: 482,\n    OHHH: 281,\n    OHIH: 249,\n    OIHI: 200,\n    OIIH: -68,\n  };\n  this.TQ2__ = { BIHH: -1401, BIII: -1033, BKAK: -543, BOOO: -5591 };\n  this.TQ3__ = {\n    BHHH: 478,\n    BHHM: -1073,\n    BHIH: 222,\n    BHII: -504,\n    BIIH: -116,\n    BIII: -105,\n    BMHI: -863,\n    BMHM: -464,\n    BOMH: 620,\n    OHHH: 346,\n    OHHI: 1729,\n    OHII: 997,\n    OHMH: 481,\n    OIHH: 623,\n    OIIH: 1344,\n    OKAK: 2792,\n    OKHH: 587,\n    OKKA: 679,\n    OOHH: 110,\n    OOII: -685,\n  };\n  this.TQ4__ = {\n    BHHH: -721,\n    BHHM: -3604,\n    BHII: -966,\n    BIIH: -607,\n    BIII: -2181,\n    OAAA: -2763,\n    OAKK: 180,\n    OHHH: -294,\n    OHHI: 2446,\n    OHHO: 480,\n    OHIH: -1573,\n    OIHH: 1935,\n    OIHI: -493,\n    OIIH: 626,\n    OIII: -4007,\n    OKAK: -8156,\n  };\n  this.TW1__ = { につい: -4681, 東京都: 2026 };\n  this.TW2__ = {\n    ある程: -2049,\n    いった: -1256,\n    ころが: -2434,\n    しょう: 3873,\n    その後: -4430,\n    だって: -1049,\n    ていた: 1833,\n    として: -4657,\n    ともに: -4517,\n    もので: 1882,\n    一気に: -792,\n    初めて: -1512,\n    同時に: -8097,\n    大きな: -1255,\n    対して: -2721,\n    社会党: -3216,\n  };\n  this.TW3__ = {\n    いただ: -1734,\n    してい: 1314,\n    として: -4314,\n    につい: -5483,\n    にとっ: -5989,\n    に当た: -6247,\n    \"ので,\": -727,\n    \"ので、\": -727,\n    のもの: -600,\n    れから: -3752,\n    十二月: -2287,\n  };\n  this.TW4__ = {\n    \"いう.\": 8576,\n    \"いう。\": 8576,\n    からな: -2348,\n    してい: 2958,\n    \"たが,\": 1516,\n    \"たが、\": 1516,\n    ている: 1538,\n    という: 1349,\n    ました: 5543,\n    ません: 1097,\n    ようと: -4258,\n    よると: 5865,\n  };\n  this.UC1__ = { A: 484, K: 93, M: 645, O: -505 };\n  this.UC2__ = { A: 819, H: 1059, I: 409, M: 3987, N: 5775, O: 646 };\n  this.UC3__ = { A: -1370, I: 2311 };\n  this.UC4__ = {\n    A: -2643,\n    H: 1809,\n    I: -1032,\n    K: -3450,\n    M: 3565,\n    N: 3876,\n    O: 6646,\n  };\n  this.UC5__ = { H: 313, I: -1238, K: -799, M: 539, O: -831 };\n  this.UC6__ = { H: -506, I: -253, K: 87, M: 247, O: -387 };\n  this.UP1__ = { O: -214 };\n  this.UP2__ = { B: 69, O: 935 };\n  this.UP3__ = { B: 189 };\n  this.UQ1__ = {\n    BH: 21,\n    BI: -12,\n    BK: -99,\n    BN: 142,\n    BO: -56,\n    OH: -95,\n    OI: 477,\n    OK: 410,\n    OO: -2422,\n  };\n  this.UQ2__ = { BH: 216, BI: 113, OK: 1759 };\n  this.UQ3__ = {\n    BA: -479,\n    BH: 42,\n    BI: 1913,\n    BK: -7198,\n    BM: 3160,\n    BN: 6427,\n    BO: 14761,\n    OI: -827,\n    ON: -3212,\n  };\n  this.UW1__ = {\n    \",\": 156,\n    \"、\": 156,\n    \"「\": -463,\n    あ: -941,\n    う: -127,\n    が: -553,\n    き: 121,\n    こ: 505,\n    で: -201,\n    と: -547,\n    ど: -123,\n    に: -789,\n    の: -185,\n    は: -847,\n    も: -466,\n    や: -470,\n    よ: 182,\n    ら: -292,\n    り: 208,\n    れ: 169,\n    を: -446,\n    ん: -137,\n    \"・\": -135,\n    主: -402,\n    京: -268,\n    区: -912,\n    午: 871,\n    国: -460,\n    大: 561,\n    委: 729,\n    市: -411,\n    日: -141,\n    理: 361,\n    生: -408,\n    県: -386,\n    都: -718,\n    \"｢\": -463,\n    \"･\": -135,\n  };\n  this.UW2__ = {\n    \",\": -829,\n    \"、\": -829,\n    〇: 892,\n    \"「\": -645,\n    \"」\": 3145,\n    あ: -538,\n    い: 505,\n    う: 134,\n    お: -502,\n    か: 1454,\n    が: -856,\n    く: -412,\n    こ: 1141,\n    さ: 878,\n    ざ: 540,\n    し: 1529,\n    す: -675,\n    せ: 300,\n    そ: -1011,\n    た: 188,\n    だ: 1837,\n    つ: -949,\n    て: -291,\n    で: -268,\n    と: -981,\n    ど: 1273,\n    な: 1063,\n    に: -1764,\n    の: 130,\n    は: -409,\n    ひ: -1273,\n    べ: 1261,\n    ま: 600,\n    も: -1263,\n    や: -402,\n    よ: 1639,\n    り: -579,\n    る: -694,\n    れ: 571,\n    を: -2516,\n    ん: 2095,\n    ア: -587,\n    カ: 306,\n    キ: 568,\n    ッ: 831,\n    三: -758,\n    不: -2150,\n    世: -302,\n    中: -968,\n    主: -861,\n    事: 492,\n    人: -123,\n    会: 978,\n    保: 362,\n    入: 548,\n    初: -3025,\n    副: -1566,\n    北: -3414,\n    区: -422,\n    大: -1769,\n    天: -865,\n    太: -483,\n    子: -1519,\n    学: 760,\n    実: 1023,\n    小: -2009,\n    市: -813,\n    年: -1060,\n    強: 1067,\n    手: -1519,\n    揺: -1033,\n    政: 1522,\n    文: -1355,\n    新: -1682,\n    日: -1815,\n    明: -1462,\n    最: -630,\n    朝: -1843,\n    本: -1650,\n    東: -931,\n    果: -665,\n    次: -2378,\n    民: -180,\n    気: -1740,\n    理: 752,\n    発: 529,\n    目: -1584,\n    相: -242,\n    県: -1165,\n    立: -763,\n    第: 810,\n    米: 509,\n    自: -1353,\n    行: 838,\n    西: -744,\n    見: -3874,\n    調: 1010,\n    議: 1198,\n    込: 3041,\n    開: 1758,\n    間: -1257,\n    \"｢\": -645,\n    \"｣\": 3145,\n    ｯ: 831,\n    ｱ: -587,\n    ｶ: 306,\n    ｷ: 568,\n  };\n  this.UW3__ = {\n    \",\": 4889,\n    1: -800,\n    \"−\": -1723,\n    \"、\": 4889,\n    々: -2311,\n    〇: 5827,\n    \"」\": 2670,\n    \"〓\": -3573,\n    あ: -2696,\n    い: 1006,\n    う: 2342,\n    え: 1983,\n    お: -4864,\n    か: -1163,\n    が: 3271,\n    く: 1004,\n    け: 388,\n    げ: 401,\n    こ: -3552,\n    ご: -3116,\n    さ: -1058,\n    し: -395,\n    す: 584,\n    せ: 3685,\n    そ: -5228,\n    た: 842,\n    ち: -521,\n    っ: -1444,\n    つ: -1081,\n    て: 6167,\n    で: 2318,\n    と: 1691,\n    ど: -899,\n    な: -2788,\n    に: 2745,\n    の: 4056,\n    は: 4555,\n    ひ: -2171,\n    ふ: -1798,\n    へ: 1199,\n    ほ: -5516,\n    ま: -4384,\n    み: -120,\n    め: 1205,\n    も: 2323,\n    や: -788,\n    よ: -202,\n    ら: 727,\n    り: 649,\n    る: 5905,\n    れ: 2773,\n    わ: -1207,\n    を: 6620,\n    ん: -518,\n    ア: 551,\n    グ: 1319,\n    ス: 874,\n    ッ: -1350,\n    ト: 521,\n    ム: 1109,\n    ル: 1591,\n    ロ: 2201,\n    ン: 278,\n    \"・\": -3794,\n    一: -1619,\n    下: -1759,\n    世: -2087,\n    両: 3815,\n    中: 653,\n    主: -758,\n    予: -1193,\n    二: 974,\n    人: 2742,\n    今: 792,\n    他: 1889,\n    以: -1368,\n    低: 811,\n    何: 4265,\n    作: -361,\n    保: -2439,\n    元: 4858,\n    党: 3593,\n    全: 1574,\n    公: -3030,\n    六: 755,\n    共: -1880,\n    円: 5807,\n    再: 3095,\n    分: 457,\n    初: 2475,\n    別: 1129,\n    前: 2286,\n    副: 4437,\n    力: 365,\n    動: -949,\n    務: -1872,\n    化: 1327,\n    北: -1038,\n    区: 4646,\n    千: -2309,\n    午: -783,\n    協: -1006,\n    口: 483,\n    右: 1233,\n    各: 3588,\n    合: -241,\n    同: 3906,\n    和: -837,\n    員: 4513,\n    国: 642,\n    型: 1389,\n    場: 1219,\n    外: -241,\n    妻: 2016,\n    学: -1356,\n    安: -423,\n    実: -1008,\n    家: 1078,\n    小: -513,\n    少: -3102,\n    州: 1155,\n    市: 3197,\n    平: -1804,\n    年: 2416,\n    広: -1030,\n    府: 1605,\n    度: 1452,\n    建: -2352,\n    当: -3885,\n    得: 1905,\n    思: -1291,\n    性: 1822,\n    戸: -488,\n    指: -3973,\n    政: -2013,\n    教: -1479,\n    数: 3222,\n    文: -1489,\n    新: 1764,\n    日: 2099,\n    旧: 5792,\n    昨: -661,\n    時: -1248,\n    曜: -951,\n    最: -937,\n    月: 4125,\n    期: 360,\n    李: 3094,\n    村: 364,\n    東: -805,\n    核: 5156,\n    森: 2438,\n    業: 484,\n    氏: 2613,\n    民: -1694,\n    決: -1073,\n    法: 1868,\n    海: -495,\n    無: 979,\n    物: 461,\n    特: -3850,\n    生: -273,\n    用: 914,\n    町: 1215,\n    的: 7313,\n    直: -1835,\n    省: 792,\n    県: 6293,\n    知: -1528,\n    私: 4231,\n    税: 401,\n    立: -960,\n    第: 1201,\n    米: 7767,\n    系: 3066,\n    約: 3663,\n    級: 1384,\n    統: -4229,\n    総: 1163,\n    線: 1255,\n    者: 6457,\n    能: 725,\n    自: -2869,\n    英: 785,\n    見: 1044,\n    調: -562,\n    財: -733,\n    費: 1777,\n    車: 1835,\n    軍: 1375,\n    込: -1504,\n    通: -1136,\n    選: -681,\n    郎: 1026,\n    郡: 4404,\n    部: 1200,\n    金: 2163,\n    長: 421,\n    開: -1432,\n    間: 1302,\n    関: -1282,\n    雨: 2009,\n    電: -1045,\n    非: 2066,\n    駅: 1620,\n    \"１\": -800,\n    \"｣\": 2670,\n    \"･\": -3794,\n    ｯ: -1350,\n    ｱ: 551,\n    ｸﾞ: 1319,\n    ｽ: 874,\n    ﾄ: 521,\n    ﾑ: 1109,\n    ﾙ: 1591,\n    ﾛ: 2201,\n    ﾝ: 278,\n  };\n  this.UW4__ = {\n    \",\": 3930,\n    \".\": 3508,\n    \"―\": -4841,\n    \"、\": 3930,\n    \"。\": 3508,\n    〇: 4999,\n    \"「\": 1895,\n    \"」\": 3798,\n    \"〓\": -5156,\n    あ: 4752,\n    い: -3435,\n    う: -640,\n    え: -2514,\n    お: 2405,\n    か: 530,\n    が: 6006,\n    き: -4482,\n    ぎ: -3821,\n    く: -3788,\n    け: -4376,\n    げ: -4734,\n    こ: 2255,\n    ご: 1979,\n    さ: 2864,\n    し: -843,\n    じ: -2506,\n    す: -731,\n    ず: 1251,\n    せ: 181,\n    そ: 4091,\n    た: 5034,\n    だ: 5408,\n    ち: -3654,\n    っ: -5882,\n    つ: -1659,\n    て: 3994,\n    で: 7410,\n    と: 4547,\n    な: 5433,\n    に: 6499,\n    ぬ: 1853,\n    ね: 1413,\n    の: 7396,\n    は: 8578,\n    ば: 1940,\n    ひ: 4249,\n    び: -4134,\n    ふ: 1345,\n    へ: 6665,\n    べ: -744,\n    ほ: 1464,\n    ま: 1051,\n    み: -2082,\n    む: -882,\n    め: -5046,\n    も: 4169,\n    ゃ: -2666,\n    や: 2795,\n    ょ: -1544,\n    よ: 3351,\n    ら: -2922,\n    り: -9726,\n    る: -14896,\n    れ: -2613,\n    ろ: -4570,\n    わ: -1783,\n    を: 13150,\n    ん: -2352,\n    カ: 2145,\n    コ: 1789,\n    セ: 1287,\n    ッ: -724,\n    ト: -403,\n    メ: -1635,\n    ラ: -881,\n    リ: -541,\n    ル: -856,\n    ン: -3637,\n    \"・\": -4371,\n    ー: -11870,\n    一: -2069,\n    中: 2210,\n    予: 782,\n    事: -190,\n    井: -1768,\n    人: 1036,\n    以: 544,\n    会: 950,\n    体: -1286,\n    作: 530,\n    側: 4292,\n    先: 601,\n    党: -2006,\n    共: -1212,\n    内: 584,\n    円: 788,\n    初: 1347,\n    前: 1623,\n    副: 3879,\n    力: -302,\n    動: -740,\n    務: -2715,\n    化: 776,\n    区: 4517,\n    協: 1013,\n    参: 1555,\n    合: -1834,\n    和: -681,\n    員: -910,\n    器: -851,\n    回: 1500,\n    国: -619,\n    園: -1200,\n    地: 866,\n    場: -1410,\n    塁: -2094,\n    士: -1413,\n    多: 1067,\n    大: 571,\n    子: -4802,\n    学: -1397,\n    定: -1057,\n    寺: -809,\n    小: 1910,\n    屋: -1328,\n    山: -1500,\n    島: -2056,\n    川: -2667,\n    市: 2771,\n    年: 374,\n    庁: -4556,\n    後: 456,\n    性: 553,\n    感: 916,\n    所: -1566,\n    支: 856,\n    改: 787,\n    政: 2182,\n    教: 704,\n    文: 522,\n    方: -856,\n    日: 1798,\n    時: 1829,\n    最: 845,\n    月: -9066,\n    木: -485,\n    来: -442,\n    校: -360,\n    業: -1043,\n    氏: 5388,\n    民: -2716,\n    気: -910,\n    沢: -939,\n    済: -543,\n    物: -735,\n    率: 672,\n    球: -1267,\n    生: -1286,\n    産: -1101,\n    田: -2900,\n    町: 1826,\n    的: 2586,\n    目: 922,\n    省: -3485,\n    県: 2997,\n    空: -867,\n    立: -2112,\n    第: 788,\n    米: 2937,\n    系: 786,\n    約: 2171,\n    経: 1146,\n    統: -1169,\n    総: 940,\n    線: -994,\n    署: 749,\n    者: 2145,\n    能: -730,\n    般: -852,\n    行: -792,\n    規: 792,\n    警: -1184,\n    議: -244,\n    谷: -1000,\n    賞: 730,\n    車: -1481,\n    軍: 1158,\n    輪: -1433,\n    込: -3370,\n    近: 929,\n    道: -1291,\n    選: 2596,\n    郎: -4866,\n    都: 1192,\n    野: -1100,\n    銀: -2213,\n    長: 357,\n    間: -2344,\n    院: -2297,\n    際: -2604,\n    電: -878,\n    領: -1659,\n    題: -792,\n    館: -1984,\n    首: 1749,\n    高: 2120,\n    \"｢\": 1895,\n    \"｣\": 3798,\n    \"･\": -4371,\n    ｯ: -724,\n    ｰ: -11870,\n    ｶ: 2145,\n    ｺ: 1789,\n    ｾ: 1287,\n    ﾄ: -403,\n    ﾒ: -1635,\n    ﾗ: -881,\n    ﾘ: -541,\n    ﾙ: -856,\n    ﾝ: -3637,\n  };\n  this.UW5__ = {\n    \",\": 465,\n    \".\": -299,\n    1: -514,\n    E2: -32768,\n    \"]\": -2762,\n    \"、\": 465,\n    \"。\": -299,\n    \"「\": 363,\n    あ: 1655,\n    い: 331,\n    う: -503,\n    え: 1199,\n    お: 527,\n    か: 647,\n    が: -421,\n    き: 1624,\n    ぎ: 1971,\n    く: 312,\n    げ: -983,\n    さ: -1537,\n    し: -1371,\n    す: -852,\n    だ: -1186,\n    ち: 1093,\n    っ: 52,\n    つ: 921,\n    て: -18,\n    で: -850,\n    と: -127,\n    ど: 1682,\n    な: -787,\n    に: -1224,\n    の: -635,\n    は: -578,\n    べ: 1001,\n    み: 502,\n    め: 865,\n    ゃ: 3350,\n    ょ: 854,\n    り: -208,\n    る: 429,\n    れ: 504,\n    わ: 419,\n    を: -1264,\n    ん: 327,\n    イ: 241,\n    ル: 451,\n    ン: -343,\n    中: -871,\n    京: 722,\n    会: -1153,\n    党: -654,\n    務: 3519,\n    区: -901,\n    告: 848,\n    員: 2104,\n    大: -1296,\n    学: -548,\n    定: 1785,\n    嵐: -1304,\n    市: -2991,\n    席: 921,\n    年: 1763,\n    思: 872,\n    所: -814,\n    挙: 1618,\n    新: -1682,\n    日: 218,\n    月: -4353,\n    査: 932,\n    格: 1356,\n    機: -1508,\n    氏: -1347,\n    田: 240,\n    町: -3912,\n    的: -3149,\n    相: 1319,\n    省: -1052,\n    県: -4003,\n    研: -997,\n    社: -278,\n    空: -813,\n    統: 1955,\n    者: -2233,\n    表: 663,\n    語: -1073,\n    議: 1219,\n    選: -1018,\n    郎: -368,\n    長: 786,\n    間: 1191,\n    題: 2368,\n    館: -689,\n    \"１\": -514,\n    Ｅ２: -32768,\n    \"｢\": 363,\n    ｲ: 241,\n    ﾙ: 451,\n    ﾝ: -343,\n  };\n  this.UW6__ = {\n    \",\": 227,\n    \".\": 808,\n    1: -270,\n    E1: 306,\n    \"、\": 227,\n    \"。\": 808,\n    あ: -307,\n    う: 189,\n    か: 241,\n    が: -73,\n    く: -121,\n    こ: -200,\n    じ: 1782,\n    す: 383,\n    た: -428,\n    っ: 573,\n    て: -1014,\n    で: 101,\n    と: -105,\n    な: -253,\n    に: -149,\n    の: -417,\n    は: -236,\n    も: -206,\n    り: 187,\n    る: -135,\n    を: 195,\n    ル: -673,\n    ン: -496,\n    一: -277,\n    中: 201,\n    件: -800,\n    会: 624,\n    前: 302,\n    区: 1792,\n    員: -1212,\n    委: 798,\n    学: -960,\n    市: 887,\n    広: -695,\n    後: 535,\n    業: -697,\n    相: 753,\n    社: -507,\n    福: 974,\n    空: -822,\n    者: 1811,\n    連: 463,\n    郎: 1082,\n    \"１\": -270,\n    Ｅ１: 306,\n    ﾙ: -673,\n    ﾝ: -496,\n  };\n\n  return this;\n}\n\nTinySegmenter.prototype.ctype_ = function (str) {\n  for (var i in this.chartype_) {\n    if (str.match(this.chartype_[i][0])) {\n      return this.chartype_[i][1];\n    }\n  }\n  return \"O\";\n};\n\nTinySegmenter.prototype.ts_ = function (v) {\n  if (v) {\n    return v;\n  }\n  return 0;\n};\n\nTinySegmenter.prototype.segment = function (input) {\n  if (input == null || input == undefined || input == \"\") {\n    return [];\n  }\n  var result = [];\n  var seg = [\"B3\", \"B2\", \"B1\"];\n  var ctype = [\"O\", \"O\", \"O\"];\n  var o = input.split(\"\");\n  for (i = 0; i < o.length; ++i) {\n    seg.push(o[i]);\n    ctype.push(this.ctype_(o[i]));\n  }\n  seg.push(\"E1\");\n  seg.push(\"E2\");\n  seg.push(\"E3\");\n  ctype.push(\"O\");\n  ctype.push(\"O\");\n  ctype.push(\"O\");\n  var word = seg[3];\n  var p1 = \"U\";\n  var p2 = \"U\";\n  var p3 = \"U\";\n  for (var i = 4; i < seg.length - 3; ++i) {\n    var score = this.BIAS__;\n    var w1 = seg[i - 3];\n    var w2 = seg[i - 2];\n    var w3 = seg[i - 1];\n    var w4 = seg[i];\n    var w5 = seg[i + 1];\n    var w6 = seg[i + 2];\n    var c1 = ctype[i - 3];\n    var c2 = ctype[i - 2];\n    var c3 = ctype[i - 1];\n    var c4 = ctype[i];\n    var c5 = ctype[i + 1];\n    var c6 = ctype[i + 2];\n    score += this.ts_(this.UP1__[p1]);\n    score += this.ts_(this.UP2__[p2]);\n    score += this.ts_(this.UP3__[p3]);\n    score += this.ts_(this.BP1__[p1 + p2]);\n    score += this.ts_(this.BP2__[p2 + p3]);\n    score += this.ts_(this.UW1__[w1]);\n    score += this.ts_(this.UW2__[w2]);\n    score += this.ts_(this.UW3__[w3]);\n    score += this.ts_(this.UW4__[w4]);\n    score += this.ts_(this.UW5__[w5]);\n    score += this.ts_(this.UW6__[w6]);\n    score += this.ts_(this.BW1__[w2 + w3]);\n    score += this.ts_(this.BW2__[w3 + w4]);\n    score += this.ts_(this.BW3__[w4 + w5]);\n    score += this.ts_(this.TW1__[w1 + w2 + w3]);\n    score += this.ts_(this.TW2__[w2 + w3 + w4]);\n    score += this.ts_(this.TW3__[w3 + w4 + w5]);\n    score += this.ts_(this.TW4__[w4 + w5 + w6]);\n    score += this.ts_(this.UC1__[c1]);\n    score += this.ts_(this.UC2__[c2]);\n    score += this.ts_(this.UC3__[c3]);\n    score += this.ts_(this.UC4__[c4]);\n    score += this.ts_(this.UC5__[c5]);\n    score += this.ts_(this.UC6__[c6]);\n    score += this.ts_(this.BC1__[c2 + c3]);\n    score += this.ts_(this.BC2__[c3 + c4]);\n    score += this.ts_(this.BC3__[c4 + c5]);\n    score += this.ts_(this.TC1__[c1 + c2 + c3]);\n    score += this.ts_(this.TC2__[c2 + c3 + c4]);\n    score += this.ts_(this.TC3__[c3 + c4 + c5]);\n    score += this.ts_(this.TC4__[c4 + c5 + c6]);\n    //  score += this.ts_(this.TC5__[c4 + c5 + c6]);\n    score += this.ts_(this.UQ1__[p1 + c1]);\n    score += this.ts_(this.UQ2__[p2 + c2]);\n    score += this.ts_(this.UQ3__[p3 + c3]);\n    score += this.ts_(this.BQ1__[p2 + c2 + c3]);\n    score += this.ts_(this.BQ2__[p2 + c3 + c4]);\n    score += this.ts_(this.BQ3__[p3 + c2 + c3]);\n    score += this.ts_(this.BQ4__[p3 + c3 + c4]);\n    score += this.ts_(this.TQ1__[p2 + c1 + c2 + c3]);\n    score += this.ts_(this.TQ2__[p2 + c2 + c3 + c4]);\n    score += this.ts_(this.TQ3__[p3 + c1 + c2 + c3]);\n    score += this.ts_(this.TQ4__[p3 + c2 + c3 + c4]);\n    var p = \"O\";\n    if (score > 0) {\n      result.push(word);\n      word = \"\";\n      p = \"B\";\n    }\n    p1 = p2;\n    p2 = p3;\n    p3 = p;\n    word += seg[i];\n  }\n  result.push(word);\n\n  return result;\n};\n\nexport default TinySegmenter;\n","import TinySegmenter from \"../../external/tiny-segmenter\";\nimport { TRIM_CHAR_PATTERN } from \"./DefaultTokenizer\";\nimport type { Tokenizer } from \"../tokenizer\";\n// @ts-ignore\nconst segmenter = new TinySegmenter();\n\nfunction pickTokensAsJapanese(content: string, trimPattern: RegExp): string[] {\n  return content\n    .split(trimPattern)\n    .filter((x) => x !== \"\")\n    .flatMap<string>((x) => segmenter.segment(x));\n}\n\n/**\n * Japanese needs original logic.\n */\nexport class JapaneseTokenizer implements Tokenizer {\n  tokenize(content: string, raw?: boolean): string[] {\n    return pickTokensAsJapanese(content, raw ? / /g : this.getTrimPattern());\n  }\n\n  recursiveTokenize(content: string): { word: string; offset: number }[] {\n    const tokens: string[] = segmenter\n      .segment(content)\n      // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/77\n      .flatMap((x: string) =>\n        x === \" \" ? x : x.split(\" \").map((t) => (t === \"\" ? \" \" : t))\n      );\n\n    const ret = [];\n    for (let i = 0; i < tokens.length; i++) {\n      if (\n        i === 0 ||\n        tokens[i].length !== 1 ||\n        !Boolean(tokens[i].match(this.getTrimPattern()))\n      ) {\n        ret.push({\n          word: tokens.slice(i).join(\"\"),\n          offset: tokens.slice(0, i).join(\"\").length,\n        });\n      }\n    }\n\n    return ret;\n  }\n\n  getTrimPattern(): RegExp {\n    return TRIM_CHAR_PATTERN;\n  }\n\n  shouldIgnoreOnCurrent(str: string): boolean {\n    return Boolean(str.match(/^[ぁ-んａ-ｚＡ-Ｚ。、ー　]*$/));\n  }\n}\n","import { DefaultTokenizer } from \"./DefaultTokenizer\";\n\ntype PreviousType = \"none\" | \"trim\" | \"english\" | \"others\";\nconst ENGLISH_PATTERN = /[a-zA-Z0-9_\\-\\\\]/;\nexport class EnglishOnlyTokenizer extends DefaultTokenizer {\n  tokenize(content: string, raw?: boolean): string[] {\n    const tokenized = Array.from(this._tokenize(content)).filter((x) =>\n      x.word.match(ENGLISH_PATTERN)\n    );\n    return raw\n      ? tokenized.map((x) => x.word)\n      : tokenized\n          .map((x) => x.word)\n          .filter((x) => !x.match(this.getTrimPattern()));\n  }\n\n  recursiveTokenize(content: string): { word: string; offset: number }[] {\n    const offsets = Array.from(this._tokenize(content))\n      .filter((x) => !x.word.match(this.getTrimPattern()))\n      .map((x) => x.offset);\n    return [\n      ...offsets.map((i) => ({\n        word: content.slice(i),\n        offset: i,\n      })),\n    ];\n  }\n\n  private *_tokenize(\n    content: string\n  ): Iterable<{ word: string; offset: number }> {\n    let startIndex = 0;\n    let previousType: PreviousType = \"none\";\n\n    for (let i = 0; i < content.length; i++) {\n      if (content[i].match(super.getTrimPattern())) {\n        yield { word: content.slice(startIndex, i), offset: startIndex };\n        previousType = \"trim\";\n        startIndex = i;\n        continue;\n      }\n\n      if (content[i].match(ENGLISH_PATTERN)) {\n        if (previousType === \"english\" || previousType === \"none\") {\n          previousType = \"english\";\n          continue;\n        }\n\n        yield { word: content.slice(startIndex, i), offset: startIndex };\n        previousType = \"english\";\n        startIndex = i;\n        continue;\n      }\n\n      if (previousType === \"others\" || previousType === \"none\") {\n        previousType = \"others\";\n        continue;\n      }\n\n      yield { word: content.slice(startIndex, i), offset: startIndex };\n      previousType = \"others\";\n      startIndex = i;\n    }\n\n    yield {\n      word: content.slice(startIndex, content.length),\n      offset: startIndex,\n    };\n  }\n}\n","// Quick guide for typing Chinese pinyin on Mac OS X\n\n// Tone 1 (flat) mā – Option + a, then hit a vowel key\n// Tone 2 (rising) má – Option + e, then hit a vowel key\n// Tone 3 (falling-rising) mǎ – Option + v, then hit a vowel key\n// Tone 4 (falling) mà – Option + `, then hit a vowel key\n\n// ǚ – Option + V, then hit V (submitted by QA)\n// ǜ – Option + `, then hit V (submitted by QA)\n\n\nvar replacements = {\n  'a': ['ā', 'á', 'ǎ', 'à'],\n  'e': ['ē', 'é', 'ě', 'è'],\n  'u': ['ū', 'ú', 'ǔ', 'ù'],\n  'i': ['ī', 'í', 'ǐ', 'ì'],\n  'o': ['ō', 'ó', 'ǒ', 'ò'],\n  'ü': ['ǖ', 'ǘ', 'ǚ', 'ǜ']\n};\n\nvar medials = ['i', 'u', 'ü'];\n\nvar prettify = function(str){\n  str = str.replace('v', 'ü');\n  var syllables = str.split(' ');\n\n  for (var i = 0; i < syllables.length; i++){\n    var syllable = syllables[i];\n    var tone = parseInt(syllable[syllable.length-1]);\n    \n    if (tone <= 0 || tone > 5) {\n      console.error('invalid tone number:', tone, 'in', syllable);\n    } else if (tone === 5){\n      syllables[i] = syllable.slice(0, syllable.length - 1);\n    } else {\n      for (var j = 0; j < syllable.length; j++){\n        var currentLetter = syllable[j];\n        var nextLetter = syllable[j + 1];\n\n        // found a vowel\n        if (replacements[currentLetter]){\n          var replaced;\n          var letterToReplace;\n\n          // two consecutive vowels\n          if (replacements[nextLetter] && medials.indexOf(currentLetter) >= 0){\n            letterToReplace = nextLetter;\n          } else {\n            letterToReplace = currentLetter;\n          }\n\n          replaced = syllable.replace(letterToReplace, replacements[letterToReplace][tone - 1]);\n          syllables[i] = replaced.slice(0, replaced.length - 1);\n          break;\n        }\n      }  \n    }\n\n  }\n  return syllables.join(' ');\n};\n\nmodule.exports.prettify = prettify;\n\n\n","class Trie {\n    constructor() {\n        this.content = {}\n    }\n\n    getKeyObject(key, create = false) {\n        key = key.toString()\n\n        let chars = key === '' ? [key] : Array.from(key)\n        let obj = this.content\n\n        for (let char of chars) {\n            if (obj[char] == null) {\n                if (create) obj[char] = {}\n                else return {}\n            }\n\n            obj = obj[char]\n        }\n\n        return obj\n    }\n\n    get(key) {\n        let obj = this.getKeyObject(key)\n\n        return obj.values || []\n    }\n\n    getPrefix(key) {\n        let inner = (key, obj = null) => {\n            if (obj == null) obj = this.getKeyObject(key)\n            let result = obj.values ? [...obj.values] : []\n\n            for (let char in obj) {\n                if (char === 'values' || obj[char] == null) continue\n\n                result.push(...inner(key + char, obj[char]))\n            }\n\n            return result\n        }\n\n        return inner(key)\n    }\n\n    push(key, value) {\n        let obj = this.getKeyObject(key, true)\n\n        if (obj.values == null) obj.values = []\n        if (!obj.values.includes(value)) obj.values.push(value)\n\n        return this\n    }\n}\n\nmodule.exports = Trie\n","const {prettify} = require('prettify-pinyin')\nconst Trie = require('./trie')\n\nfunction parseLine(line) {\n    let match = line.match(/^(\\S+)\\s(\\S+)\\s\\[([^\\]]+)\\]\\s\\/(.+)\\//)\n    if (match == null) return\n\n    let [, traditional, simplified, pinyin, english] = match\n\n    pinyin = pinyin.replace(/u:/g, 'ü')\n    let pinyinPretty = prettify(pinyin)\n\n    return {traditional, simplified, pinyin, pinyinPretty, english}\n}\n\nclass Cedict {\n    load(contents) {\n        this.simplifiedTrie = new Trie()\n        this.traditionalTrie = new Trie()\n\n        let lines = contents.split('\\n')\n\n        for (let line of lines) {\n            if (line.trim() === '' || line[0] === '#') continue\n\n            let entry = parseLine(line)\n            if (entry == null) continue\n\n            this.simplifiedTrie.push(entry.simplified, entry)\n            this.traditionalTrie.push(entry.traditional, entry)\n        }\n    }\n\n    get(word, traditional = false) {\n        return traditional ? this.traditionalTrie.get(word) : this.simplifiedTrie.get(word)\n    }\n\n    getPrefix(word, traditional = false) {\n        return traditional ? this.traditionalTrie.getPrefix(word) : this.simplifiedTrie.getPrefix(word)\n    }\n}\n\nmodule.exports = Cedict\n","const Cedict = require(\"./cedict\");\n\nconst chinesePunctuation = [\n  \"·\",\n  \"×\",\n  \"—\",\n  \"‘\",\n  \"’\",\n  \"“\",\n  \"”\",\n  \"…\",\n  \"、\",\n  \"。\",\n  \"《\",\n  \"》\",\n  \"『\",\n  \"』\",\n  \"【\",\n  \"】\",\n  \"！\",\n  \"（\",\n  \"）\",\n  \"，\",\n  \"：\",\n  \"；\",\n  \"？\",\n];\n\nexports.load = function (contents) {\n  let dictionary = new Cedict();\n  dictionary.load(contents);\n\n  return function tokenize(text) {\n    text = Array.from(text.replace(/\\r/g, \"\"));\n\n    let result = [];\n    let i = 0;\n    let [offset, line, column] = [0, 1, 1];\n    let [simplifiedPreference, traditionalPreference] = [0, 0];\n\n    let pushToken = (word) => {\n      let simplifiedEntries = dictionary.get(word, false);\n      let traditionalEntries = dictionary.get(word, true);\n\n      let entries =\n        simplifiedEntries.length === 0\n          ? traditionalEntries\n          : traditionalEntries.length === 0\n          ? simplifiedEntries\n          : simplifiedPreference < traditionalPreference\n          ? traditionalEntries\n          : simplifiedPreference > traditionalPreference\n          ? simplifiedEntries\n          : traditionalEntries;\n\n      if (traditionalEntries.length === 0 && simplifiedEntries.length > 0) {\n        simplifiedPreference++;\n      } else if (\n        simplifiedEntries.length === 0 &&\n        traditionalEntries.length > 0\n      ) {\n        traditionalPreference++;\n      }\n\n      result.push({\n        text: word,\n        traditional: entries[0] ? entries[0].traditional : word,\n        simplified: entries[0] ? entries[0].simplified : word,\n\n        position: {\n          offset,\n          line,\n          column,\n        },\n\n        matches: entries.map(({ pinyin, pinyinPretty, english }) => ({\n          pinyin,\n          pinyinPretty,\n          english,\n        })),\n      });\n\n      let wordArr = Array.from(word);\n      let lastLineBreakIndex = word.lastIndexOf(\"\\n\");\n\n      i += wordArr.length;\n      offset += word.length;\n      line += wordArr.filter((x) => x === \"\\n\").length;\n      column =\n        lastLineBreakIndex >= 0\n          ? word.length - lastLineBreakIndex\n          : column + word.length;\n    };\n\n    while (i < text.length) {\n      // Try to match two or more characters\n\n      if (i !== text.length - 1) {\n        let getTwo = text.slice(i, i + 2).join(\"\");\n        let simplifiedEntries = dictionary.getPrefix(getTwo, false);\n        let traditionalEntries = dictionary.getPrefix(getTwo, true);\n        let foundWord = null;\n        let foundEntries = null;\n\n        for (let entries of [traditionalEntries, simplifiedEntries]) {\n          for (let entry of entries) {\n            let matchText =\n              entries === traditionalEntries\n                ? entry.traditional\n                : entry.simplified;\n            let word = text.slice(i, i + Array.from(matchText).length).join(\"\");\n\n            if (\n              matchText === word &&\n              (foundWord == null ||\n                Array.from(word).length > Array.from(foundWord).length)\n            ) {\n              foundWord = word;\n              foundEntries = entries;\n            }\n          }\n        }\n\n        if (foundWord != null) {\n          pushToken(foundWord);\n\n          if (foundEntries === simplifiedEntries) {\n            simplifiedPreference++;\n          } else if (foundEntries === traditionalEntries) {\n            traditionalPreference++;\n          }\n\n          continue;\n        }\n      }\n\n      // If it fails, match one character\n\n      let character = text[i];\n      let isChinese = (character) =>\n        chinesePunctuation.includes(character) ||\n        dictionary.get(character, false).length > 0 ||\n        dictionary.get(character, true).length > 0;\n\n      if (isChinese(character) || character.match(/\\s/) != null) {\n        pushToken(character);\n        continue;\n      }\n\n      // Handle non-Chinese characters\n\n      let end = i + 1;\n\n      for (; end < text.length; end++) {\n        if (text[end].match(/\\s/) != null || isChinese(text[end])) break;\n      }\n\n      let word = text.slice(i, end).join(\"\");\n      pushToken(word);\n    }\n\n    return result;\n  };\n};\n","import { TRIM_CHAR_PATTERN } from \"./DefaultTokenizer\";\nimport type { Tokenizer } from \"../tokenizer\";\nimport chineseTokenizer from \"chinese-tokenizer\";\n\n/**\n * Chinese needs original logic.\n */\nexport class ChineseTokenizer implements Tokenizer {\n  _tokenize: ReturnType<typeof chineseTokenizer.load>;\n\n  static create(dict: string): ChineseTokenizer {\n    const ins = new ChineseTokenizer();\n    ins._tokenize = chineseTokenizer.load(dict);\n    return ins;\n  }\n\n  tokenize(content: string, raw?: boolean): string[] {\n    return content\n      .split(raw ? / /g : this.getTrimPattern())\n      .filter((x) => x !== \"\")\n      .flatMap((x) => this._tokenize(x))\n      .map((x) => x.text);\n  }\n\n  recursiveTokenize(content: string): { word: string; offset: number }[] {\n    const tokens: string[] = this._tokenize(content).map((x) => x.text);\n\n    const ret = [];\n    for (let i = 0; i < tokens.length; i++) {\n      if (\n        i === 0 ||\n        tokens[i].length !== 1 ||\n        !Boolean(tokens[i].match(this.getTrimPattern()))\n      ) {\n        ret.push({\n          word: tokens.slice(i).join(\"\"),\n          offset: tokens.slice(0, i).join(\"\").length,\n        });\n      }\n    }\n\n    return ret;\n  }\n\n  getTrimPattern(): RegExp {\n    return TRIM_CHAR_PATTERN;\n  }\n\n  shouldIgnoreOnCurrent(str: string): boolean {\n    return false;\n  }\n}\n","import { ArabicTokenizer } from \"./tokenizers/ArabicTokenizer\";\nimport { DefaultTokenizer } from \"./tokenizers/DefaultTokenizer\";\nimport { JapaneseTokenizer } from \"./tokenizers/JapaneseTokenizer\";\nimport type { TokenizeStrategy } from \"./TokenizeStrategy\";\nimport { EnglishOnlyTokenizer } from \"./tokenizers/EnglishOnlyTokenizer\";\nimport type { App } from \"obsidian\";\nimport { ChineseTokenizer } from \"./tokenizers/ChineseTokenizer\";\n\nexport interface Tokenizer {\n  tokenize(content: string, raw?: boolean): string[];\n  recursiveTokenize(content: string): { word: string; offset: number }[];\n  getTrimPattern(): RegExp;\n  shouldIgnoreOnCurrent(query: string): boolean;\n}\n\nexport async function createTokenizer(\n  strategy: TokenizeStrategy,\n  app: App\n): Promise<Tokenizer> {\n  switch (strategy.name) {\n    case \"default\":\n      return new DefaultTokenizer();\n    case \"english-only\":\n      return new EnglishOnlyTokenizer();\n    case \"arabic\":\n      return new ArabicTokenizer();\n    case \"japanese\":\n      return new JapaneseTokenizer();\n    case \"chinese\":\n      const hasCedict = await app.vault.adapter.exists(\"./cedict_ts.u8\");\n      if (!hasCedict) {\n        return Promise.reject(\n          new Error(\"cedict_ts.U8 doesn't exist in your vault root.\")\n        );\n      }\n      const dict = await app.vault.adapter.read(\"./cedict_ts.u8\");\n      return ChineseTokenizer.create(dict);\n  }\n}\n","type Name = \"default\" | \"english-only\" | \"japanese\" | \"arabic\" | \"chinese\";\n\nexport class TokenizeStrategy {\n  private static readonly _values: TokenizeStrategy[] = [];\n\n  static readonly DEFAULT = new TokenizeStrategy(\"default\", 3, 5);\n  static readonly ENGLISH_ONLY = new TokenizeStrategy(\"english-only\", 3, 5);\n  static readonly JAPANESE = new TokenizeStrategy(\"japanese\", 2, 2);\n  static readonly ARABIC = new TokenizeStrategy(\"arabic\", 3, 3);\n  static readonly CHINESE = new TokenizeStrategy(\"chinese\", 1, 2);\n\n  private constructor(\n    readonly name: Name,\n    readonly triggerThreshold: number,\n    readonly indexingThreshold: number\n  ) {\n    TokenizeStrategy._values.push(this);\n  }\n\n  static fromName(name: string): TokenizeStrategy {\n    return TokenizeStrategy._values.find((x) => x.name === name)!;\n  }\n\n  static values(): TokenizeStrategy[] {\n    return TokenizeStrategy._values;\n  }\n}\n","import {\n  App,\n  Editor,\n  type EditorPosition,\n  MarkdownView,\n  normalizePath,\n  parseFrontMatterAliases,\n  parseFrontMatterStringArray,\n  parseFrontMatterTags,\n  TFile,\n  Vault,\n} from \"obsidian\";\n\ninterface UnsafeAppInterface {\n  vault: Vault & {\n    config: {\n      spellcheckDictionary?: string[];\n      useMarkdownLinks?: false;\n    };\n  };\n}\n\nexport type FrontMatterValue = string[];\n\nexport class AppHelper {\n  private unsafeApp: App & UnsafeAppInterface;\n\n  constructor(app: App) {\n    this.unsafeApp = app as any;\n  }\n\n  equalsAsEditorPostion(one: EditorPosition, other: EditorPosition): boolean {\n    return one.line === other.line && one.ch === other.ch;\n  }\n\n  getAliases(file: TFile): string[] {\n    return (\n      parseFrontMatterAliases(\n        this.unsafeApp.metadataCache.getFileCache(file)?.frontmatter\n      ) ?? []\n    );\n  }\n\n  getFrontMatter(file: TFile): { [key: string]: FrontMatterValue } | undefined {\n    const frontMatter =\n      this.unsafeApp.metadataCache.getFileCache(file)?.frontmatter;\n    if (!frontMatter) {\n      return undefined;\n    }\n\n    // remove #\n    const tags =\n      parseFrontMatterTags(frontMatter)?.map((x) => x.slice(1)) ?? [];\n    const aliases = parseFrontMatterAliases(frontMatter) ?? [];\n    const { position, ...rest } = frontMatter;\n    return {\n      ...Object.fromEntries(\n        Object.entries(rest).map(([k, _v]) => [\n          k,\n          parseFrontMatterStringArray(frontMatter, k),\n        ])\n      ),\n      tags,\n      tag: tags,\n      aliases,\n      alias: aliases,\n    };\n  }\n\n  getMarkdownViewInActiveLeaf(): MarkdownView | null {\n    if (!this.unsafeApp.workspace.getActiveViewOfType(MarkdownView)) {\n      return null;\n    }\n\n    return this.unsafeApp.workspace.activeLeaf!.view as MarkdownView;\n  }\n\n  getActiveFile(): TFile | null {\n    return this.unsafeApp.workspace.getActiveFile();\n  }\n\n  isActiveFile(file: TFile): boolean {\n    return this.getActiveFile()?.path === file.path;\n  }\n\n  getPreviousFile(): TFile | null {\n    const fName = this.unsafeApp.workspace.getLastOpenFiles()?.[1];\n    if (!fName) {\n      return null;\n    }\n\n    return this.getMarkdownFileByPath(fName);\n  }\n\n  getCurrentDirname(): string | null {\n    return this.getActiveFile()?.parent.path ?? null;\n  }\n\n  getCurrentEditor(): Editor | null {\n    return this.getMarkdownViewInActiveLeaf()?.editor ?? null;\n  }\n\n  getSelection(): string | undefined {\n    return this.getCurrentEditor()?.getSelection();\n  }\n\n  getCurrentOffset(editor: Editor): number {\n    return editor.posToOffset(editor.getCursor());\n  }\n\n  getCurrentLine(editor: Editor): string {\n    return editor.getLine(editor.getCursor().line);\n  }\n\n  getCurrentLineUntilCursor(editor: Editor): string {\n    return this.getCurrentLine(editor).slice(0, editor.getCursor().ch);\n  }\n\n  optimizeMarkdownLinkText(linkText: string): string | null {\n    const activeFile = this.getActiveFile();\n    if (!activeFile) {\n      return null;\n    }\n\n    const path = this.linkText2Path(linkText);\n    if (!path) {\n      return linkText;\n    }\n\n    const file = this.getMarkdownFileByPath(path);\n    if (!file) {\n      return null;\n    }\n\n    const markdownLink = this.unsafeApp.fileManager.generateMarkdownLink(\n      file,\n      activeFile.path\n    );\n\n    return markdownLink.startsWith(\"[[\")\n      ? markdownLink.replace(\"[[\", \"\").replace(\"]]\", \"\")\n      : markdownLink.replace(\"[\", \"\").replace(/\\]\\(.+\\)/g, \"\");\n  }\n\n  linkText2Path(linkText: string): string | null {\n    const activeFile = this.getActiveFile();\n    if (!activeFile) {\n      return null;\n    }\n\n    return (\n      this.unsafeApp.metadataCache.getFirstLinkpathDest(\n        linkText,\n        activeFile.path\n      )?.path ?? null\n    );\n  }\n\n  searchPhantomLinks(): { path: string; link: string }[] {\n    return Object.entries(this.unsafeApp.metadataCache.unresolvedLinks).flatMap(\n      ([path, obj]) => Object.keys(obj).map((link) => ({ path, link }))\n    );\n  }\n\n  getMarkdownFileByPath(path: string): TFile | null {\n    if (!path.endsWith(\".md\")) {\n      return null;\n    }\n\n    const abstractFile = this.unsafeApp.vault.getAbstractFileByPath(path);\n    if (!abstractFile) {\n      return null;\n    }\n\n    return abstractFile as TFile;\n  }\n\n  openMarkdownFile(file: TFile, newLeaf: boolean, offset: number = 0) {\n    const leaf = this.unsafeApp.workspace.getLeaf(newLeaf);\n\n    leaf\n      .openFile(file, this.unsafeApp.workspace.activeLeaf?.getViewState())\n      .then(() => {\n        this.unsafeApp.workspace.setActiveLeaf(leaf, true, true);\n        const viewOfType =\n          this.unsafeApp.workspace.getActiveViewOfType(MarkdownView);\n        if (viewOfType) {\n          const editor = viewOfType.editor;\n          const pos = editor.offsetToPos(offset);\n          editor.setCursor(pos);\n          editor.scrollIntoView({ from: pos, to: pos }, true);\n        }\n      });\n  }\n\n  getCurrentFrontMatter(): string | null {\n    const editor = this.getCurrentEditor();\n    if (!editor) {\n      return null;\n    }\n\n    if (!this.getActiveFile()) {\n      return null;\n    }\n\n    if (editor.getLine(0) !== \"---\") {\n      return null;\n    }\n    const endPosition = editor.getValue().indexOf(\"---\", 3);\n\n    const currentOffset = this.getCurrentOffset(editor);\n    if (endPosition !== -1 && currentOffset >= endPosition) {\n      return null;\n    }\n\n    const keyLocations = Array.from(editor.getValue().matchAll(/.+:/g));\n    if (keyLocations.length === 0) {\n      return null;\n    }\n\n    const currentKeyLocation = keyLocations\n      .filter((x) => x.index! < currentOffset)\n      .last();\n    if (!currentKeyLocation) {\n      return null;\n    }\n\n    return currentKeyLocation[0].split(\":\")[0];\n  }\n\n  /**\n   * Unsafe method\n   */\n  isIMEOn(): boolean {\n    if (!this.unsafeApp.workspace.getActiveViewOfType(MarkdownView)) {\n      return false;\n    }\n\n    const markdownView = this.unsafeApp.workspace.activeLeaf!\n      .view as MarkdownView;\n    const cm5or6: any = (markdownView.editor as any).cm;\n\n    // cm6\n    if (cm5or6?.inputState?.composing > 0) {\n      return true;\n    }\n\n    // cm5\n    return !!cm5or6?.display?.input?.composing;\n  }\n\n  async writeLog(log: string) {\n    await this.unsafeApp.vault.adapter.append(normalizePath(\"log.md\"), log);\n  }\n\n  get useWikiLinks(): boolean {\n    return !this.unsafeApp.vault.config.useMarkdownLinks;\n  }\n}\n","export const keyBy = <T>(\n  values: T[],\n  toKey: (t: T) => string\n): { [key: string]: T } =>\n  values.reduce(\n    (prev, cur, _1, _2, k = toKey(cur)) => ((prev[k] = cur), prev),\n    {} as { [key: string]: T }\n  );\n\nexport const groupBy = <T>(\n  values: T[],\n  toKey: (t: T) => string\n): { [key: string]: T[] } =>\n  values.reduce(\n    (prev, cur, _1, _2, k = toKey(cur)) => (\n      (prev[k] || (prev[k] = [])).push(cur), prev\n    ),\n    {} as { [key: string]: T[] }\n  );\n\nexport function uniq<T>(values: T[]): T[] {\n  return [...new Set(values)];\n}\n\nexport function uniqBy<T>(values: T[], fn: (x: T) => string | number): T[] {\n  const m = new Map<string | number, T>();\n  values.forEach((x) => {\n    const k = fn(x);\n    if (!m.has(k)) {\n      m.set(k, x);\n    }\n  });\n  return Array.from(m.values());\n}\n\nexport function uniqWith<T>(arr: T[], fn: (one: T, other: T) => boolean) {\n  return arr.filter(\n    (element, index) => arr.findIndex((step) => fn(element, step)) === index\n  );\n}\n\nexport function arrayEquals(\n  arr1: unknown[],\n  arr2: unknown[],\n  length?: number\n): boolean {\n  let l = Math.max(arr1.length, arr2.length);\n  if (length !== undefined) {\n    l = Math.min(l, length);\n  }\n\n  for (let i = 0; i < l; i++) {\n    if (arr1[i] !== arr2[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function arrayEqualsUntil(arr1: unknown[], arr2: unknown[]): number {\n  let l = Math.min(arr1.length, arr2.length);\n  for (let i = 0; i < l; i++) {\n    if (arr1[i] !== arr2[i]) {\n      return i - 1;\n    }\n  }\n\n  return l - 1;\n}\n\nexport function mirrorMap<T>(\n  collection: T[],\n  toValue: (t: T) => string\n): { [key: string]: string } {\n  return collection.reduce((p, c) => ({ ...p, [toValue(c)]: toValue(c) }), {});\n}\n","export type WordType =\n  | \"currentFile\"\n  | \"currentVault\"\n  | \"customDictionary\"\n  | \"internalLink\"\n  | \"frontMatter\";\n\nexport interface DefaultWord {\n  value: string;\n  description?: string;\n  aliases?: string[];\n  type: WordType;\n  createdPath: string;\n  // Add after judge\n  offset?: number;\n  hit?: string;\n}\nexport interface CurrentFileWord extends DefaultWord {\n  type: \"currentFile\";\n}\nexport interface CurrentVaultWord extends DefaultWord {\n  type: \"currentVault\";\n}\nexport interface CustomDictionaryWord extends DefaultWord {\n  type: \"customDictionary\";\n  caretSymbol?: string;\n  /** Use for inserting instead of value **/\n  insertedText?: string;\n  /** If true, ignore `Insert space after completion` option **/\n  ignoreSpaceAfterCompletion?: boolean;\n}\nexport interface InternalLinkWord extends DefaultWord {\n  type: \"internalLink\";\n  phantom?: boolean;\n  aliasMeta?: {\n    origin: string;\n  };\n}\nexport interface FrontMatterWord extends DefaultWord {\n  type: \"frontMatter\";\n  key: string;\n}\n\nexport type Word =\n  | CurrentFileWord\n  | CurrentVaultWord\n  | CustomDictionaryWord\n  | InternalLinkWord\n  | FrontMatterWord;\n\nexport class WordTypeMeta {\n  private static readonly _values: WordTypeMeta[] = [];\n  private static readonly _dict: { [type: string]: WordTypeMeta } = {};\n\n  static readonly FRONT_MATTER = new WordTypeMeta(\n    \"frontMatter\",\n    100,\n    \"frontMatter\"\n  );\n  static readonly INTERNAL_LINK = new WordTypeMeta(\n    \"internalLink\",\n    90,\n    \"internalLink\"\n  );\n  static readonly CUSTOM_DICTIONARY = new WordTypeMeta(\n    \"customDictionary\",\n    80,\n    \"suggestion\"\n  );\n  static readonly CURRENT_FILE = new WordTypeMeta(\n    \"currentFile\",\n    70,\n    \"suggestion\"\n  );\n  static readonly CURRENT_VAULT = new WordTypeMeta(\n    \"currentVault\",\n    60,\n    \"suggestion\"\n  );\n\n  private constructor(\n    readonly type: WordType,\n    readonly priority: number,\n    readonly group: string\n  ) {\n    WordTypeMeta._values.push(this);\n    WordTypeMeta._dict[type] = this;\n  }\n\n  static of(type: WordType): WordTypeMeta {\n    return WordTypeMeta._dict[type];\n  }\n\n  static values(): WordTypeMeta[] {\n    return WordTypeMeta._values;\n  }\n}\n","import {\n  capitalizeFirstLetter,\n  lowerIncludes,\n  lowerStartsWith,\n} from \"../util/strings\";\nimport type { IndexedWords } from \"../ui/AutoCompleteSuggest\";\nimport { uniqWith } from \"../util/collection-helper\";\nimport { type Word, WordTypeMeta } from \"../model/Word\";\nimport type {\n  HitWord,\n  SelectionHistoryStorage,\n} from \"../storage/SelectionHistoryStorage\";\n\nexport type WordsByFirstLetter = { [firstLetter: string]: Word[] };\n\ninterface Judgement {\n  word: Word;\n  // TODO: remove value. use word.hit instead\n  value?: string;\n  alias: boolean;\n}\n\nexport function pushWord(\n  wordsByFirstLetter: WordsByFirstLetter,\n  key: string,\n  word: Word\n) {\n  if (wordsByFirstLetter[key] === undefined) {\n    wordsByFirstLetter[key] = [word];\n    return;\n  }\n\n  wordsByFirstLetter[key].push(word);\n}\n\n// Public for tests\nexport function judge(\n  word: Word,\n  query: string,\n  queryStartWithUpper: boolean\n): Judgement {\n  if (query === \"\") {\n    return {\n      word: {\n        ...word,\n        hit: word.value,\n      },\n      value: word.value,\n      alias: false,\n    };\n  }\n\n  if (lowerStartsWith(word.value, query)) {\n    if (\n      queryStartWithUpper &&\n      word.type !== \"internalLink\" &&\n      word.type !== \"frontMatter\"\n    ) {\n      const c = capitalizeFirstLetter(word.value);\n      return {\n        word: {\n          ...word,\n          value: c,\n          hit: c,\n        },\n        value: c,\n        alias: false,\n      };\n    } else {\n      return {\n        word: {\n          ...word,\n          hit: word.value,\n        },\n        value: word.value,\n        alias: false,\n      };\n    }\n  }\n  const matchedAlias = word.aliases?.find((a) => lowerStartsWith(a, query));\n  if (matchedAlias) {\n    return {\n      word: {\n        ...word,\n        hit: matchedAlias,\n      },\n      value: matchedAlias,\n      alias: true,\n    };\n  }\n\n  return {\n    word,\n    alias: false,\n  };\n}\n\nexport function suggestWords(\n  indexedWords: IndexedWords,\n  query: string,\n  max: number,\n  option: {\n    frontMatter?: string;\n    selectionHistoryStorage?: SelectionHistoryStorage;\n  } = {}\n): Word[] {\n  const { frontMatter, selectionHistoryStorage } = option;\n  const queryStartWithUpper = capitalizeFirstLetter(query) === query;\n\n  const flattenFrontMatterWords = () => {\n    if (frontMatter === \"alias\" || frontMatter === \"aliases\") {\n      return [];\n    }\n    if (frontMatter && indexedWords.frontMatter?.[frontMatter]) {\n      return Object.values(indexedWords.frontMatter?.[frontMatter]).flat();\n    }\n    return [];\n  };\n\n  const words = queryStartWithUpper\n    ? frontMatter\n      ? flattenFrontMatterWords()\n      : [\n          ...(indexedWords.currentFile[query.charAt(0)] ?? []),\n          ...(indexedWords.currentFile[query.charAt(0).toLowerCase()] ?? []),\n          ...(indexedWords.currentVault[query.charAt(0)] ?? []),\n          ...(indexedWords.currentVault[query.charAt(0).toLowerCase()] ?? []),\n          ...(indexedWords.customDictionary[query.charAt(0)] ?? []),\n          ...(indexedWords.customDictionary[query.charAt(0).toLowerCase()] ??\n            []),\n          ...(indexedWords.internalLink[query.charAt(0)] ?? []),\n          ...(indexedWords.internalLink[query.charAt(0).toLowerCase()] ?? []),\n        ]\n    : frontMatter\n    ? flattenFrontMatterWords()\n    : [\n        ...(indexedWords.currentFile[query.charAt(0)] ?? []),\n        ...(indexedWords.currentFile[query.charAt(0).toUpperCase()] ?? []),\n        ...(indexedWords.currentVault[query.charAt(0)] ?? []),\n        ...(indexedWords.currentVault[query.charAt(0).toUpperCase()] ?? []),\n        ...(indexedWords.customDictionary[query.charAt(0)] ?? []),\n        ...(indexedWords.customDictionary[query.charAt(0).toUpperCase()] ?? []),\n        ...(indexedWords.internalLink[query.charAt(0)] ?? []),\n        ...(indexedWords.internalLink[query.charAt(0).toUpperCase()] ?? []),\n      ];\n\n  const candidate = Array.from(words)\n    .map((x) => judge(x, query, queryStartWithUpper))\n    .filter((x) => x.value !== undefined)\n    .sort((a, b) => {\n      const aWord = a.word as HitWord;\n      const bWord = b.word as HitWord;\n\n      const notSameWordType = aWord.type !== bWord.type;\n      if (frontMatter && notSameWordType) {\n        return bWord.type === \"frontMatter\" ? 1 : -1;\n      }\n\n      if (selectionHistoryStorage) {\n        const ret = selectionHistoryStorage.compare(\n          aWord as HitWord,\n          bWord as HitWord\n        );\n        if (ret !== 0) {\n          return ret;\n        }\n      }\n\n      if (a.value!.length !== b.value!.length) {\n        return a.value!.length > b.value!.length ? 1 : -1;\n      }\n      if (notSameWordType) {\n        return WordTypeMeta.of(bWord.type).priority >\n          WordTypeMeta.of(aWord.type).priority\n          ? 1\n          : -1;\n      }\n      if (a.alias !== b.alias) {\n        return a.alias ? 1 : -1;\n      }\n      return 0;\n    })\n    .map((x) => x.word)\n    .slice(0, max);\n\n  // XXX: There is no guarantee that equals with max, but it is important for performance\n  return uniqWith(\n    candidate,\n    (a, b) =>\n      a.value === b.value &&\n      WordTypeMeta.of(a.type).group === WordTypeMeta.of(b.type).group\n  );\n}\n\n// TODO: refactoring\n// Public for tests\nexport function judgeByPartialMatch(\n  word: Word,\n  query: string,\n  queryStartWithUpper: boolean\n): Judgement {\n  if (query === \"\") {\n    return {\n      word: { ...word, hit: word.value },\n      value: word.value,\n      alias: false,\n    };\n  }\n\n  if (lowerStartsWith(word.value, query)) {\n    if (\n      queryStartWithUpper &&\n      word.type !== \"internalLink\" &&\n      word.type !== \"frontMatter\"\n    ) {\n      const c = capitalizeFirstLetter(word.value);\n      return { word: { ...word, value: c, hit: c }, value: c, alias: false };\n    } else {\n      return {\n        word: { ...word, hit: word.value },\n        value: word.value,\n        alias: false,\n      };\n    }\n  }\n\n  const matchedAliasStarts = word.aliases?.find((a) =>\n    lowerStartsWith(a, query)\n  );\n  if (matchedAliasStarts) {\n    return {\n      word: { ...word, hit: matchedAliasStarts },\n      value: matchedAliasStarts,\n      alias: true,\n    };\n  }\n\n  if (lowerIncludes(word.value, query)) {\n    return {\n      word: { ...word, hit: word.value },\n      value: word.value,\n      alias: false,\n    };\n  }\n\n  const matchedAliasIncluded = word.aliases?.find((a) =>\n    lowerIncludes(a, query)\n  );\n  if (matchedAliasIncluded) {\n    return {\n      word: { ...word, hit: matchedAliasIncluded },\n      value: matchedAliasIncluded,\n      alias: true,\n    };\n  }\n\n  return { word: word, alias: false };\n}\n\nexport function suggestWordsByPartialMatch(\n  indexedWords: IndexedWords,\n  query: string,\n  max: number,\n  option: {\n    frontMatter?: string;\n    selectionHistoryStorage?: SelectionHistoryStorage;\n  } = {}\n): Word[] {\n  const { frontMatter, selectionHistoryStorage } = option;\n  const queryStartWithUpper = capitalizeFirstLetter(query) === query;\n\n  const flatObjectValues = (object: { [firstLetter: string]: Word[] }) =>\n    Object.values(object).flat();\n\n  const flattenFrontMatterWords = () => {\n    if (frontMatter === \"alias\" || frontMatter === \"aliases\") {\n      return [];\n    }\n    if (frontMatter && indexedWords.frontMatter?.[frontMatter]) {\n      return Object.values(indexedWords.frontMatter?.[frontMatter]).flat();\n    }\n    return [];\n  };\n\n  const words = frontMatter\n    ? flattenFrontMatterWords()\n    : [\n        ...flatObjectValues(indexedWords.currentFile),\n        ...flatObjectValues(indexedWords.currentVault),\n        ...flatObjectValues(indexedWords.customDictionary),\n        ...flatObjectValues(indexedWords.internalLink),\n      ];\n\n  const candidate = Array.from(words)\n    .map((x) => judgeByPartialMatch(x, query, queryStartWithUpper))\n    .filter((x) => x.value !== undefined)\n    .sort((a, b) => {\n      const aWord = a.word as HitWord;\n      const bWord = b.word as HitWord;\n\n      const notSameWordType = aWord.type !== bWord.type;\n      if (frontMatter && notSameWordType) {\n        return bWord.type === \"frontMatter\" ? 1 : -1;\n      }\n\n      if (selectionHistoryStorage) {\n        const ret = selectionHistoryStorage.compare(\n          aWord as HitWord,\n          bWord as HitWord\n        );\n        if (ret !== 0) {\n          return ret;\n        }\n      }\n\n      const as = lowerStartsWith(a.value!, query);\n      const bs = lowerStartsWith(b.value!, query);\n      if (as !== bs) {\n        return bs ? 1 : -1;\n      }\n\n      if (a.value!.length !== b.value!.length) {\n        return a.value!.length > b.value!.length ? 1 : -1;\n      }\n      if (notSameWordType) {\n        return WordTypeMeta.of(bWord.type).priority >\n          WordTypeMeta.of(aWord.type).priority\n          ? 1\n          : -1;\n      }\n      if (a.alias !== b.alias) {\n        return a.alias ? 1 : -1;\n      }\n      return 0;\n    })\n    .map((x) => x.word)\n    .slice(0, max);\n\n  // XXX: There is no guarantee that equals with max, but it is important for performance\n  return uniqWith(\n    candidate,\n    (a, b) =>\n      a.value === b.value &&\n      WordTypeMeta.of(a.type).group === WordTypeMeta.of(b.type).group\n  );\n}\n","export function basename(path: string, ext?: string): string {\n  const name = path.match(/.+[\\\\/]([^\\\\/]+)[\\\\/]?$/)?.[1] ?? path;\n  return ext && name.endsWith(ext) ? name.replace(ext, \"\") : name;\n}\n\nexport function extname(path: string): string {\n  const ext = basename(path).split(\".\").slice(1).pop();\n  return ext ? `.${ext}` : \"\";\n}\n\nexport function dirname(path: string): string {\n  return path.match(/(.+)[\\\\/].+$/)?.[1] ?? \".\";\n}\n\nexport function isURL(path: string): boolean {\n  return Boolean(path.match(new RegExp(\"^https?://\")));\n}\n","import { App, FileSystemAdapter, Notice, request } from \"obsidian\";\nimport { pushWord, type WordsByFirstLetter } from \"./suggester\";\nimport type { ColumnDelimiter } from \"../option/ColumnDelimiter\";\nimport { isURL } from \"../util/path\";\nimport type { CustomDictionaryWord } from \"../model/Word\";\nimport { excludeEmoji } from \"../util/strings\";\nimport type { AppHelper } from \"../app-helper\";\n\ntype JsonDictionary = {\n  /** If set, take precedence over [\"Caret location symbol after complement\"](https://tadashi-aikawa.github.io/docs-obsidian-various-complements-plugin/4.%20Options/4.6.%20Custom%20dictionary%20complement/%E2%9A%99%EF%B8%8FCaret%20location%20symbol%20after%20complement/) */\n  caretSymbol?: string;\n  /** If set, ignore [\"Insert space after completion\"](https://tadashi-aikawa.github.io/docs-obsidian-various-complements-plugin/4.%20Options/4.1.%20Main/%E2%9A%99%EF%B8%8FInsert%20space%20after%20completion/) */\n  ignoreSpaceAfterCompletion?: boolean;\n  words: {\n    value: string;\n    description?: string;\n    aliases?: string[];\n    /** If set, use this value for searching and rendering instead of `value` */\n    displayed?: string;\n  }[];\n};\n\nfunction escape(value: string): string {\n  // This tricky logics for Safari\n  // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/56\n  return value\n    .replace(/\\\\/g, \"__VariousComplementsEscape__\")\n    .replace(/\\n/g, \"\\\\n\")\n    .replace(/\\t/g, \"\\\\t\")\n    .replace(/__VariousComplementsEscape__/g, \"\\\\\\\\\");\n}\n\nfunction unescape(value: string): string {\n  // This tricky logics for Safari\n  // https://github.com/tadashi-aikawa/obsidian-various-complements-plugin/issues/56\n  return value\n    .replace(/\\\\\\\\/g, \"__VariousComplementsEscape__\")\n    .replace(/\\\\n/g, \"\\n\")\n    .replace(/\\\\t/g, \"\\t\")\n    .replace(/__VariousComplementsEscape__/g, \"\\\\\");\n}\n\nfunction jsonToWords(\n  json: JsonDictionary,\n  path: string,\n  systemCaretSymbol?: string\n): CustomDictionaryWord[] {\n  return json.words.map((x) => ({\n    value: x.displayed || x.value,\n    description: x.description,\n    aliases: x.aliases,\n    type: \"customDictionary\",\n    createdPath: path,\n    insertedText: x.displayed ? x.value : undefined,\n    caretSymbol: json.caretSymbol ?? systemCaretSymbol,\n    ignoreSpaceAfterCompletion: json.ignoreSpaceAfterCompletion,\n  }));\n}\n\nfunction lineToWord(\n  line: string,\n  delimiter: ColumnDelimiter,\n  path: string,\n  delimiterForDisplay?: string,\n  delimiterForHide?: string,\n  systemCaretSymbol?: string\n): CustomDictionaryWord {\n  const [v, description, ...aliases] = line.split(delimiter.value);\n\n  let value = unescape(v);\n  let insertedText: string | undefined;\n  let displayedText = value;\n\n  if (delimiterForDisplay && value.includes(delimiterForDisplay)) {\n    [displayedText, insertedText] = value.split(delimiterForDisplay);\n  }\n  if (delimiterForHide && value.includes(delimiterForHide)) {\n    insertedText = value.replace(delimiterForHide, \"\");\n    displayedText = `${value.split(delimiterForHide)[0]} ...`;\n  }\n\n  return {\n    value: displayedText,\n    description,\n    aliases,\n    type: \"customDictionary\",\n    createdPath: path,\n    insertedText,\n    caretSymbol: systemCaretSymbol,\n  };\n}\n\nfunction wordToLine(\n  word: CustomDictionaryWord,\n  delimiter: ColumnDelimiter,\n  dividerForDisplay: string | null\n): string {\n  const value =\n    word.insertedText && dividerForDisplay\n      ? `${word.value}${dividerForDisplay}${word.insertedText}`\n      : word.value;\n\n  const escapedValue = escape(value);\n  if (!word.description && !word.aliases) {\n    return escapedValue;\n  }\n  if (!word.aliases) {\n    return [escapedValue, word.description].join(delimiter.value);\n  }\n  return [escapedValue, word.description, ...word.aliases].join(\n    delimiter.value\n  );\n}\n\nfunction synonymAliases(name: string): string[] {\n  const lessEmojiValue = excludeEmoji(name);\n  return name === lessEmojiValue ? [] : [lessEmojiValue];\n}\n\ntype Option = {\n  regexp: string;\n  delimiterForHide?: string;\n  delimiterForDisplay?: string;\n  caretSymbol?: string;\n};\n\nexport class CustomDictionaryWordProvider {\n  private words: CustomDictionaryWord[] = [];\n  wordByValue: { [value: string]: CustomDictionaryWord } = {};\n  wordsByFirstLetter: WordsByFirstLetter = {};\n\n  private appHelper: AppHelper;\n  private fileSystemAdapter: FileSystemAdapter;\n  private paths: string[];\n  private delimiter: ColumnDelimiter;\n  private dividerForDisplay: string | null;\n\n  constructor(app: App, appHelper: AppHelper) {\n    this.appHelper = appHelper;\n    this.fileSystemAdapter = app.vault.adapter as FileSystemAdapter;\n  }\n\n  get editablePaths(): string[] {\n    return this.paths.filter((x) => !isURL(x) && !x.endsWith(\".json\"));\n  }\n\n  private async loadWords(\n    path: string,\n    option: Option\n  ): Promise<CustomDictionaryWord[]> {\n    const contents = isURL(path)\n      ? await request({ url: path })\n      : await this.fileSystemAdapter.read(path);\n\n    const words = path.endsWith(\".json\")\n      ? jsonToWords(JSON.parse(contents), path, option.caretSymbol)\n      : contents\n          .split(/\\r\\n|\\n/)\n          .map((x) => x.replace(/%%.*%%/g, \"\"))\n          .filter((x) => x)\n          .map((x) =>\n            lineToWord(\n              x,\n              this.delimiter,\n              path,\n              option.delimiterForDisplay,\n              option.delimiterForHide,\n              option.caretSymbol\n            )\n          );\n\n    return words.filter(\n      (x) => !option.regexp || x.value.match(new RegExp(option.regexp))\n    );\n  }\n\n  async refreshCustomWords(option: Option): Promise<void> {\n    this.clearWords();\n\n    for (const path of this.paths) {\n      try {\n        const words = await this.loadWords(path, option);\n        words.forEach((x) => this.addWord(x));\n      } catch (e) {\n        // noinspection ObjectAllocationIgnored\n        new Notice(\n          `⚠ Fail to load ${path} -- Various Complements Plugin -- \\n ${e}`,\n          0\n        );\n      }\n    }\n  }\n\n  async addWordWithDictionary(\n    word: CustomDictionaryWord,\n    dictionaryPath: string\n  ): Promise<void> {\n    this.addWord(word);\n    await this.fileSystemAdapter.append(\n      dictionaryPath,\n      \"\\n\" + wordToLine(word, this.delimiter, this.dividerForDisplay)\n    );\n  }\n\n  private addWord(word: CustomDictionaryWord) {\n    this.words.push(word);\n\n    // Add aliases as a synonym\n    const wordWithSynonym = {\n      ...word,\n      aliases: [...(word.aliases ?? []), ...synonymAliases(word.value)],\n    };\n\n    this.wordByValue[wordWithSynonym.value] = wordWithSynonym;\n    pushWord(\n      this.wordsByFirstLetter,\n      wordWithSynonym.value.charAt(0),\n      wordWithSynonym\n    );\n    wordWithSynonym.aliases?.forEach((a) =>\n      pushWord(this.wordsByFirstLetter, a.charAt(0), wordWithSynonym)\n    );\n  }\n\n  clearWords(): void {\n    this.words = [];\n    this.wordByValue = {};\n    this.wordsByFirstLetter = {};\n  }\n\n  get wordCount(): number {\n    return this.words.length;\n  }\n\n  setSettings(\n    paths: string[],\n    delimiter: ColumnDelimiter,\n    dividerForDisplay: string | null\n  ) {\n    this.paths = paths;\n    this.delimiter = delimiter;\n    this.dividerForDisplay = dividerForDisplay;\n  }\n}\n","import type { App } from \"obsidian\";\nimport { groupBy, uniq } from \"../util/collection-helper\";\nimport type { WordsByFirstLetter } from \"./suggester\";\nimport type { Tokenizer } from \"../tokenizer/tokenizer\";\nimport type { AppHelper } from \"../app-helper\";\nimport { allAlphabets, startsSmallLetterOnlyFirst } from \"../util/strings\";\nimport type { Word } from \"../model/Word\";\n\nexport class CurrentFileWordProvider {\n  wordsByFirstLetter: WordsByFirstLetter = {};\n  private words: Word[] = [];\n  private tokenizer: Tokenizer;\n\n  constructor(private app: App, private appHelper: AppHelper) {}\n\n  async refreshWords(\n    onlyEnglish: boolean,\n    minNumberOfCharacters: number\n  ): Promise<void> {\n    this.clearWords();\n\n    const editor = this.appHelper.getCurrentEditor();\n    if (!editor) {\n      return;\n    }\n\n    const file = this.app.workspace.getActiveFile();\n    if (!file) {\n      return;\n    }\n\n    const currentToken = this.tokenizer\n      .tokenize(\n        editor.getLine(editor.getCursor().line).slice(0, editor.getCursor().ch)\n      )\n      .last();\n\n    const content = await this.app.vault.cachedRead(file);\n    const tokens = this.tokenizer\n      .tokenize(content)\n      .filter((x) => {\n        if (x.length < minNumberOfCharacters) {\n          return false;\n        }\n        if (this.tokenizer.shouldIgnoreOnCurrent(x)) {\n          return false;\n        }\n        return onlyEnglish ? allAlphabets(x) : true;\n      })\n      .map((x) => (startsSmallLetterOnlyFirst(x) ? x.toLowerCase() : x));\n    this.words = uniq(tokens)\n      .filter((x) => x !== currentToken)\n      .map((x) => ({\n        value: x,\n        type: \"currentFile\",\n        createdPath: file.path,\n      }));\n    this.wordsByFirstLetter = groupBy(this.words, (x) => x.value.charAt(0));\n  }\n\n  clearWords(): void {\n    this.words = [];\n    this.wordsByFirstLetter = {};\n  }\n\n  get wordCount(): number {\n    return this.words.length;\n  }\n\n  setSettings(tokenizer: Tokenizer) {\n    this.tokenizer = tokenizer;\n  }\n}\n","import type { App } from \"obsidian\";\nimport { pushWord, type WordsByFirstLetter } from \"./suggester\";\nimport type { AppHelper } from \"../app-helper\";\nimport { excludeEmoji } from \"../util/strings\";\nimport type { InternalLinkWord, Word } from \"../model/Word\";\n\nexport class InternalLinkWordProvider {\n  private words: Word[] = [];\n  wordsByFirstLetter: WordsByFirstLetter = {};\n\n  constructor(private app: App, private appHelper: AppHelper) {}\n\n  refreshWords(\n    wordAsInternalLinkAlias: boolean,\n    excludePathPrefixPatterns: string[]\n  ): void {\n    this.clearWords();\n\n    const synonymAliases = (name: string): string[] => {\n      const lessEmojiValue = excludeEmoji(name);\n      return name === lessEmojiValue ? [] : [lessEmojiValue];\n    };\n\n    const resolvedInternalLinkWords: InternalLinkWord[] = this.app.vault\n      .getMarkdownFiles()\n      .filter((f) =>\n        excludePathPrefixPatterns.every((x) => !f.path.startsWith(x))\n      )\n      .flatMap((x) => {\n        const aliases = this.appHelper.getAliases(x);\n\n        if (wordAsInternalLinkAlias) {\n          return [\n            {\n              value: x.basename,\n              type: \"internalLink\",\n              createdPath: x.path,\n              aliases: synonymAliases(x.basename),\n              description: x.path,\n            },\n            ...aliases.map((a) => ({\n              value: a,\n              type: \"internalLink\",\n              createdPath: x.path,\n              aliases: synonymAliases(a),\n              description: x.path,\n              aliasMeta: {\n                origin: x.basename,\n              },\n            })),\n          ] as InternalLinkWord[];\n        } else {\n          return [\n            {\n              value: x.basename,\n              type: \"internalLink\",\n              createdPath: x.path,\n              aliases: [\n                ...synonymAliases(x.basename),\n                ...aliases,\n                ...aliases.flatMap(synonymAliases),\n              ],\n              description: x.path,\n            },\n          ] as InternalLinkWord[];\n        }\n      });\n\n    const unresolvedInternalLinkWords: InternalLinkWord[] = this.appHelper\n      .searchPhantomLinks()\n      .map(({ path, link }) => {\n        return {\n          value: link,\n          type: \"internalLink\",\n          createdPath: path,\n          aliases: synonymAliases(link),\n          description: `Appeared in -> ${path}`,\n          phantom: true,\n        };\n      });\n\n    this.words = [...resolvedInternalLinkWords, ...unresolvedInternalLinkWords];\n    for (const word of this.words) {\n      pushWord(this.wordsByFirstLetter, word.value.charAt(0), word);\n      word.aliases?.forEach((a) =>\n        pushWord(this.wordsByFirstLetter, a.charAt(0), word)\n      );\n    }\n  }\n\n  clearWords(): void {\n    this.words = [];\n    this.wordsByFirstLetter = {};\n  }\n\n  get wordCount(): number {\n    return this.words.length;\n  }\n}\n","import type { IndexedWords } from \"../ui/AutoCompleteSuggest\";\nimport { suggestWords, suggestWordsByPartialMatch } from \"./suggester\";\nimport type { Word } from \"../model/Word\";\nimport type { SelectionHistoryStorage } from \"../storage/SelectionHistoryStorage\";\n\ntype Name = \"prefix\" | \"partial\";\n\ntype Handler = (\n  indexedWords: IndexedWords,\n  query: string,\n  max: number,\n  option: {\n    frontMatter?: string;\n    selectionHistoryStorage?: SelectionHistoryStorage;\n  }\n) => Word[];\n\nexport class MatchStrategy {\n  private static readonly _values: MatchStrategy[] = [];\n\n  static readonly PREFIX = new MatchStrategy(\"prefix\", suggestWords);\n  static readonly PARTIAL = new MatchStrategy(\n    \"partial\",\n    suggestWordsByPartialMatch\n  );\n\n  private constructor(readonly name: Name, readonly handler: Handler) {\n    MatchStrategy._values.push(this);\n  }\n\n  static fromName(name: string): MatchStrategy {\n    return MatchStrategy._values.find((x) => x.name === name)!;\n  }\n\n  static values(): MatchStrategy[] {\n    return MatchStrategy._values;\n  }\n}\n","import type { Modifier } from \"obsidian\";\n\ntype Name =\n  | \"None\"\n  | \"Tab, Shift+Tab\"\n  | \"Ctrl/Cmd+N, Ctrl/Cmd+P\"\n  | \"Ctrl/Cmd+J, Ctrl/Cmd+K\";\ninterface KeyBind {\n  modifiers: Modifier[];\n  key: string | null;\n}\n\nexport class CycleThroughSuggestionsKeys {\n  private static readonly _values: CycleThroughSuggestionsKeys[] = [];\n\n  static readonly NONE = new CycleThroughSuggestionsKeys(\n    \"None\",\n    { modifiers: [], key: null },\n    { modifiers: [], key: null }\n  );\n  static readonly TAB = new CycleThroughSuggestionsKeys(\n    \"Tab, Shift+Tab\",\n    { modifiers: [], key: \"Tab\" },\n    { modifiers: [\"Shift\"], key: \"Tab\" }\n  );\n  static readonly EMACS = new CycleThroughSuggestionsKeys(\n    \"Ctrl/Cmd+N, Ctrl/Cmd+P\",\n    { modifiers: [\"Mod\"], key: \"N\" },\n    { modifiers: [\"Mod\"], key: \"P\" }\n  );\n  static readonly VIM = new CycleThroughSuggestionsKeys(\n    \"Ctrl/Cmd+J, Ctrl/Cmd+K\",\n    { modifiers: [\"Mod\"], key: \"J\" },\n    { modifiers: [\"Mod\"], key: \"K\" }\n  );\n\n  private constructor(\n    readonly name: Name,\n    readonly nextKey: KeyBind,\n    readonly previousKey: KeyBind\n  ) {\n    CycleThroughSuggestionsKeys._values.push(this);\n  }\n\n  static fromName(name: string): CycleThroughSuggestionsKeys {\n    return CycleThroughSuggestionsKeys._values.find((x) => x.name === name)!;\n  }\n\n  static values(): CycleThroughSuggestionsKeys[] {\n    return CycleThroughSuggestionsKeys._values;\n  }\n}\n","type Delimiter = \"\\t\" | \",\" | \"|\";\n\nexport class ColumnDelimiter {\n  private static readonly _values: ColumnDelimiter[] = [];\n\n  static readonly TAB = new ColumnDelimiter(\"Tab\", \"\\t\");\n  static readonly COMMA = new ColumnDelimiter(\"Comma\", \",\");\n  static readonly PIPE = new ColumnDelimiter(\"Pipe\", \"|\");\n\n  private constructor(readonly name: string, readonly value: Delimiter) {\n    ColumnDelimiter._values.push(this);\n  }\n\n  static fromName(name: string): ColumnDelimiter {\n    return ColumnDelimiter._values.find((x) => x.name === name)!;\n  }\n\n  static values(): ColumnDelimiter[] {\n    return ColumnDelimiter._values;\n  }\n}\n","import type { Modifier } from \"obsidian\";\n\ntype Name =\n  | \"Enter\"\n  | \"Tab\"\n  | \"Ctrl/Cmd+Enter\"\n  | \"Alt+Enter\"\n  | \"Shift+Enter\"\n  | \"Space\"\n  | \"Shift+Space\"\n  | \"Backquote\"\n  | \"None\";\ninterface KeyBind {\n  modifiers: Modifier[];\n  key: string | null;\n}\n\nexport class SelectSuggestionKey {\n  private static readonly _values: SelectSuggestionKey[] = [];\n\n  static readonly ENTER = new SelectSuggestionKey(\"Enter\", {\n    modifiers: [],\n    key: \"Enter\",\n  });\n  static readonly TAB = new SelectSuggestionKey(\"Tab\", {\n    modifiers: [],\n    key: \"Tab\",\n  });\n  static readonly MOD_ENTER = new SelectSuggestionKey(\"Ctrl/Cmd+Enter\", {\n    modifiers: [\"Mod\"],\n    key: \"Enter\",\n  });\n  static readonly ALT_ENTER = new SelectSuggestionKey(\"Alt+Enter\", {\n    modifiers: [\"Alt\"],\n    key: \"Enter\",\n  });\n  static readonly SHIFT_ENTER = new SelectSuggestionKey(\"Shift+Enter\", {\n    modifiers: [\"Shift\"],\n    key: \"Enter\",\n  });\n  static readonly SPACE = new SelectSuggestionKey(\"Space\", {\n    modifiers: [],\n    key: \" \",\n  });\n  static readonly SHIFT_SPACE = new SelectSuggestionKey(\"Shift+Space\", {\n    modifiers: [\"Shift\"],\n    key: \" \",\n  });\n  static readonly BACKQUOTE = new SelectSuggestionKey(\"Backquote\", {\n    modifiers: [],\n    key: \"`\",\n  });\n  static readonly None = new SelectSuggestionKey(\"None\", {\n    modifiers: [],\n    key: \"\",\n  });\n\n  private constructor(readonly name: Name, readonly keyBind: KeyBind) {\n    SelectSuggestionKey._values.push(this);\n  }\n\n  static fromName(name: string): SelectSuggestionKey {\n    return SelectSuggestionKey._values.find((x) => x.name === name)!;\n  }\n\n  static values(): SelectSuggestionKey[] {\n    return SelectSuggestionKey._values;\n  }\n}\n","import type { App } from \"obsidian\";\nimport { groupBy } from \"../util/collection-helper\";\nimport type { WordsByFirstLetter } from \"./suggester\";\nimport type { Tokenizer } from \"../tokenizer/tokenizer\";\nimport type { AppHelper } from \"../app-helper\";\nimport type { Word } from \"../model/Word\";\nimport { dirname } from \"../util/path\";\nimport { startsSmallLetterOnlyFirst } from \"../util/strings\";\n\nexport class CurrentVaultWordProvider {\n  wordsByFirstLetter: WordsByFirstLetter = {};\n  private words: Word[] = [];\n  private tokenizer: Tokenizer;\n  private includePrefixPatterns: string[];\n  private excludePrefixPatterns: string[];\n  private onlyUnderCurrentDirectory: boolean;\n\n  constructor(private app: App, private appHelper: AppHelper) {}\n\n  async refreshWords(minNumberOfCharacters: number): Promise<void> {\n    this.clearWords();\n\n    const currentDirname = this.appHelper.getCurrentDirname();\n\n    const markdownFilePaths = this.app.vault\n      .getMarkdownFiles()\n      .map((x) => x.path)\n      .filter((p) => this.includePrefixPatterns.every((x) => p.startsWith(x)))\n      .filter((p) => this.excludePrefixPatterns.every((x) => !p.startsWith(x)))\n      .filter(\n        (p) => !this.onlyUnderCurrentDirectory || dirname(p) === currentDirname\n      );\n\n    let wordByValue: { [value: string]: Word } = {};\n    for (const path of markdownFilePaths) {\n      const content = await this.app.vault.adapter.read(path);\n\n      const tokens = this.tokenizer\n        .tokenize(content)\n        .filter(\n          (x) =>\n            x.length >= minNumberOfCharacters &&\n            !this.tokenizer.shouldIgnoreOnCurrent(x)\n        )\n        .map((x) => (startsSmallLetterOnlyFirst(x) ? x.toLowerCase() : x));\n      for (const token of tokens) {\n        wordByValue[token] = {\n          value: token,\n          type: \"currentVault\",\n          createdPath: path,\n          description: path,\n        };\n      }\n    }\n\n    this.words = Object.values(wordByValue);\n    this.wordsByFirstLetter = groupBy(this.words, (x) => x.value.charAt(0));\n  }\n\n  clearWords(): void {\n    this.words = [];\n    this.wordsByFirstLetter = {};\n  }\n\n  get wordCount(): number {\n    return this.words.length;\n  }\n\n  setSettings(\n    tokenizer: Tokenizer,\n    includePrefixPatterns: string[],\n    excludePrefixPatterns: string[],\n    onlyUnderCurrentDirectory: boolean\n  ) {\n    this.tokenizer = tokenizer;\n    this.includePrefixPatterns = includePrefixPatterns;\n    this.excludePrefixPatterns = excludePrefixPatterns;\n    this.onlyUnderCurrentDirectory = onlyUnderCurrentDirectory;\n  }\n}\n","import type { Modifier } from \"obsidian\";\n\ntype Name = \"None\" | \"Ctrl/Cmd+Enter\" | \"Alt+Enter\" | \"Shift+Enter\";\ninterface KeyBind {\n  modifiers: Modifier[];\n  key: string | null;\n}\n\nexport class OpenSourceFileKeys {\n  private static readonly _values: OpenSourceFileKeys[] = [];\n\n  static readonly NONE = new OpenSourceFileKeys(\"None\", {\n    modifiers: [],\n    key: null,\n  });\n  static readonly MOD_ENTER = new OpenSourceFileKeys(\"Ctrl/Cmd+Enter\", {\n    modifiers: [\"Mod\"],\n    key: \"Enter\",\n  });\n  static readonly ALT_ENTER = new OpenSourceFileKeys(\"Alt+Enter\", {\n    modifiers: [\"Alt\"],\n    key: \"Enter\",\n  });\n  static readonly SHIFT_ENTER = new OpenSourceFileKeys(\"Shift+Enter\", {\n    modifiers: [\"Shift\"],\n    key: \"Enter\",\n  });\n\n  private constructor(readonly name: Name, readonly keyBind: KeyBind) {\n    OpenSourceFileKeys._values.push(this);\n  }\n\n  static fromName(name: string): OpenSourceFileKeys {\n    return OpenSourceFileKeys._values.find((x) => x.name === name)!;\n  }\n\n  static values(): OpenSourceFileKeys[] {\n    return OpenSourceFileKeys._values;\n  }\n}\n","import type { Word } from \"../model/Word\";\nimport { basename } from \"../util/path\";\n\nexport class DescriptionOnSuggestion {\n  private static readonly _values: DescriptionOnSuggestion[] = [];\n\n  static readonly NONE = new DescriptionOnSuggestion(\"None\", () => null);\n  static readonly SHORT = new DescriptionOnSuggestion(\"Short\", (word) => {\n    if (!word.description) {\n      return null;\n    }\n    return word.type === \"customDictionary\"\n      ? word.description\n      : basename(word.description);\n  });\n  static readonly FULL = new DescriptionOnSuggestion(\n    \"Full\",\n    (word) => word.description ?? null\n  );\n\n  private constructor(\n    readonly name: string,\n    readonly toDisplay: (word: Word) => string | null\n  ) {\n    DescriptionOnSuggestion._values.push(this);\n  }\n\n  static fromName(name: string): DescriptionOnSuggestion {\n    return DescriptionOnSuggestion._values.find((x) => x.name === name)!;\n  }\n\n  static values(): DescriptionOnSuggestion[] {\n    return DescriptionOnSuggestion._values;\n  }\n}\n","import type { App, TFile } from \"obsidian\";\nimport type { WordsByFirstLetter } from \"./suggester\";\nimport type { AppHelper, FrontMatterValue } from \"../app-helper\";\nimport type { FrontMatterWord } from \"../model/Word\";\nimport { excludeEmoji } from \"../util/strings\";\nimport { groupBy, uniqBy } from \"../util/collection-helper\";\n\nfunction synonymAliases(name: string): string[] {\n  const lessEmojiValue = excludeEmoji(name);\n  return name === lessEmojiValue ? [] : [lessEmojiValue];\n}\n\nfunction frontMatterToWords(\n  file: TFile,\n  key: string,\n  values: FrontMatterValue\n): FrontMatterWord[] {\n  return values.map((x) => ({\n    key,\n    value: x,\n    type: \"frontMatter\",\n    createdPath: file.path,\n    aliases: synonymAliases(x),\n  }));\n}\n\nfunction pickWords(file: TFile, fm: { [key: string]: FrontMatterValue }) {\n  return Object.entries(fm)\n    .filter(\n      ([_key, value]) =>\n        value != null &&\n        (typeof value === \"string\" || typeof value[0] === \"string\")\n    )\n    .flatMap(([key, value]) => frontMatterToWords(file, key, value));\n}\n\n// noinspection FunctionWithMultipleLoopsJS\nfunction extractAndUniqWords(\n  wordsByCreatedPath: FrontMatterWordProvider[\"wordsByCreatedPath\"]\n): FrontMatterWord[] {\n  return uniqBy(\n    Object.values(wordsByCreatedPath).flat(),\n    (w) => w.key + w.value.toLowerCase()\n  );\n}\n\nfunction indexingWords(\n  words: FrontMatterWord[]\n): FrontMatterWordProvider[\"wordsByFirstLetterByKey\"] {\n  const wordsByKey = groupBy(words, (x) => x.key);\n  return Object.fromEntries(\n    Object.entries(wordsByKey).map(\n      ([key, words]: [string, FrontMatterWord[]]) => [\n        key,\n        groupBy(words, (w) => w.value.charAt(0)),\n      ]\n    )\n  );\n}\n\nexport class FrontMatterWordProvider {\n  private wordsByCreatedPath: { [path: string]: FrontMatterWord[] } = {};\n  words: FrontMatterWord[];\n  wordsByFirstLetterByKey: { [key: string]: WordsByFirstLetter };\n\n  constructor(private app: App, private appHelper: AppHelper) {}\n\n  refreshWords(): void {\n    this.clearWords();\n\n    this.app.vault.getMarkdownFiles().forEach((f) => {\n      const fm = this.appHelper.getFrontMatter(f);\n      if (!fm) {\n        return;\n      }\n\n      this.wordsByCreatedPath[f.path] = pickWords(f, fm);\n    });\n\n    this.words = extractAndUniqWords(this.wordsByCreatedPath);\n    this.wordsByFirstLetterByKey = indexingWords(this.words);\n  }\n\n  updateWordIndex(file: TFile): void {\n    const fm = this.appHelper.getFrontMatter(file);\n    if (!fm) {\n      return;\n    }\n\n    this.wordsByCreatedPath[file.path] = pickWords(file, fm);\n  }\n\n  updateWords(): void {\n    this.words = extractAndUniqWords(this.wordsByCreatedPath);\n    this.wordsByFirstLetterByKey = indexingWords(this.words);\n  }\n\n  clearWords(): void {\n    this.wordsByCreatedPath = {};\n    this.words = [];\n    this.wordsByFirstLetterByKey = {};\n  }\n\n  get wordCount(): number {\n    return this.words.length;\n  }\n}\n","import type { IndexedWords } from \"../ui/AutoCompleteSuggest\";\nimport { suggestWords, suggestWordsByPartialMatch } from \"./suggester\";\nimport type { Word } from \"../model/Word\";\nimport type { SelectionHistoryStorage } from \"../storage/SelectionHistoryStorage\";\n\ntype Name = \"inherit\" | \"prefix\" | \"partial\";\n\ntype Handler = (\n  indexedWords: IndexedWords,\n  query: string,\n  max: number,\n  option: {\n    frontMatter?: string;\n    selectionHistoryStorage?: SelectionHistoryStorage;\n  }\n) => Word[];\n\nconst neverUsedHandler = (..._args: any[]) => [];\n\nexport class SpecificMatchStrategy {\n  private static readonly _values: SpecificMatchStrategy[] = [];\n\n  static readonly INHERIT = new SpecificMatchStrategy(\n    \"inherit\",\n    neverUsedHandler\n  );\n  static readonly PREFIX = new SpecificMatchStrategy(\"prefix\", suggestWords);\n  static readonly PARTIAL = new SpecificMatchStrategy(\n    \"partial\",\n    suggestWordsByPartialMatch\n  );\n\n  private constructor(readonly name: Name, readonly handler: Handler) {\n    SpecificMatchStrategy._values.push(this);\n  }\n\n  static fromName(name: string): SpecificMatchStrategy {\n    return SpecificMatchStrategy._values.find((x) => x.name === name)!;\n  }\n\n  static values(): SpecificMatchStrategy[] {\n    return SpecificMatchStrategy._values;\n  }\n}\n","import type { Word } from \"../model/Word\";\nimport type { PartialRequired } from \"../types\";\n\nexport type HitWord = PartialRequired<Word, \"hit\">;\nexport type SelectionHistory = {\n  count: number;\n  lastUpdated: number;\n};\n\nexport type SelectionHistoryTree = {\n  [hit: string]: {\n    [value: string]: {\n      [type: string]: SelectionHistory;\n    };\n  };\n};\n\nconst SEC = 1000;\nconst MIN = SEC * 60;\nconst HOUR = MIN * 60;\nconst DAY = HOUR * 24;\nconst WEEK = DAY * 7;\n\nfunction calcScore(history: SelectionHistory | undefined): number {\n  if (!history) {\n    return 0;\n  }\n\n  const behind = Date.now() - history.lastUpdated;\n\n  // noinspection IfStatementWithTooManyBranchesJS\n  if (behind < MIN) {\n    return 8 * history.count;\n  } else if (behind < HOUR) {\n    return 4 * history.count;\n  } else if (behind < DAY) {\n    return 2 * history.count;\n  } else if (behind < WEEK) {\n    return 0.5 * history.count;\n  } else {\n    return 0.25 * history.count;\n  }\n}\n\nexport class SelectionHistoryStorage {\n  data: SelectionHistoryTree;\n  version: number;\n  persistedVersion: number;\n\n  constructor(data: SelectionHistoryTree = {}) {\n    this.data = data;\n\n    const now = Date.now();\n    this.version = now;\n    this.persistedVersion = now;\n  }\n\n  // noinspection FunctionWithMultipleLoopsJS\n  purge() {\n    for (const hit of Object.keys(this.data)) {\n      for (const value of Object.keys(this.data[hit])) {\n        for (const kind of Object.keys(this.data[hit][value])) {\n          if (Date.now() - this.data[hit][value][kind].lastUpdated > 4 * WEEK) {\n            delete this.data[hit][value][kind];\n          }\n        }\n\n        if (Object.isEmpty(this.data[hit][value])) {\n          delete this.data[hit][value];\n        }\n      }\n\n      if (Object.isEmpty(this.data[hit])) {\n        delete this.data[hit];\n      }\n    }\n  }\n\n  getSelectionHistory(word: HitWord): SelectionHistory | undefined {\n    return this.data[word.hit]?.[word.value]?.[word.type];\n  }\n\n  increment(word: HitWord): void {\n    if (!this.data[word.hit]) {\n      this.data[word.hit] = {};\n    }\n    if (!this.data[word.hit][word.value]) {\n      this.data[word.hit][word.value] = {};\n    }\n\n    if (this.data[word.hit][word.value][word.type]) {\n      this.data[word.hit][word.value][word.type] = {\n        count: this.data[word.hit][word.value][word.type].count + 1,\n        lastUpdated: Date.now(),\n      };\n    } else {\n      this.data[word.hit][word.value][word.type] = {\n        count: 1,\n        lastUpdated: Date.now(),\n      };\n    }\n\n    this.version = Date.now();\n  }\n\n  compare(w1: HitWord, w2: HitWord): -1 | 0 | 1 {\n    const score1 = calcScore(this.getSelectionHistory(w1));\n    const score2 = calcScore(this.getSelectionHistory(w2));\n\n    if (score1 === score2) {\n      return 0;\n    }\n\n    return score1 > score2 ? -1 : 1;\n  }\n\n  get shouldPersist(): boolean {\n    return this.version > this.persistedVersion;\n  }\n\n  syncPersistVersion(): void {\n    this.persistedVersion = this.version;\n  }\n}\n","import {\n  App,\n  debounce,\n  type Debouncer,\n  Editor,\n  type EditorPosition,\n  EditorSuggest,\n  type EditorSuggestContext,\n  type EditorSuggestTriggerInfo,\n  type EventRef,\n  type KeymapEventHandler,\n  type Modifier,\n  Notice,\n  Scope,\n  TFile,\n} from \"obsidian\";\nimport { createTokenizer, type Tokenizer } from \"../tokenizer/tokenizer\";\nimport { TokenizeStrategy } from \"../tokenizer/TokenizeStrategy\";\nimport type { Settings } from \"../setting/settings\";\nimport { AppHelper } from \"../app-helper\";\nimport type { WordsByFirstLetter } from \"../provider/suggester\";\nimport { CustomDictionaryWordProvider } from \"../provider/CustomDictionaryWordProvider\";\nimport { CurrentFileWordProvider } from \"../provider/CurrentFileWordProvider\";\nimport { InternalLinkWordProvider } from \"../provider/InternalLinkWordProvider\";\nimport { MatchStrategy } from \"../provider/MatchStrategy\";\nimport { CycleThroughSuggestionsKeys } from \"../option/CycleThroughSuggestionsKeys\";\nimport { ColumnDelimiter } from \"../option/ColumnDelimiter\";\nimport { SelectSuggestionKey } from \"../option/SelectSuggestionKey\";\nimport { uniqWith } from \"../util/collection-helper\";\nimport { CurrentVaultWordProvider } from \"../provider/CurrentVaultWordProvider\";\nimport type { ProviderStatusBar } from \"./ProviderStatusBar\";\nimport type { Word } from \"../model/Word\";\nimport { OpenSourceFileKeys } from \"../option/OpenSourceFileKeys\";\nimport { DescriptionOnSuggestion } from \"../option/DescriptionOnSuggestion\";\nimport { FrontMatterWordProvider } from \"../provider/FrontMatterWordProvider\";\nimport { SpecificMatchStrategy } from \"../provider/SpecificMatchStrategy\";\nimport {\n  type HitWord,\n  SelectionHistoryStorage,\n} from \"../storage/SelectionHistoryStorage\";\n\nfunction buildLogMessage(message: string, msec: number) {\n  return `${message}: ${Math.round(msec)}[ms]`;\n}\n\nexport type IndexedWords = {\n  currentFile: WordsByFirstLetter;\n  currentVault: WordsByFirstLetter;\n  customDictionary: WordsByFirstLetter;\n  internalLink: WordsByFirstLetter;\n  frontMatter: { [key: string]: WordsByFirstLetter };\n};\n\n// This is an unsafe code..!!\ninterface UnsafeEditorSuggestInterface {\n  scope: Scope & { keys: (KeymapEventHandler & { func: CallableFunction })[] };\n  suggestions: {\n    selectedItem: number;\n    useSelectedItem(ev: Partial<KeyboardEvent>): void;\n    setSelectedItem(selected: number, scroll: boolean): void;\n    values: Word[];\n  };\n  isOpen: boolean;\n}\n\nexport class AutoCompleteSuggest\n  extends EditorSuggest<Word>\n  implements UnsafeEditorSuggestInterface\n{\n  app: App;\n  settings: Settings;\n  appHelper: AppHelper;\n  statusBar: ProviderStatusBar;\n\n  currentFileWordProvider: CurrentFileWordProvider;\n  currentVaultWordProvider: CurrentVaultWordProvider;\n  customDictionaryWordProvider: CustomDictionaryWordProvider;\n  internalLinkWordProvider: InternalLinkWordProvider;\n  frontMatterWordProvider: FrontMatterWordProvider;\n  selectionHistoryStorage: SelectionHistoryStorage | undefined;\n\n  tokenizer: Tokenizer;\n  debounceGetSuggestions: Debouncer<\n    [EditorSuggestContext, (tokens: Word[]) => void]\n  >;\n  debounceClose: Debouncer<[]>;\n\n  runManually: boolean;\n  declare isOpen: boolean;\n\n  contextStartCh: number;\n\n  previousCurrentLine = \"\";\n\n  // unsafe!!\n  scope: UnsafeEditorSuggestInterface[\"scope\"];\n  suggestions: UnsafeEditorSuggestInterface[\"suggestions\"];\n\n  keymapEventHandler: KeymapEventHandler[] = [];\n  modifyEventRef: EventRef;\n  activeLeafChangeRef: EventRef;\n  metadataCacheChangeRef: EventRef;\n\n  private constructor(app: App, statusBar: ProviderStatusBar) {\n    super(app);\n    this.appHelper = new AppHelper(app);\n    this.statusBar = statusBar;\n  }\n\n  triggerComplete() {\n    const editor = this.appHelper.getCurrentEditor();\n    const activeFile = this.app.workspace.getActiveFile();\n    if (!editor || !activeFile) {\n      return;\n    }\n\n    // XXX: Unsafe\n    this.runManually = true;\n    (this as any).trigger(editor, activeFile, true);\n  }\n\n  static async new(\n    app: App,\n    settings: Settings,\n    statusBar: ProviderStatusBar,\n    onPersistSelectionHistory: () => void\n  ): Promise<AutoCompleteSuggest> {\n    const ins = new AutoCompleteSuggest(app, statusBar);\n\n    ins.currentFileWordProvider = new CurrentFileWordProvider(\n      ins.app,\n      ins.appHelper\n    );\n    ins.currentVaultWordProvider = new CurrentVaultWordProvider(\n      ins.app,\n      ins.appHelper\n    );\n    ins.customDictionaryWordProvider = new CustomDictionaryWordProvider(\n      ins.app,\n      ins.appHelper\n    );\n    ins.internalLinkWordProvider = new InternalLinkWordProvider(\n      ins.app,\n      ins.appHelper\n    );\n    ins.frontMatterWordProvider = new FrontMatterWordProvider(\n      ins.app,\n      ins.appHelper\n    );\n\n    ins.selectionHistoryStorage = new SelectionHistoryStorage(\n      settings.selectionHistoryTree\n    );\n    ins.selectionHistoryStorage.purge();\n\n    await ins.updateSettings(settings);\n\n    ins.modifyEventRef = app.vault.on(\"modify\", async (_) => {\n      await ins.refreshCurrentFileTokens();\n      if (ins.selectionHistoryStorage?.shouldPersist) {\n        ins.settings.selectionHistoryTree = ins.selectionHistoryStorage.data;\n        ins.selectionHistoryStorage.syncPersistVersion();\n        onPersistSelectionHistory();\n      }\n    });\n    ins.activeLeafChangeRef = app.workspace.on(\n      \"active-leaf-change\",\n      async (_) => {\n        await ins.refreshCurrentFileTokens();\n        ins.refreshInternalLinkTokens();\n        ins.updateFrontMatterToken();\n      }\n    );\n\n    ins.metadataCacheChangeRef = app.metadataCache.on(\"changed\", (f) => {\n      ins.updateFrontMatterTokenIndex(f);\n      if (!ins.appHelper.isActiveFile(f)) {\n        ins.updateFrontMatterToken();\n      }\n    });\n\n    // Avoid referring to incorrect cache\n    const cacheResolvedRef = app.metadataCache.on(\"resolved\", async () => {\n      ins.refreshInternalLinkTokens();\n      ins.refreshFrontMatterTokens();\n      // noinspection ES6MissingAwait\n      ins.refreshCustomDictionaryTokens();\n      // noinspection ES6MissingAwait\n      ins.refreshCurrentVaultTokens();\n\n      ins.app.metadataCache.offref(cacheResolvedRef);\n    });\n\n    return ins;\n  }\n\n  predictableComplete() {\n    const editor = this.appHelper.getCurrentEditor();\n    if (!editor) {\n      return;\n    }\n\n    const cursor = editor.getCursor();\n    const currentToken = this.tokenizer\n      .tokenize(editor.getLine(cursor.line).slice(0, cursor.ch))\n      .last();\n    if (!currentToken) {\n      return;\n    }\n\n    let suggestion = this.tokenizer\n      .tokenize(\n        editor.getRange({ line: Math.max(cursor.line - 50, 0), ch: 0 }, cursor)\n      )\n      .reverse()\n      .slice(1)\n      .find((x) => x.startsWith(currentToken));\n    if (!suggestion) {\n      suggestion = this.tokenizer\n        .tokenize(\n          editor.getRange(cursor, {\n            line: Math.min(cursor.line + 50, editor.lineCount() - 1),\n            ch: 0,\n          })\n        )\n        .find((x) => x.startsWith(currentToken));\n    }\n    if (!suggestion) {\n      return;\n    }\n\n    editor.replaceRange(\n      suggestion,\n      { line: cursor.line, ch: cursor.ch - currentToken.length },\n      { line: cursor.line, ch: cursor.ch }\n    );\n\n    this.close();\n    this.debounceClose();\n  }\n\n  unregister() {\n    this.app.vault.offref(this.modifyEventRef);\n    this.app.workspace.offref(this.activeLeafChangeRef);\n    this.app.metadataCache.offref(this.metadataCacheChangeRef);\n  }\n\n  // settings getters\n  get tokenizerStrategy(): TokenizeStrategy {\n    return TokenizeStrategy.fromName(this.settings.strategy);\n  }\n\n  get matchStrategy(): MatchStrategy {\n    return MatchStrategy.fromName(this.settings.matchStrategy);\n  }\n\n  get frontMatterComplementStrategy(): SpecificMatchStrategy {\n    return SpecificMatchStrategy.fromName(\n      this.settings.frontMatterComplementMatchStrategy\n    );\n  }\n\n  get minNumberTriggered(): number {\n    return (\n      this.settings.minNumberOfCharactersTriggered ||\n      this.tokenizerStrategy.triggerThreshold\n    );\n  }\n\n  get currentFileMinNumberOfCharacters(): number {\n    return (\n      this.settings.currentFileMinNumberOfCharacters ||\n      this.tokenizerStrategy.indexingThreshold\n    );\n  }\n\n  get currentVaultMinNumberOfCharacters(): number {\n    return (\n      this.settings.currentVaultMinNumberOfCharacters ||\n      this.tokenizerStrategy.indexingThreshold\n    );\n  }\n\n  get descriptionOnSuggestion(): DescriptionOnSuggestion {\n    return DescriptionOnSuggestion.fromName(\n      this.settings.descriptionOnSuggestion\n    );\n  }\n\n  get excludeInternalLinkPrefixPathPatterns(): string[] {\n    return this.settings.excludeInternalLinkPathPrefixPatterns\n      .split(\"\\n\")\n      .filter((x) => x);\n  }\n\n  // --- end ---\n\n  get indexedWords(): IndexedWords {\n    return {\n      currentFile: this.currentFileWordProvider.wordsByFirstLetter,\n      currentVault: this.currentVaultWordProvider.wordsByFirstLetter,\n      customDictionary: this.customDictionaryWordProvider.wordsByFirstLetter,\n      internalLink: this.internalLinkWordProvider.wordsByFirstLetter,\n      frontMatter: this.frontMatterWordProvider.wordsByFirstLetterByKey,\n    };\n  }\n\n  async updateSettings(settings: Settings) {\n    this.settings = settings;\n\n    this.statusBar.setMatchStrategy(this.matchStrategy);\n    this.statusBar.setComplementAutomatically(\n      this.settings.complementAutomatically\n    );\n\n    try {\n      this.tokenizer = await createTokenizer(this.tokenizerStrategy, this.app);\n    } catch (e: any) {\n      new Notice(e.message, 0);\n    }\n    this.currentFileWordProvider.setSettings(this.tokenizer);\n    this.currentVaultWordProvider.setSettings(\n      this.tokenizer,\n      settings.includeCurrentVaultPathPrefixPatterns\n        .split(\"\\n\")\n        .filter((x) => x),\n      settings.excludeCurrentVaultPathPrefixPatterns\n        .split(\"\\n\")\n        .filter((x) => x),\n      settings.includeCurrentVaultOnlyFilesUnderCurrentDirectory\n    );\n    this.customDictionaryWordProvider.setSettings(\n      settings.customDictionaryPaths.split(\"\\n\").filter((x) => x),\n      ColumnDelimiter.fromName(settings.columnDelimiter),\n      settings.delimiterToDivideSuggestionsForDisplayFromInsertion || null\n    );\n\n    this.debounceGetSuggestions = debounce(\n      (context: EditorSuggestContext, cb: (words: Word[]) => void) => {\n        const start = performance.now();\n\n        this.showDebugLog(() => `[context.query]: ${context.query}`);\n        const parsedQuery = JSON.parse(context.query) as {\n          currentFrontMatter?: string;\n          queries: {\n            word: string;\n            offset: number;\n          }[];\n        };\n\n        const words = parsedQuery.queries\n          .filter(\n            (x, i, xs) =>\n              parsedQuery.currentFrontMatter ||\n              (this.settings.minNumberOfWordsTriggeredPhrase + i - 1 <\n                xs.length &&\n                x.word.length >= this.minNumberTriggered &&\n                !x.word.endsWith(\" \"))\n          )\n          .map((q) => {\n            const handler =\n              parsedQuery.currentFrontMatter &&\n              this.frontMatterComplementStrategy !==\n                SpecificMatchStrategy.INHERIT\n                ? this.frontMatterComplementStrategy.handler\n                : this.matchStrategy.handler;\n            return handler(\n              this.indexedWords,\n              q.word,\n              this.settings.maxNumberOfSuggestions,\n              {\n                frontMatter: parsedQuery.currentFrontMatter,\n                selectionHistoryStorage: this.selectionHistoryStorage,\n              }\n            ).map((word) => ({ ...word, offset: q.offset }));\n          })\n          .flat();\n\n        cb(\n          uniqWith(\n            words,\n            (a, b) => a.value === b.value && a.type === b.type\n          ).slice(0, this.settings.maxNumberOfSuggestions)\n        );\n\n        this.showDebugLog(() =>\n          buildLogMessage(\"Get suggestions\", performance.now() - start)\n        );\n      },\n      this.settings.delayMilliSeconds,\n      true\n    );\n\n    this.debounceClose = debounce(() => {\n      this.close();\n    }, this.settings.delayMilliSeconds + 50);\n\n    this.registerKeymaps();\n  }\n\n  private registerKeymaps() {\n    const registerKeyAsIgnored = (\n      modifiers: Modifier[],\n      key: string | null\n    ) => {\n      this.keymapEventHandler.push(\n        this.scope.register(modifiers, key, () => {\n          this.close();\n          return true;\n        })\n      );\n    };\n\n    // Clear\n    this.keymapEventHandler.forEach((x) => this.scope.unregister(x));\n    this.keymapEventHandler = [];\n    this.scope.unregister(this.scope.keys.find((x) => x.key === \"Enter\")!);\n    this.scope.unregister(this.scope.keys.find((x) => x.key === \"ArrowUp\")!);\n    this.scope.unregister(this.scope.keys.find((x) => x.key === \"ArrowDown\")!);\n\n    // selectSuggestionKeys\n    const selectSuggestionKey = SelectSuggestionKey.fromName(\n      this.settings.selectSuggestionKeys\n    );\n    if (selectSuggestionKey !== SelectSuggestionKey.ENTER) {\n      registerKeyAsIgnored(\n        SelectSuggestionKey.ENTER.keyBind.modifiers,\n        SelectSuggestionKey.ENTER.keyBind.key\n      );\n    }\n    if (selectSuggestionKey !== SelectSuggestionKey.TAB) {\n      registerKeyAsIgnored(\n        SelectSuggestionKey.TAB.keyBind.modifiers,\n        SelectSuggestionKey.TAB.keyBind.key\n      );\n    }\n    if (selectSuggestionKey !== SelectSuggestionKey.None) {\n      this.keymapEventHandler.push(\n        this.scope.register(\n          selectSuggestionKey.keyBind.modifiers,\n          selectSuggestionKey.keyBind.key,\n          () => {\n            this.suggestions.useSelectedItem({});\n            return false;\n          }\n        )\n      );\n    }\n\n    // propagateESC\n    this.scope.keys.find((x) => x.key === \"Escape\")!.func = () => {\n      this.close();\n      return this.settings.propagateEsc;\n    };\n\n    // cycleThroughSuggestionsKeys\n    const selectNext = () => {\n      this.suggestions.setSelectedItem(this.suggestions.selectedItem + 1, true);\n      return false;\n    };\n    const selectPrevious = () => {\n      this.suggestions.setSelectedItem(this.suggestions.selectedItem - 1, true);\n      return false;\n    };\n\n    const cycleThroughSuggestionsKeys = CycleThroughSuggestionsKeys.fromName(\n      this.settings.additionalCycleThroughSuggestionsKeys\n    );\n    if (this.settings.disableUpDownKeysForCycleThroughSuggestionsKeys) {\n      this.keymapEventHandler.push(\n        this.scope.register([], \"ArrowDown\", () => {\n          this.close();\n          return true;\n        }),\n        this.scope.register([], \"ArrowUp\", () => {\n          this.close();\n          return true;\n        })\n      );\n    } else {\n      this.keymapEventHandler.push(\n        this.scope.register([], \"ArrowDown\", selectNext),\n        this.scope.register([], \"ArrowUp\", selectPrevious)\n      );\n    }\n    if (cycleThroughSuggestionsKeys !== CycleThroughSuggestionsKeys.NONE) {\n      if (cycleThroughSuggestionsKeys === CycleThroughSuggestionsKeys.TAB) {\n        this.scope.unregister(\n          this.scope.keys.find((x) => x.modifiers === \"\" && x.key === \"Tab\")!\n        );\n      }\n      this.keymapEventHandler.push(\n        this.scope.register(\n          cycleThroughSuggestionsKeys.nextKey.modifiers,\n          cycleThroughSuggestionsKeys.nextKey.key,\n          selectNext\n        ),\n        this.scope.register(\n          cycleThroughSuggestionsKeys.previousKey.modifiers,\n          cycleThroughSuggestionsKeys.previousKey.key,\n          selectPrevious\n        )\n      );\n    }\n\n    const openSourceFileKey = OpenSourceFileKeys.fromName(\n      this.settings.openSourceFileKey\n    );\n    if (openSourceFileKey !== OpenSourceFileKeys.NONE) {\n      this.keymapEventHandler.push(\n        this.scope.register(\n          openSourceFileKey.keyBind.modifiers,\n          openSourceFileKey.keyBind.key,\n          () => {\n            const item = this.suggestions.values[this.suggestions.selectedItem];\n            if (\n              item.type !== \"currentVault\" &&\n              item.type !== \"internalLink\" &&\n              item.type !== \"frontMatter\"\n            ) {\n              return false;\n            }\n\n            const markdownFile = this.appHelper.getMarkdownFileByPath(\n              item.createdPath\n            );\n            if (!markdownFile) {\n              // noinspection ObjectAllocationIgnored\n              new Notice(`Can't open ${item.createdPath}`);\n              return false;\n            }\n            this.appHelper.openMarkdownFile(markdownFile, true);\n            return false;\n          }\n        )\n      );\n    }\n  }\n\n  async refreshCurrentFileTokens(): Promise<void> {\n    const start = performance.now();\n    this.statusBar.setCurrentFileIndexing();\n\n    if (!this.settings.enableCurrentFileComplement) {\n      this.statusBar.setCurrentFileDisabled();\n      this.currentFileWordProvider.clearWords();\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢 Skip: Index current file tokens\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    await this.currentFileWordProvider.refreshWords(\n      this.settings.onlyComplementEnglishOnCurrentFileComplement,\n      this.currentFileMinNumberOfCharacters\n    );\n\n    this.statusBar.setCurrentFileIndexed(\n      this.currentFileWordProvider.wordCount\n    );\n    this.showDebugLog(() =>\n      buildLogMessage(\"Index current file tokens\", performance.now() - start)\n    );\n  }\n\n  async refreshCurrentVaultTokens(): Promise<void> {\n    const start = performance.now();\n    this.statusBar.setCurrentVaultIndexing();\n\n    if (!this.settings.enableCurrentVaultComplement) {\n      this.statusBar.setCurrentVaultDisabled();\n      this.currentVaultWordProvider.clearWords();\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢 Skip: Index current vault tokens\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    await this.currentVaultWordProvider.refreshWords(\n      this.currentVaultMinNumberOfCharacters\n    );\n\n    this.statusBar.setCurrentVaultIndexed(\n      this.currentVaultWordProvider.wordCount\n    );\n    this.showDebugLog(() =>\n      buildLogMessage(\"Index current vault tokens\", performance.now() - start)\n    );\n  }\n\n  async refreshCustomDictionaryTokens(): Promise<void> {\n    const start = performance.now();\n    this.statusBar.setCustomDictionaryIndexing();\n\n    if (!this.settings.enableCustomDictionaryComplement) {\n      this.statusBar.setCustomDictionaryDisabled();\n      this.customDictionaryWordProvider.clearWords();\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢Skip: Index custom dictionary tokens\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    await this.customDictionaryWordProvider.refreshCustomWords({\n      regexp: this.settings.customDictionaryWordRegexPattern,\n      delimiterForHide: this.settings.delimiterToHideSuggestion || undefined,\n      delimiterForDisplay:\n        this.settings.delimiterToDivideSuggestionsForDisplayFromInsertion ||\n        undefined,\n      caretSymbol:\n        this.settings.caretLocationSymbolAfterComplement || undefined,\n    });\n\n    this.statusBar.setCustomDictionaryIndexed(\n      this.customDictionaryWordProvider.wordCount\n    );\n    this.showDebugLog(() =>\n      buildLogMessage(\n        \"Index custom dictionary tokens\",\n        performance.now() - start\n      )\n    );\n  }\n\n  refreshInternalLinkTokens(): void {\n    const start = performance.now();\n    this.statusBar.setInternalLinkIndexing();\n\n    if (!this.settings.enableInternalLinkComplement) {\n      this.statusBar.setInternalLinkDisabled();\n      this.internalLinkWordProvider.clearWords();\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢Skip: Index internal link tokens\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    this.internalLinkWordProvider.refreshWords(\n      this.settings.suggestInternalLinkWithAlias,\n      this.excludeInternalLinkPrefixPathPatterns\n    );\n\n    this.statusBar.setInternalLinkIndexed(\n      this.internalLinkWordProvider.wordCount\n    );\n    this.showDebugLog(() =>\n      buildLogMessage(\"Index internal link tokens\", performance.now() - start)\n    );\n  }\n\n  refreshFrontMatterTokens(): void {\n    const start = performance.now();\n    this.statusBar.setFrontMatterIndexing();\n\n    if (!this.settings.enableFrontMatterComplement) {\n      this.statusBar.setFrontMatterDisabled();\n      this.frontMatterWordProvider.clearWords();\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢Skip: Index front matter tokens\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    this.frontMatterWordProvider.refreshWords();\n\n    this.statusBar.setFrontMatterIndexed(\n      this.frontMatterWordProvider.wordCount\n    );\n    this.showDebugLog(() =>\n      buildLogMessage(\"Index front matter tokens\", performance.now() - start)\n    );\n  }\n\n  updateFrontMatterTokenIndex(file: TFile): void {\n    const start = performance.now();\n    if (!this.settings.enableFrontMatterComplement) {\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢Skip: Update front matter token index\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    this.frontMatterWordProvider.updateWordIndex(file);\n\n    this.showDebugLog(() =>\n      buildLogMessage(\n        \"Update front matter token index\",\n        performance.now() - start\n      )\n    );\n  }\n\n  updateFrontMatterToken(): void {\n    const start = performance.now();\n    if (!this.settings.enableFrontMatterComplement) {\n      this.showDebugLog(() =>\n        buildLogMessage(\n          \"👢Skip: Update front matter token\",\n          performance.now() - start\n        )\n      );\n      return;\n    }\n\n    this.frontMatterWordProvider.updateWords();\n    this.statusBar.setFrontMatterIndexed(\n      this.frontMatterWordProvider.wordCount\n    );\n\n    this.showDebugLog(() =>\n      buildLogMessage(\"Update front matter token\", performance.now() - start)\n    );\n  }\n\n  onTrigger(\n    cursor: EditorPosition,\n    editor: Editor,\n    file: TFile\n  ): EditorSuggestTriggerInfo | null {\n    const start = performance.now();\n\n    const showDebugLog = (message: string) => {\n      this.showDebugLog(() => `[onTrigger] ${message}`);\n    };\n    const onReturnNull = (message: string) => {\n      showDebugLog(message);\n      this.runManually = false;\n      this.close();\n    };\n\n    if (\n      !this.settings.complementAutomatically &&\n      !this.isOpen &&\n      !this.runManually\n    ) {\n      onReturnNull(\"Don't show suggestions\");\n      return null;\n    }\n\n    if (\n      this.settings.disableSuggestionsDuringImeOn &&\n      this.appHelper.isIMEOn() &&\n      !this.runManually\n    ) {\n      onReturnNull(\"Don't show suggestions for IME\");\n      return null;\n    }\n\n    const cl = this.appHelper.getCurrentLine(editor);\n    if (this.previousCurrentLine === cl && !this.runManually) {\n      this.previousCurrentLine = cl;\n      onReturnNull(\"Don't show suggestions because there are no changes\");\n      return null;\n    }\n    this.previousCurrentLine = cl;\n\n    const currentLineUntilCursor =\n      this.appHelper.getCurrentLineUntilCursor(editor);\n    if (currentLineUntilCursor.startsWith(\"---\")) {\n      onReturnNull(\n        \"Don't show suggestions because it supposes front matter or horizontal line\"\n      );\n      return null;\n    }\n    if (\n      currentLineUntilCursor.startsWith(\"~~~\") ||\n      currentLineUntilCursor.startsWith(\"```\")\n    ) {\n      onReturnNull(\n        \"Don't show suggestions because it supposes front code block\"\n      );\n      return null;\n    }\n\n    const tokens = this.tokenizer.tokenize(currentLineUntilCursor, true);\n    showDebugLog(`tokens is ${tokens}`);\n\n    const tokenized = this.tokenizer.recursiveTokenize(currentLineUntilCursor);\n    const currentTokens = tokenized.slice(\n      tokenized.length > this.settings.maxNumberOfWordsAsPhrase\n        ? tokenized.length - this.settings.maxNumberOfWordsAsPhrase\n        : 0\n    );\n    showDebugLog(`currentTokens is ${JSON.stringify(currentTokens)}`);\n\n    const currentToken = currentTokens[0]?.word;\n    showDebugLog(`currentToken is ${currentToken}`);\n    if (!currentToken) {\n      onReturnNull(`Don't show suggestions because currentToken is empty`);\n      return null;\n    }\n\n    const currentTokenSeparatedWhiteSpace =\n      currentLineUntilCursor.split(\" \").last() ?? \"\";\n    if (\n      new RegExp(`^[${this.settings.firstCharactersDisableSuggestions}]`).test(\n        currentTokenSeparatedWhiteSpace\n      )\n    ) {\n      onReturnNull(\n        `Don't show suggestions for avoiding to conflict with the other commands.`\n      );\n      return null;\n    }\n\n    if (\n      currentToken.length === 1 &&\n      Boolean(currentToken.match(this.tokenizer.getTrimPattern()))\n    ) {\n      onReturnNull(\n        `Don't show suggestions because currentToken is TRIM_PATTERN`\n      );\n      return null;\n    }\n\n    const currentFrontMatter = this.settings.enableFrontMatterComplement\n      ? this.appHelper.getCurrentFrontMatter()\n      : undefined;\n    showDebugLog(`Current front matter is ${currentFrontMatter}`);\n\n    if (\n      !this.runManually &&\n      !currentFrontMatter &&\n      currentToken.length < this.minNumberTriggered\n    ) {\n      onReturnNull(\n        \"Don't show suggestions because currentToken is less than minNumberTriggered option\"\n      );\n      return null;\n    }\n\n    showDebugLog(buildLogMessage(\"onTrigger\", performance.now() - start));\n    this.runManually = false;\n\n    // Hack implementation for Front matter complement\n    if (currentFrontMatter && currentTokens.last()?.word.match(/[^ ] $/)) {\n      currentTokens.push({ word: \"\", offset: currentLineUntilCursor.length });\n    }\n\n    // For multi-word completion\n    this.contextStartCh = cursor.ch - currentToken.length;\n    return {\n      start: {\n        ch: cursor.ch - (currentTokens.last()?.word?.length ?? 0), // For multi-word completion\n        line: cursor.line,\n      },\n      end: cursor,\n      query: JSON.stringify({\n        currentFrontMatter,\n        queries: currentTokens.map((x) => ({\n          ...x,\n          offset: x.offset - currentTokens[0].offset,\n        })),\n      }),\n    };\n  }\n\n  getSuggestions(context: EditorSuggestContext): Word[] | Promise<Word[]> {\n    return new Promise((resolve) => {\n      this.debounceGetSuggestions(context, (words) => {\n        resolve(words);\n      });\n    });\n  }\n\n  renderSuggestion(word: Word, el: HTMLElement): void {\n    const base = createDiv();\n\n    let text = word.value;\n    if (\n      word.type === \"customDictionary\" &&\n      word.insertedText &&\n      this.settings.displayedTextSuffix\n    ) {\n      text += this.settings.displayedTextSuffix;\n    }\n\n    base.createDiv({\n      text,\n      cls:\n        word.type === \"internalLink\" && word.aliasMeta\n          ? \"various-complements__suggestion-item__content__alias\"\n          : undefined,\n    });\n\n    const description = this.descriptionOnSuggestion.toDisplay(word);\n    if (description) {\n      base.createDiv({\n        cls: \"various-complements__suggestion-item__description\",\n        text: `${description}`,\n      });\n    }\n\n    el.appendChild(base);\n\n    el.addClass(\"various-complements__suggestion-item\");\n    switch (word.type) {\n      case \"currentFile\":\n        el.addClass(\"various-complements__suggestion-item__current-file\");\n        break;\n      case \"currentVault\":\n        el.addClass(\"various-complements__suggestion-item__current-vault\");\n        break;\n      case \"customDictionary\":\n        el.addClass(\"various-complements__suggestion-item__custom-dictionary\");\n        break;\n      case \"internalLink\":\n        el.addClass(\"various-complements__suggestion-item__internal-link\");\n        if (word.phantom) {\n          el.addClass(\"various-complements__suggestion-item__phantom\");\n        }\n        break;\n      case \"frontMatter\":\n        el.addClass(\"various-complements__suggestion-item__front-matter\");\n        break;\n    }\n  }\n\n  selectSuggestion(word: Word, evt: MouseEvent | KeyboardEvent): void {\n    if (!this.context) {\n      return;\n    }\n\n    let insertedText = word.value;\n    if (word.type === \"internalLink\") {\n      if (this.settings.suggestInternalLinkWithAlias && word.aliasMeta) {\n        const linkText = this.appHelper.optimizeMarkdownLinkText(\n          word.aliasMeta.origin\n        );\n        insertedText = this.appHelper.useWikiLinks\n          ? `[[${linkText}|${word.value}]]`\n          : `[${word.value}](${linkText}.md)`;\n      } else {\n        const linkText = this.appHelper.optimizeMarkdownLinkText(word.value);\n        insertedText = this.appHelper.useWikiLinks\n          ? `[[${linkText}]]`\n          : `[${linkText}](${linkText}.md)`;\n      }\n    }\n\n    if (\n      word.type === \"frontMatter\" &&\n      this.settings.insertCommaAfterFrontMatterCompletion\n    ) {\n      insertedText = `${insertedText}, `;\n    } else {\n      if (\n        this.settings.insertAfterCompletion &&\n        !(word.type === \"customDictionary\" && word.ignoreSpaceAfterCompletion)\n      ) {\n        insertedText = `${insertedText} `;\n      }\n    }\n\n    let positionToMove = -1;\n\n    if (word.type === \"customDictionary\") {\n      if (word.insertedText) {\n        insertedText = word.insertedText;\n      }\n\n      const caret = word.caretSymbol;\n      if (caret) {\n        positionToMove = insertedText.indexOf(caret);\n        insertedText = insertedText.replace(caret, \"\");\n      }\n    }\n\n    const editor = this.context.editor;\n    editor.replaceRange(\n      insertedText,\n      {\n        ...this.context.start,\n        ch: this.contextStartCh + word.offset!,\n      },\n      this.context.end\n    );\n\n    if (positionToMove !== -1) {\n      editor.setCursor(\n        editor.offsetToPos(\n          editor.posToOffset(editor.getCursor()) -\n            insertedText.length +\n            positionToMove\n        )\n      );\n    }\n\n    // The workaround of strange behavior for that cursor doesn't move after completion only if it doesn't input any word.\n    if (\n      this.appHelper.equalsAsEditorPostion(this.context.start, this.context.end)\n    ) {\n      editor.setCursor(\n        editor.offsetToPos(\n          editor.posToOffset(editor.getCursor()) + insertedText.length\n        )\n      );\n    }\n\n    this.selectionHistoryStorage?.increment(word as HitWord);\n    if (this.settings.showLogAboutPerformanceInConsole) {\n      console.log(\"--- history ---\");\n      console.log(this.selectionHistoryStorage?.data);\n    }\n\n    this.close();\n    this.debounceClose();\n  }\n\n  private showDebugLog(toMessage: () => string) {\n    if (this.settings.showLogAboutPerformanceInConsole) {\n      console.log(toMessage());\n    }\n  }\n}\n","import { App, Notice, PluginSettingTab, Setting } from \"obsidian\";\nimport type VariousComponents from \"../main\";\nimport { TokenizeStrategy } from \"../tokenizer/TokenizeStrategy\";\nimport { MatchStrategy } from \"../provider/MatchStrategy\";\nimport { CycleThroughSuggestionsKeys } from \"../option/CycleThroughSuggestionsKeys\";\nimport { ColumnDelimiter } from \"../option/ColumnDelimiter\";\nimport { SelectSuggestionKey } from \"../option/SelectSuggestionKey\";\nimport { mirrorMap } from \"../util/collection-helper\";\nimport { OpenSourceFileKeys } from \"../option/OpenSourceFileKeys\";\nimport { DescriptionOnSuggestion } from \"../option/DescriptionOnSuggestion\";\nimport { SpecificMatchStrategy } from \"../provider/SpecificMatchStrategy\";\nimport type { SelectionHistoryTree } from \"../storage/SelectionHistoryStorage\";\n\nexport interface Settings {\n  // general\n  strategy: string;\n  matchStrategy: string;\n  maxNumberOfSuggestions: number;\n  maxNumberOfWordsAsPhrase: number;\n  minNumberOfCharactersTriggered: number;\n  minNumberOfWordsTriggeredPhrase: number;\n  complementAutomatically: boolean;\n  delayMilliSeconds: number;\n  disableSuggestionsDuringImeOn: boolean;\n  // FIXME: Rename at next major version up\n  insertAfterCompletion: boolean;\n  firstCharactersDisableSuggestions: string;\n\n  // appearance\n  showMatchStrategy: boolean;\n  showComplementAutomatically: boolean;\n  showIndexingStatus: boolean;\n  descriptionOnSuggestion: string;\n\n  // key customization\n  selectSuggestionKeys: string;\n  additionalCycleThroughSuggestionsKeys: string;\n  disableUpDownKeysForCycleThroughSuggestionsKeys: boolean;\n  openSourceFileKey: string;\n  propagateEsc: boolean;\n\n  // current file complement\n  enableCurrentFileComplement: boolean;\n  currentFileMinNumberOfCharacters: number;\n  onlyComplementEnglishOnCurrentFileComplement: boolean;\n\n  // current vault complement\n  enableCurrentVaultComplement: boolean;\n  currentVaultMinNumberOfCharacters: number;\n  includeCurrentVaultPathPrefixPatterns: string;\n  excludeCurrentVaultPathPrefixPatterns: string;\n  includeCurrentVaultOnlyFilesUnderCurrentDirectory: boolean;\n\n  // custom dictionary complement\n  enableCustomDictionaryComplement: boolean;\n  customDictionaryPaths: string;\n  columnDelimiter: string;\n  customDictionaryWordRegexPattern: string;\n  delimiterToHideSuggestion: string;\n  delimiterToDivideSuggestionsForDisplayFromInsertion: string;\n  caretLocationSymbolAfterComplement: string;\n  displayedTextSuffix: string;\n\n  // internal link complement\n  enableInternalLinkComplement: boolean;\n  suggestInternalLinkWithAlias: boolean;\n  excludeInternalLinkPathPrefixPatterns: string;\n\n  // front matter complement\n  enableFrontMatterComplement: boolean;\n  frontMatterComplementMatchStrategy: string;\n  insertCommaAfterFrontMatterCompletion: boolean;\n\n  // debug\n  showLogAboutPerformanceInConsole: boolean;\n\n  // others\n  selectionHistoryTree: SelectionHistoryTree;\n}\n\nexport const DEFAULT_SETTINGS: Settings = {\n  // general\n  strategy: \"default\",\n  matchStrategy: \"prefix\",\n\n  maxNumberOfSuggestions: 5,\n  maxNumberOfWordsAsPhrase: 3,\n  minNumberOfCharactersTriggered: 0,\n  minNumberOfWordsTriggeredPhrase: 1,\n  complementAutomatically: true,\n  delayMilliSeconds: 0,\n  disableSuggestionsDuringImeOn: false,\n  insertAfterCompletion: true,\n  firstCharactersDisableSuggestions: \":/^\",\n\n  // appearance\n  showMatchStrategy: true,\n  showComplementAutomatically: true,\n  showIndexingStatus: true,\n  descriptionOnSuggestion: \"Short\",\n\n  // key customization\n  selectSuggestionKeys: \"Enter\",\n  additionalCycleThroughSuggestionsKeys: \"None\",\n  disableUpDownKeysForCycleThroughSuggestionsKeys: false,\n  openSourceFileKey: \"None\",\n  propagateEsc: false,\n\n  // current file complement\n  enableCurrentFileComplement: true,\n  currentFileMinNumberOfCharacters: 0,\n  onlyComplementEnglishOnCurrentFileComplement: false,\n\n  // current vault complement\n  enableCurrentVaultComplement: false,\n  currentVaultMinNumberOfCharacters: 0,\n  includeCurrentVaultPathPrefixPatterns: \"\",\n  excludeCurrentVaultPathPrefixPatterns: \"\",\n  includeCurrentVaultOnlyFilesUnderCurrentDirectory: false,\n\n  // custom dictionary complement\n  enableCustomDictionaryComplement: false,\n  customDictionaryPaths: `https://raw.githubusercontent.com/first20hours/google-10000-english/master/google-10000-english-no-swears.txt`,\n  columnDelimiter: \"Tab\",\n  customDictionaryWordRegexPattern: \"\",\n  delimiterToHideSuggestion: \"\",\n  delimiterToDivideSuggestionsForDisplayFromInsertion: \"\",\n  caretLocationSymbolAfterComplement: \"\",\n  displayedTextSuffix: \" => ...\",\n\n  // internal link complement\n  enableInternalLinkComplement: true,\n  suggestInternalLinkWithAlias: false,\n  excludeInternalLinkPathPrefixPatterns: \"\",\n\n  // front matter complement\n  enableFrontMatterComplement: true,\n  frontMatterComplementMatchStrategy: \"inherit\",\n  insertCommaAfterFrontMatterCompletion: false,\n\n  // debug\n  showLogAboutPerformanceInConsole: false,\n\n  // others\n  selectionHistoryTree: {},\n};\n\nexport class VariousComplementsSettingTab extends PluginSettingTab {\n  plugin: VariousComponents;\n\n  constructor(app: App, plugin: VariousComponents) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    let { containerEl } = this;\n\n    containerEl.empty();\n\n    containerEl.createEl(\"h2\", { text: \"Various Complements - Settings\" });\n    this.addMainSettings(containerEl);\n    this.addAppearanceSettings(containerEl);\n    this.addKeyCustomizationSettings(containerEl);\n    this.addCurrentFileComplementSettings(containerEl);\n    this.addCurrentVaultComplementSettings(containerEl);\n    this.addCustomDictionaryComplementSettings(containerEl);\n    this.addInternalLinkComplementSettings(containerEl);\n    this.addFrontMatterComplementSettings(containerEl);\n    this.addDebugSettings(containerEl);\n  }\n\n  private addMainSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", { text: \"Main\" });\n\n    new Setting(containerEl).setName(\"Strategy\").addDropdown((tc) =>\n      tc\n        .addOptions(mirrorMap(TokenizeStrategy.values(), (x) => x.name))\n        .setValue(this.plugin.settings.strategy)\n        .onChange(async (value) => {\n          this.plugin.settings.strategy = value;\n          this.display();\n          await this.plugin.saveSettings({\n            currentFile: true,\n            currentVault: true,\n          });\n        })\n    );\n    if (this.plugin.settings.strategy === TokenizeStrategy.CHINESE.name) {\n      const el = containerEl.createEl(\"div\", {\n        cls: \"various-complements__settings__warning\",\n      });\n      el.createSpan({\n        text: \"⚠ You need to download `cedict_ts.u8` from\",\n      });\n      el.createEl(\"a\", {\n        href: \"https://www.mdbg.net/chinese/dictionary?page=cc-cedict\",\n        text: \" the site \",\n      });\n      el.createSpan({\n        text: \"and store it in vault root.\",\n      });\n    }\n\n    new Setting(containerEl).setName(\"Match strategy\").addDropdown((tc) =>\n      tc\n        .addOptions(mirrorMap(MatchStrategy.values(), (x) => x.name))\n        .setValue(this.plugin.settings.matchStrategy)\n        .onChange(async (value) => {\n          this.plugin.settings.matchStrategy = value;\n          await this.plugin.saveSettings();\n          this.display();\n        })\n    );\n    if (this.plugin.settings.matchStrategy === MatchStrategy.PARTIAL.name) {\n      containerEl.createEl(\"div\", {\n        text: \"⚠ `partial` is more than 10 times slower than `prefix`\",\n        cls: \"various-complements__settings__warning\",\n      });\n    }\n\n    new Setting(containerEl)\n      .setName(\"Max number of suggestions\")\n      .addSlider((sc) =>\n        sc\n          .setLimits(1, 255, 1)\n          .setValue(this.plugin.settings.maxNumberOfSuggestions)\n          .setDynamicTooltip()\n          .onChange(async (value) => {\n            this.plugin.settings.maxNumberOfSuggestions = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Max number of words as a phrase\")\n      .setDesc(`[⚠Warning] It makes slower more than N times (N is set value)`)\n      .addSlider((sc) =>\n        sc\n          .setLimits(1, 10, 1)\n          .setValue(this.plugin.settings.maxNumberOfWordsAsPhrase)\n          .setDynamicTooltip()\n          .onChange(async (value) => {\n            this.plugin.settings.maxNumberOfWordsAsPhrase = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Min number of characters for trigger\")\n      .setDesc(\"It uses a default value of Strategy if set 0.\")\n      .addSlider((sc) =>\n        sc\n          .setLimits(0, 10, 1)\n          .setValue(this.plugin.settings.minNumberOfCharactersTriggered)\n          .setDynamicTooltip()\n          .onChange(async (value) => {\n            this.plugin.settings.minNumberOfCharactersTriggered = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Min number of words for trigger\")\n      .addSlider((sc) =>\n        sc\n          .setLimits(1, 10, 1)\n          .setValue(this.plugin.settings.minNumberOfWordsTriggeredPhrase)\n          .setDynamicTooltip()\n          .onChange(async (value) => {\n            this.plugin.settings.minNumberOfWordsTriggeredPhrase = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Complement automatically\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.complementAutomatically).onChange(\n          async (value) => {\n            this.plugin.settings.complementAutomatically = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n\n    new Setting(containerEl)\n      .setName(\"Delay milli-seconds for trigger\")\n      .addSlider((sc) =>\n        sc\n          .setLimits(0, 1000, 10)\n          .setValue(this.plugin.settings.delayMilliSeconds)\n          .setDynamicTooltip()\n          .onChange(async (value) => {\n            this.plugin.settings.delayMilliSeconds = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Disable suggestions during IME on\")\n      .addToggle((tc) => {\n        tc.setValue(\n          this.plugin.settings.disableSuggestionsDuringImeOn\n        ).onChange(async (value) => {\n          this.plugin.settings.disableSuggestionsDuringImeOn = value;\n          await this.plugin.saveSettings();\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(\"Insert space after completion\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.insertAfterCompletion).onChange(\n          async (value) => {\n            this.plugin.settings.insertAfterCompletion = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n\n    new Setting(containerEl)\n      .setName(\"First characters to disable suggestions\")\n      .addText((cb) => {\n        cb.setValue(\n          this.plugin.settings.firstCharactersDisableSuggestions\n        ).onChange(async (value) => {\n          this.plugin.settings.firstCharactersDisableSuggestions = value;\n          await this.plugin.saveSettings();\n        });\n      });\n  }\n\n  private addAppearanceSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", { text: \"Appearance\" });\n\n    new Setting(containerEl)\n      .setName(\"Show Match strategy\")\n      .setDesc(\n        \"Show Match strategy at the status bar. Changing this option requires a restart to take effect.\"\n      )\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.showMatchStrategy).onChange(\n          async (value) => {\n            this.plugin.settings.showMatchStrategy = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n\n    new Setting(containerEl)\n      .setName(\"Show Complement automatically\")\n      .setDesc(\n        \"Show complement automatically at the status bar. Changing this option requires a restart to take effect.\"\n      )\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.showComplementAutomatically).onChange(\n          async (value) => {\n            this.plugin.settings.showComplementAutomatically = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n\n    new Setting(containerEl)\n      .setName(\"Show Indexing status\")\n      .setDesc(\n        \"Show indexing status at the status bar. Changing this option requires a restart to take effect.\"\n      )\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.showIndexingStatus).onChange(\n          async (value) => {\n            this.plugin.settings.showIndexingStatus = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n\n    new Setting(containerEl)\n      .setName(\"Description on a suggestion\")\n      .addDropdown((tc) =>\n        tc\n          .addOptions(\n            mirrorMap(DescriptionOnSuggestion.values(), (x) => x.name)\n          )\n          .setValue(this.plugin.settings.descriptionOnSuggestion)\n          .onChange(async (value) => {\n            this.plugin.settings.descriptionOnSuggestion = value;\n            await this.plugin.saveSettings();\n          })\n      );\n  }\n\n  private addKeyCustomizationSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", { text: \"Key customization\" });\n\n    new Setting(containerEl)\n      .setName(\"Select a suggestion key\")\n      .addDropdown((tc) =>\n        tc\n          .addOptions(mirrorMap(SelectSuggestionKey.values(), (x) => x.name))\n          .setValue(this.plugin.settings.selectSuggestionKeys)\n          .onChange(async (value) => {\n            this.plugin.settings.selectSuggestionKeys = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Additional cycle through suggestions keys\")\n      .addDropdown((tc) =>\n        tc\n          .addOptions(\n            mirrorMap(CycleThroughSuggestionsKeys.values(), (x) => x.name)\n          )\n          .setValue(this.plugin.settings.additionalCycleThroughSuggestionsKeys)\n          .onChange(async (value) => {\n            this.plugin.settings.additionalCycleThroughSuggestionsKeys = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    new Setting(containerEl)\n      .setName(\"Disable the up/down keys for cycle through suggestions keys\")\n      .addToggle((tc) => {\n        tc.setValue(\n          this.plugin.settings.disableUpDownKeysForCycleThroughSuggestionsKeys\n        ).onChange(async (value) => {\n          this.plugin.settings.disableUpDownKeysForCycleThroughSuggestionsKeys =\n            value;\n          await this.plugin.saveSettings();\n        });\n      });\n\n    new Setting(containerEl).setName(\"Open source file key\").addDropdown((tc) =>\n      tc\n        .addOptions(mirrorMap(OpenSourceFileKeys.values(), (x) => x.name))\n        .setValue(this.plugin.settings.openSourceFileKey)\n        .onChange(async (value) => {\n          this.plugin.settings.openSourceFileKey = value;\n          await this.plugin.saveSettings();\n        })\n    );\n\n    new Setting(containerEl)\n      .setName(\"Propagate ESC\")\n      .setDesc(\n        \"It is handy if you use Vim mode because you can switch to Normal mode by one ESC, whether it shows suggestions or not.\"\n      )\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.propagateEsc).onChange(\n          async (value) => {\n            this.plugin.settings.propagateEsc = value;\n            await this.plugin.saveSettings();\n          }\n        );\n      });\n  }\n\n  private addCurrentFileComplementSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", {\n      text: \"Current file complement\",\n      cls: \"various-complements__settings__header various-complements__settings__header__current-file\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable Current file complement\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.enableCurrentFileComplement).onChange(\n          async (value) => {\n            this.plugin.settings.enableCurrentFileComplement = value;\n            await this.plugin.saveSettings({ currentFile: true });\n            this.display();\n          }\n        );\n      });\n\n    if (this.plugin.settings.enableCurrentFileComplement) {\n      new Setting(containerEl)\n        .setName(\"Min number of characters for indexing\")\n        .setDesc(\"It uses a default value of Strategy if set 0.\")\n        .addSlider((sc) =>\n          sc\n            .setLimits(0, 15, 1)\n            .setValue(this.plugin.settings.currentFileMinNumberOfCharacters)\n            .setDynamicTooltip()\n            .onChange(async (value) => {\n              this.plugin.settings.currentFileMinNumberOfCharacters = value;\n              await this.plugin.saveSettings({ currentFile: true });\n            })\n        );\n\n      new Setting(containerEl)\n        .setName(\"Only complement English on current file complement\")\n        .addToggle((tc) => {\n          tc.setValue(\n            this.plugin.settings.onlyComplementEnglishOnCurrentFileComplement\n          ).onChange(async (value) => {\n            this.plugin.settings.onlyComplementEnglishOnCurrentFileComplement =\n              value;\n            await this.plugin.saveSettings({ currentFile: true });\n          });\n        });\n    }\n  }\n\n  private addCurrentVaultComplementSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", {\n      text: \"Current vault complement\",\n      cls: \"various-complements__settings__header various-complements__settings__header__current-vault\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable Current vault complement\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.enableCurrentVaultComplement).onChange(\n          async (value) => {\n            this.plugin.settings.enableCurrentVaultComplement = value;\n            this.display();\n            await this.plugin.saveSettings({ currentVault: true });\n          }\n        );\n      });\n\n    if (this.plugin.settings.enableCurrentVaultComplement) {\n      new Setting(containerEl)\n        .setName(\"Min number of characters for indexing\")\n        .setDesc(\"It uses a default value of Strategy if set 0.\")\n        .addSlider((sc) =>\n          sc\n            .setLimits(0, 15, 1)\n            .setValue(this.plugin.settings.currentVaultMinNumberOfCharacters)\n            .setDynamicTooltip()\n            .onChange(async (value) => {\n              this.plugin.settings.currentVaultMinNumberOfCharacters = value;\n              await this.plugin.saveSettings();\n            })\n        );\n\n      new Setting(containerEl)\n        .setName(\"Include prefix path patterns\")\n        .setDesc(\"Prefix match path patterns to include files.\")\n        .addTextArea((tac) => {\n          const el = tac\n            .setValue(\n              this.plugin.settings.includeCurrentVaultPathPrefixPatterns\n            )\n            .setPlaceholder(\"Private/\")\n            .onChange(async (value) => {\n              this.plugin.settings.includeCurrentVaultPathPrefixPatterns =\n                value;\n              await this.plugin.saveSettings();\n            });\n          el.inputEl.className =\n            \"various-complements__settings__text-area-path\";\n          return el;\n        });\n      new Setting(containerEl)\n        .setName(\"Exclude prefix path patterns\")\n        .setDesc(\"Prefix match path patterns to exclude files.\")\n        .addTextArea((tac) => {\n          const el = tac\n            .setValue(\n              this.plugin.settings.excludeCurrentVaultPathPrefixPatterns\n            )\n            .setPlaceholder(\"Private/\")\n            .onChange(async (value) => {\n              this.plugin.settings.excludeCurrentVaultPathPrefixPatterns =\n                value;\n              await this.plugin.saveSettings();\n            });\n          el.inputEl.className =\n            \"various-complements__settings__text-area-path\";\n          return el;\n        });\n      new Setting(containerEl)\n        .setName(\"Include only files under current directory\")\n        .addToggle((tc) => {\n          tc.setValue(\n            this.plugin.settings\n              .includeCurrentVaultOnlyFilesUnderCurrentDirectory\n          ).onChange(async (value) => {\n            this.plugin.settings.includeCurrentVaultOnlyFilesUnderCurrentDirectory =\n              value;\n            await this.plugin.saveSettings();\n          });\n        });\n    }\n  }\n\n  private addCustomDictionaryComplementSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", {\n      text: \"Custom dictionary complement\",\n      cls: \"various-complements__settings__header various-complements__settings__header__custom-dictionary\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable Custom dictionary complement\")\n      .addToggle((tc) => {\n        tc.setValue(\n          this.plugin.settings.enableCustomDictionaryComplement\n        ).onChange(async (value) => {\n          this.plugin.settings.enableCustomDictionaryComplement = value;\n          await this.plugin.saveSettings({ customDictionary: true });\n          this.display();\n        });\n      });\n\n    if (this.plugin.settings.enableCustomDictionaryComplement) {\n      new Setting(containerEl)\n        .setName(\"Custom dictionary paths\")\n        .setDesc(\n          \"Specify either a relative path from Vault root or URL for each line.\"\n        )\n        .addTextArea((tac) => {\n          const el = tac\n            .setValue(this.plugin.settings.customDictionaryPaths)\n            .setPlaceholder(\"dictionary.md\")\n            .onChange(async (value) => {\n              this.plugin.settings.customDictionaryPaths = value;\n              await this.plugin.saveSettings();\n            });\n          el.inputEl.className =\n            \"various-complements__settings__text-area-path\";\n          return el;\n        });\n\n      new Setting(containerEl).setName(\"Column delimiter\").addDropdown((tc) =>\n        tc\n          .addOptions(mirrorMap(ColumnDelimiter.values(), (x) => x.name))\n          .setValue(this.plugin.settings.columnDelimiter)\n          .onChange(async (value) => {\n            this.plugin.settings.columnDelimiter = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n      new Setting(containerEl)\n        .setName(\"Word regex pattern\")\n        .setDesc(\"Only load words that match the regular expression pattern.\")\n        .addText((cb) => {\n          cb.setValue(\n            this.plugin.settings.customDictionaryWordRegexPattern\n          ).onChange(async (value) => {\n            this.plugin.settings.customDictionaryWordRegexPattern = value;\n            await this.plugin.saveSettings();\n          });\n        });\n\n      new Setting(containerEl)\n        .setName(\"Delimiter to hide a suggestion\")\n        .setDesc(\n          \"If set ';;;', 'abcd;;;efg' is shown as 'abcd' on suggestions, but completes to 'abcdefg'.\"\n        )\n        .addText((cb) => {\n          cb.setValue(this.plugin.settings.delimiterToHideSuggestion).onChange(\n            async (value) => {\n              this.plugin.settings.delimiterToHideSuggestion = value;\n              await this.plugin.saveSettings();\n            }\n          );\n        });\n\n      new Setting(containerEl)\n        .setName(\n          \"Delimiter to divide suggestions for display from ones for insertion\"\n        )\n        .setDesc(\n          \"If set ' >>> ', 'displayed >>> inserted' is shown as 'displayed' on suggestions, but completes to 'inserted'.\"\n        )\n        .addText((cb) => {\n          cb.setValue(\n            this.plugin.settings\n              .delimiterToDivideSuggestionsForDisplayFromInsertion\n          ).onChange(async (value) => {\n            this.plugin.settings.delimiterToDivideSuggestionsForDisplayFromInsertion =\n              value;\n            await this.plugin.saveSettings();\n          });\n        });\n\n      new Setting(containerEl)\n        .setName(\"Caret location symbol after complement\")\n        .setDesc(\n          \"If set '<CARET>' and there is '<li><CARET></li>' in custom dictionary, it complements '<li></li>' and move a caret where between '<li>' and `</li>`.\"\n        )\n        .addText((cb) => {\n          cb.setValue(\n            this.plugin.settings.caretLocationSymbolAfterComplement\n          ).onChange(async (value) => {\n            this.plugin.settings.caretLocationSymbolAfterComplement = value;\n            await this.plugin.saveSettings();\n          });\n        });\n\n      new Setting(containerEl)\n        .setName(\"Displayed text suffix\")\n        .setDesc(\n          \"It shows as a suffix of displayed text if there is a difference between displayed and inserted\"\n        )\n        .addText((cb) => {\n          cb.setValue(this.plugin.settings.displayedTextSuffix).onChange(\n            async (value) => {\n              this.plugin.settings.displayedTextSuffix = value;\n              await this.plugin.saveSettings();\n            }\n          );\n        });\n    }\n  }\n\n  private addInternalLinkComplementSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", {\n      text: \"Internal link complement\",\n      cls: \"various-complements__settings__header various-complements__settings__header__internal-link\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable Internal link complement\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.enableInternalLinkComplement).onChange(\n          async (value) => {\n            this.plugin.settings.enableInternalLinkComplement = value;\n            await this.plugin.saveSettings({ internalLink: true });\n            this.display();\n          }\n        );\n      });\n\n    if (this.plugin.settings.enableInternalLinkComplement) {\n      new Setting(containerEl)\n        .setName(\"Suggest with an alias\")\n        .addToggle((tc) => {\n          tc.setValue(\n            this.plugin.settings.suggestInternalLinkWithAlias\n          ).onChange(async (value) => {\n            this.plugin.settings.suggestInternalLinkWithAlias = value;\n            await this.plugin.saveSettings({ internalLink: true });\n          });\n        });\n      new Setting(containerEl)\n        .setName(\"Exclude prefix path patterns\")\n        .setDesc(\"Prefix match path patterns to exclude files.\")\n        .addTextArea((tac) => {\n          const el = tac\n            .setValue(\n              this.plugin.settings.excludeInternalLinkPathPrefixPatterns\n            )\n            .setPlaceholder(\"Private/\")\n            .onChange(async (value) => {\n              this.plugin.settings.excludeInternalLinkPathPrefixPatterns =\n                value;\n              await this.plugin.saveSettings();\n            });\n          el.inputEl.className =\n            \"various-complements__settings__text-area-path\";\n          return el;\n        });\n    }\n  }\n\n  private addFrontMatterComplementSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", {\n      text: \"Front matter complement\",\n      cls: \"various-complements__settings__header various-complements__settings__header__front-matter\",\n    });\n\n    new Setting(containerEl)\n      .setName(\"Enable Front matter complement\")\n      .addToggle((tc) => {\n        tc.setValue(this.plugin.settings.enableFrontMatterComplement).onChange(\n          async (value) => {\n            this.plugin.settings.enableFrontMatterComplement = value;\n            await this.plugin.saveSettings({ frontMatter: true });\n            this.display();\n          }\n        );\n      });\n\n    if (this.plugin.settings.enableFrontMatterComplement) {\n      new Setting(containerEl)\n        .setName(\"Match strategy in the front matter\")\n        .addDropdown((tc) =>\n          tc\n            .addOptions(\n              mirrorMap(SpecificMatchStrategy.values(), (x) => x.name)\n            )\n            .setValue(this.plugin.settings.frontMatterComplementMatchStrategy)\n            .onChange(async (value) => {\n              this.plugin.settings.frontMatterComplementMatchStrategy = value;\n              await this.plugin.saveSettings();\n            })\n        );\n\n      new Setting(containerEl)\n        .setName(\"Insert comma after completion\")\n        .addToggle((tc) => {\n          tc.setValue(\n            this.plugin.settings.insertCommaAfterFrontMatterCompletion\n          ).onChange(async (value) => {\n            this.plugin.settings.insertCommaAfterFrontMatterCompletion = value;\n            await this.plugin.saveSettings();\n          });\n        });\n    }\n  }\n\n  private addDebugSettings(containerEl: HTMLElement) {\n    containerEl.createEl(\"h3\", { text: \"Debug\" });\n\n    new Setting(containerEl)\n      .setName(\"Show log about performance in a console\")\n      .addToggle((tc) => {\n        tc.setValue(\n          this.plugin.settings.showLogAboutPerformanceInConsole\n        ).onChange(async (value) => {\n          this.plugin.settings.showLogAboutPerformanceInConsole = value;\n          await this.plugin.saveSettings();\n        });\n      });\n  }\n\n  async toggleMatchStrategy() {\n    switch (this.plugin.settings.matchStrategy) {\n      case \"prefix\":\n        this.plugin.settings.matchStrategy = \"partial\";\n        break;\n      case \"partial\":\n        this.plugin.settings.matchStrategy = \"prefix\";\n        break;\n      default:\n        // noinspection ObjectAllocationIgnored\n        new Notice(\"⚠Unexpected error\");\n    }\n    await this.plugin.saveSettings();\n  }\n\n  async toggleComplementAutomatically() {\n    this.plugin.settings.complementAutomatically =\n      !this.plugin.settings.complementAutomatically;\n    await this.plugin.saveSettings();\n  }\n\n  async ensureCustomDictionaryPath(\n    path: string,\n    state: \"present\" | \"absent\"\n  ): Promise<boolean> {\n    const paths = this.plugin.settings.customDictionaryPaths.split(\"\\n\");\n    const exists = paths.some((x) => x === path);\n    if ((exists && state === \"present\") || (!exists && state === \"absent\")) {\n      return false;\n    }\n\n    const newPaths =\n      state === \"present\" ? [...paths, path] : paths.filter((x) => x !== path);\n    this.plugin.settings.customDictionaryPaths = newPaths.join(\"\\n\");\n    await this.plugin.saveSettings({ customDictionary: true });\n\n    return true;\n  }\n\n  getPluginSettingsAsJsonString(): string {\n    return JSON.stringify(\n      {\n        version: this.plugin.manifest.version,\n        mobile: (this.app as any).isMobile,\n        settings: { ...this.plugin.settings, selectionHistoryTree: null },\n      },\n      null,\n      4\n    );\n  }\n}\n","import type { MatchStrategy } from \"../provider/MatchStrategy\";\n\nexport class ProviderStatusBar {\n  constructor(\n    public currentFile: HTMLElement | null,\n    public currentVault: HTMLElement | null,\n    public customDictionary: HTMLElement | null,\n    public internalLink: HTMLElement | null,\n    public frontMatter: HTMLElement | null,\n    public matchStrategy: HTMLElement | null,\n    public complementAutomatically: HTMLElement | null\n  ) {}\n\n  static new(\n    statusBar: HTMLElement,\n    showMatchStrategy: boolean,\n    showIndexingStatus: boolean,\n    showComplementAutomatically: boolean\n  ): ProviderStatusBar {\n    const currentFile = showIndexingStatus\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__current-file\",\n        })\n      : null;\n    const currentVault = showIndexingStatus\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__current-vault\",\n        })\n      : null;\n    const customDictionary = showIndexingStatus\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__custom-dictionary\",\n        })\n      : null;\n    const internalLink = showIndexingStatus\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__internal-link\",\n        })\n      : null;\n    const frontMatter = showIndexingStatus\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__front-matter\",\n        })\n      : null;\n\n    const matchStrategy = showMatchStrategy\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__match-strategy\",\n        })\n      : null;\n\n    const complementAutomatically = showComplementAutomatically\n      ? statusBar.createEl(\"span\", {\n          text: \"---\",\n          cls: \"various-complements__footer various-complements__footer__complement-automatically\",\n        })\n      : null;\n\n    return new ProviderStatusBar(\n      currentFile,\n      currentVault,\n      customDictionary,\n      internalLink,\n      frontMatter,\n      matchStrategy,\n      complementAutomatically\n    );\n  }\n\n  setOnClickStrategyListener(listener: () => void) {\n    this.matchStrategy?.addEventListener(\"click\", listener);\n  }\n  setOnClickComplementAutomatically(listener: () => void) {\n    this.complementAutomatically?.addEventListener(\"click\", listener);\n  }\n\n  setCurrentFileDisabled() {\n    this.currentFile?.setText(\"---\");\n  }\n  setCurrentVaultDisabled() {\n    this.currentVault?.setText(\"---\");\n  }\n  setCustomDictionaryDisabled() {\n    this.customDictionary?.setText(\"---\");\n  }\n  setInternalLinkDisabled() {\n    this.internalLink?.setText(\"---\");\n  }\n  setFrontMatterDisabled() {\n    this.frontMatter?.setText(\"---\");\n  }\n\n  setCurrentFileIndexing() {\n    this.currentFile?.setText(\"indexing...\");\n  }\n  setCurrentVaultIndexing() {\n    this.currentVault?.setText(\"indexing...\");\n  }\n  setCustomDictionaryIndexing() {\n    this.customDictionary?.setText(\"indexing...\");\n  }\n  setInternalLinkIndexing() {\n    this.internalLink?.setText(\"indexing...\");\n  }\n  setFrontMatterIndexing() {\n    this.frontMatter?.setText(\"indexing...\");\n  }\n\n  setCurrentFileIndexed(count: any) {\n    this.currentFile?.setText(String(count));\n  }\n  setCurrentVaultIndexed(count: any) {\n    this.currentVault?.setText(String(count));\n  }\n  setCustomDictionaryIndexed(count: any) {\n    this.customDictionary?.setText(String(count));\n  }\n  setInternalLinkIndexed(count: any) {\n    this.internalLink?.setText(String(count));\n  }\n  setFrontMatterIndexed(count: any) {\n    this.frontMatter?.setText(String(count));\n  }\n\n  setMatchStrategy(strategy: MatchStrategy) {\n    this.matchStrategy?.setText(strategy.name);\n  }\n  setComplementAutomatically(automatically: boolean) {\n    this.complementAutomatically?.setText(automatically ? \"auto\" : \"manual\");\n  }\n}\n","function noop() { }\nconst identity = x => x;\nfunction assign(tar, src) {\n    // @ts-ignore\n    for (const k in src)\n        tar[k] = src[k];\n    return tar;\n}\nfunction is_promise(value) {\n    return value && typeof value === 'object' && typeof value.then === 'function';\n}\nfunction add_location(element, file, line, column, char) {\n    element.__svelte_meta = {\n        loc: { file, line, column, char }\n    };\n}\nfunction run(fn) {\n    return fn();\n}\nfunction blank_object() {\n    return Object.create(null);\n}\nfunction run_all(fns) {\n    fns.forEach(run);\n}\nfunction is_function(thing) {\n    return typeof thing === 'function';\n}\nfunction safe_not_equal(a, b) {\n    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');\n}\nlet src_url_equal_anchor;\nfunction src_url_equal(element_src, url) {\n    if (!src_url_equal_anchor) {\n        src_url_equal_anchor = document.createElement('a');\n    }\n    src_url_equal_anchor.href = url;\n    return element_src === src_url_equal_anchor.href;\n}\nfunction not_equal(a, b) {\n    return a != a ? b == b : a !== b;\n}\nfunction is_empty(obj) {\n    return Object.keys(obj).length === 0;\n}\nfunction validate_store(store, name) {\n    if (store != null && typeof store.subscribe !== 'function') {\n        throw new Error(`'${name}' is not a store with a 'subscribe' method`);\n    }\n}\nfunction subscribe(store, ...callbacks) {\n    if (store == null) {\n        return noop;\n    }\n    const unsub = store.subscribe(...callbacks);\n    return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;\n}\nfunction get_store_value(store) {\n    let value;\n    subscribe(store, _ => value = _)();\n    return value;\n}\nfunction component_subscribe(component, store, callback) {\n    component.$$.on_destroy.push(subscribe(store, callback));\n}\nfunction create_slot(definition, ctx, $$scope, fn) {\n    if (definition) {\n        const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);\n        return definition[0](slot_ctx);\n    }\n}\nfunction get_slot_context(definition, ctx, $$scope, fn) {\n    return definition[1] && fn\n        ? assign($$scope.ctx.slice(), definition[1](fn(ctx)))\n        : $$scope.ctx;\n}\nfunction get_slot_changes(definition, $$scope, dirty, fn) {\n    if (definition[2] && fn) {\n        const lets = definition[2](fn(dirty));\n        if ($$scope.dirty === undefined) {\n            return lets;\n        }\n        if (typeof lets === 'object') {\n            const merged = [];\n            const len = Math.max($$scope.dirty.length, lets.length);\n            for (let i = 0; i < len; i += 1) {\n                merged[i] = $$scope.dirty[i] | lets[i];\n            }\n            return merged;\n        }\n        return $$scope.dirty | lets;\n    }\n    return $$scope.dirty;\n}\nfunction update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {\n    if (slot_changes) {\n        const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);\n        slot.p(slot_context, slot_changes);\n    }\n}\nfunction update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {\n    const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);\n    update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn);\n}\nfunction get_all_dirty_from_scope($$scope) {\n    if ($$scope.ctx.length > 32) {\n        const dirty = [];\n        const length = $$scope.ctx.length / 32;\n        for (let i = 0; i < length; i++) {\n            dirty[i] = -1;\n        }\n        return dirty;\n    }\n    return -1;\n}\nfunction exclude_internal_props(props) {\n    const result = {};\n    for (const k in props)\n        if (k[0] !== '$')\n            result[k] = props[k];\n    return result;\n}\nfunction compute_rest_props(props, keys) {\n    const rest = {};\n    keys = new Set(keys);\n    for (const k in props)\n        if (!keys.has(k) && k[0] !== '$')\n            rest[k] = props[k];\n    return rest;\n}\nfunction compute_slots(slots) {\n    const result = {};\n    for (const key in slots) {\n        result[key] = true;\n    }\n    return result;\n}\nfunction once(fn) {\n    let ran = false;\n    return function (...args) {\n        if (ran)\n            return;\n        ran = true;\n        fn.call(this, ...args);\n    };\n}\nfunction null_to_empty(value) {\n    return value == null ? '' : value;\n}\nfunction set_store_value(store, ret, value) {\n    store.set(value);\n    return ret;\n}\nconst has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);\nfunction action_destroyer(action_result) {\n    return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;\n}\n\nconst is_client = typeof window !== 'undefined';\nlet now = is_client\n    ? () => window.performance.now()\n    : () => Date.now();\nlet raf = is_client ? cb => requestAnimationFrame(cb) : noop;\n// used internally for testing\nfunction set_now(fn) {\n    now = fn;\n}\nfunction set_raf(fn) {\n    raf = fn;\n}\n\nconst tasks = new Set();\nfunction run_tasks(now) {\n    tasks.forEach(task => {\n        if (!task.c(now)) {\n            tasks.delete(task);\n            task.f();\n        }\n    });\n    if (tasks.size !== 0)\n        raf(run_tasks);\n}\n/**\n * For testing purposes only!\n */\nfunction clear_loops() {\n    tasks.clear();\n}\n/**\n * Creates a new task that runs on each raf frame\n * until it returns a falsy value or is aborted\n */\nfunction loop(callback) {\n    let task;\n    if (tasks.size === 0)\n        raf(run_tasks);\n    return {\n        promise: new Promise(fulfill => {\n            tasks.add(task = { c: callback, f: fulfill });\n        }),\n        abort() {\n            tasks.delete(task);\n        }\n    };\n}\n\n// Track which nodes are claimed during hydration. Unclaimed nodes can then be removed from the DOM\n// at the end of hydration without touching the remaining nodes.\nlet is_hydrating = false;\nfunction start_hydrating() {\n    is_hydrating = true;\n}\nfunction end_hydrating() {\n    is_hydrating = false;\n}\nfunction upper_bound(low, high, key, value) {\n    // Return first index of value larger than input value in the range [low, high)\n    while (low < high) {\n        const mid = low + ((high - low) >> 1);\n        if (key(mid) <= value) {\n            low = mid + 1;\n        }\n        else {\n            high = mid;\n        }\n    }\n    return low;\n}\nfunction init_hydrate(target) {\n    if (target.hydrate_init)\n        return;\n    target.hydrate_init = true;\n    // We know that all children have claim_order values since the unclaimed have been detached if target is not <head>\n    let children = target.childNodes;\n    // If target is <head>, there may be children without claim_order\n    if (target.nodeName === 'HEAD') {\n        const myChildren = [];\n        for (let i = 0; i < children.length; i++) {\n            const node = children[i];\n            if (node.claim_order !== undefined) {\n                myChildren.push(node);\n            }\n        }\n        children = myChildren;\n    }\n    /*\n    * Reorder claimed children optimally.\n    * We can reorder claimed children optimally by finding the longest subsequence of\n    * nodes that are already claimed in order and only moving the rest. The longest\n    * subsequence subsequence of nodes that are claimed in order can be found by\n    * computing the longest increasing subsequence of .claim_order values.\n    *\n    * This algorithm is optimal in generating the least amount of reorder operations\n    * possible.\n    *\n    * Proof:\n    * We know that, given a set of reordering operations, the nodes that do not move\n    * always form an increasing subsequence, since they do not move among each other\n    * meaning that they must be already ordered among each other. Thus, the maximal\n    * set of nodes that do not move form a longest increasing subsequence.\n    */\n    // Compute longest increasing subsequence\n    // m: subsequence length j => index k of smallest value that ends an increasing subsequence of length j\n    const m = new Int32Array(children.length + 1);\n    // Predecessor indices + 1\n    const p = new Int32Array(children.length);\n    m[0] = -1;\n    let longest = 0;\n    for (let i = 0; i < children.length; i++) {\n        const current = children[i].claim_order;\n        // Find the largest subsequence length such that it ends in a value less than our current value\n        // upper_bound returns first greater value, so we subtract one\n        // with fast path for when we are on the current longest subsequence\n        const seqLen = ((longest > 0 && children[m[longest]].claim_order <= current) ? longest + 1 : upper_bound(1, longest, idx => children[m[idx]].claim_order, current)) - 1;\n        p[i] = m[seqLen] + 1;\n        const newLen = seqLen + 1;\n        // We can guarantee that current is the smallest value. Otherwise, we would have generated a longer sequence.\n        m[newLen] = i;\n        longest = Math.max(newLen, longest);\n    }\n    // The longest increasing subsequence of nodes (initially reversed)\n    const lis = [];\n    // The rest of the nodes, nodes that will be moved\n    const toMove = [];\n    let last = children.length - 1;\n    for (let cur = m[longest] + 1; cur != 0; cur = p[cur - 1]) {\n        lis.push(children[cur - 1]);\n        for (; last >= cur; last--) {\n            toMove.push(children[last]);\n        }\n        last--;\n    }\n    for (; last >= 0; last--) {\n        toMove.push(children[last]);\n    }\n    lis.reverse();\n    // We sort the nodes being moved to guarantee that their insertion order matches the claim order\n    toMove.sort((a, b) => a.claim_order - b.claim_order);\n    // Finally, we move the nodes\n    for (let i = 0, j = 0; i < toMove.length; i++) {\n        while (j < lis.length && toMove[i].claim_order >= lis[j].claim_order) {\n            j++;\n        }\n        const anchor = j < lis.length ? lis[j] : null;\n        target.insertBefore(toMove[i], anchor);\n    }\n}\nfunction append(target, node) {\n    target.appendChild(node);\n}\nfunction append_styles(target, style_sheet_id, styles) {\n    const append_styles_to = get_root_for_style(target);\n    if (!append_styles_to.getElementById(style_sheet_id)) {\n        const style = element('style');\n        style.id = style_sheet_id;\n        style.textContent = styles;\n        append_stylesheet(append_styles_to, style);\n    }\n}\nfunction get_root_for_style(node) {\n    if (!node)\n        return document;\n    const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;\n    if (root && root.host) {\n        return root;\n    }\n    return node.ownerDocument;\n}\nfunction append_empty_stylesheet(node) {\n    const style_element = element('style');\n    append_stylesheet(get_root_for_style(node), style_element);\n    return style_element.sheet;\n}\nfunction append_stylesheet(node, style) {\n    append(node.head || node, style);\n}\nfunction append_hydration(target, node) {\n    if (is_hydrating) {\n        init_hydrate(target);\n        if ((target.actual_end_child === undefined) || ((target.actual_end_child !== null) && (target.actual_end_child.parentElement !== target))) {\n            target.actual_end_child = target.firstChild;\n        }\n        // Skip nodes of undefined ordering\n        while ((target.actual_end_child !== null) && (target.actual_end_child.claim_order === undefined)) {\n            target.actual_end_child = target.actual_end_child.nextSibling;\n        }\n        if (node !== target.actual_end_child) {\n            // We only insert if the ordering of this node should be modified or the parent node is not target\n            if (node.claim_order !== undefined || node.parentNode !== target) {\n                target.insertBefore(node, target.actual_end_child);\n            }\n        }\n        else {\n            target.actual_end_child = node.nextSibling;\n        }\n    }\n    else if (node.parentNode !== target || node.nextSibling !== null) {\n        target.appendChild(node);\n    }\n}\nfunction insert(target, node, anchor) {\n    target.insertBefore(node, anchor || null);\n}\nfunction insert_hydration(target, node, anchor) {\n    if (is_hydrating && !anchor) {\n        append_hydration(target, node);\n    }\n    else if (node.parentNode !== target || node.nextSibling != anchor) {\n        target.insertBefore(node, anchor || null);\n    }\n}\nfunction detach(node) {\n    node.parentNode.removeChild(node);\n}\nfunction destroy_each(iterations, detaching) {\n    for (let i = 0; i < iterations.length; i += 1) {\n        if (iterations[i])\n            iterations[i].d(detaching);\n    }\n}\nfunction element(name) {\n    return document.createElement(name);\n}\nfunction element_is(name, is) {\n    return document.createElement(name, { is });\n}\nfunction object_without_properties(obj, exclude) {\n    const target = {};\n    for (const k in obj) {\n        if (has_prop(obj, k)\n            // @ts-ignore\n            && exclude.indexOf(k) === -1) {\n            // @ts-ignore\n            target[k] = obj[k];\n        }\n    }\n    return target;\n}\nfunction svg_element(name) {\n    return document.createElementNS('http://www.w3.org/2000/svg', name);\n}\nfunction text(data) {\n    return document.createTextNode(data);\n}\nfunction space() {\n    return text(' ');\n}\nfunction empty() {\n    return text('');\n}\nfunction listen(node, event, handler, options) {\n    node.addEventListener(event, handler, options);\n    return () => node.removeEventListener(event, handler, options);\n}\nfunction prevent_default(fn) {\n    return function (event) {\n        event.preventDefault();\n        // @ts-ignore\n        return fn.call(this, event);\n    };\n}\nfunction stop_propagation(fn) {\n    return function (event) {\n        event.stopPropagation();\n        // @ts-ignore\n        return fn.call(this, event);\n    };\n}\nfunction self(fn) {\n    return function (event) {\n        // @ts-ignore\n        if (event.target === this)\n            fn.call(this, event);\n    };\n}\nfunction trusted(fn) {\n    return function (event) {\n        // @ts-ignore\n        if (event.isTrusted)\n            fn.call(this, event);\n    };\n}\nfunction attr(node, attribute, value) {\n    if (value == null)\n        node.removeAttribute(attribute);\n    else if (node.getAttribute(attribute) !== value)\n        node.setAttribute(attribute, value);\n}\nfunction set_attributes(node, attributes) {\n    // @ts-ignore\n    const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);\n    for (const key in attributes) {\n        if (attributes[key] == null) {\n            node.removeAttribute(key);\n        }\n        else if (key === 'style') {\n            node.style.cssText = attributes[key];\n        }\n        else if (key === '__value') {\n            node.value = node[key] = attributes[key];\n        }\n        else if (descriptors[key] && descriptors[key].set) {\n            node[key] = attributes[key];\n        }\n        else {\n            attr(node, key, attributes[key]);\n        }\n    }\n}\nfunction set_svg_attributes(node, attributes) {\n    for (const key in attributes) {\n        attr(node, key, attributes[key]);\n    }\n}\nfunction set_custom_element_data(node, prop, value) {\n    if (prop in node) {\n        node[prop] = typeof node[prop] === 'boolean' && value === '' ? true : value;\n    }\n    else {\n        attr(node, prop, value);\n    }\n}\nfunction xlink_attr(node, attribute, value) {\n    node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);\n}\nfunction get_binding_group_value(group, __value, checked) {\n    const value = new Set();\n    for (let i = 0; i < group.length; i += 1) {\n        if (group[i].checked)\n            value.add(group[i].__value);\n    }\n    if (!checked) {\n        value.delete(__value);\n    }\n    return Array.from(value);\n}\nfunction to_number(value) {\n    return value === '' ? null : +value;\n}\nfunction time_ranges_to_array(ranges) {\n    const array = [];\n    for (let i = 0; i < ranges.length; i += 1) {\n        array.push({ start: ranges.start(i), end: ranges.end(i) });\n    }\n    return array;\n}\nfunction children(element) {\n    return Array.from(element.childNodes);\n}\nfunction init_claim_info(nodes) {\n    if (nodes.claim_info === undefined) {\n        nodes.claim_info = { last_index: 0, total_claimed: 0 };\n    }\n}\nfunction claim_node(nodes, predicate, processNode, createNode, dontUpdateLastIndex = false) {\n    // Try to find nodes in an order such that we lengthen the longest increasing subsequence\n    init_claim_info(nodes);\n    const resultNode = (() => {\n        // We first try to find an element after the previous one\n        for (let i = nodes.claim_info.last_index; i < nodes.length; i++) {\n            const node = nodes[i];\n            if (predicate(node)) {\n                const replacement = processNode(node);\n                if (replacement === undefined) {\n                    nodes.splice(i, 1);\n                }\n                else {\n                    nodes[i] = replacement;\n                }\n                if (!dontUpdateLastIndex) {\n                    nodes.claim_info.last_index = i;\n                }\n                return node;\n            }\n        }\n        // Otherwise, we try to find one before\n        // We iterate in reverse so that we don't go too far back\n        for (let i = nodes.claim_info.last_index - 1; i >= 0; i--) {\n            const node = nodes[i];\n            if (predicate(node)) {\n                const replacement = processNode(node);\n                if (replacement === undefined) {\n                    nodes.splice(i, 1);\n                }\n                else {\n                    nodes[i] = replacement;\n                }\n                if (!dontUpdateLastIndex) {\n                    nodes.claim_info.last_index = i;\n                }\n                else if (replacement === undefined) {\n                    // Since we spliced before the last_index, we decrease it\n                    nodes.claim_info.last_index--;\n                }\n                return node;\n            }\n        }\n        // If we can't find any matching node, we create a new one\n        return createNode();\n    })();\n    resultNode.claim_order = nodes.claim_info.total_claimed;\n    nodes.claim_info.total_claimed += 1;\n    return resultNode;\n}\nfunction claim_element_base(nodes, name, attributes, create_element) {\n    return claim_node(nodes, (node) => node.nodeName === name, (node) => {\n        const remove = [];\n        for (let j = 0; j < node.attributes.length; j++) {\n            const attribute = node.attributes[j];\n            if (!attributes[attribute.name]) {\n                remove.push(attribute.name);\n            }\n        }\n        remove.forEach(v => node.removeAttribute(v));\n        return undefined;\n    }, () => create_element(name));\n}\nfunction claim_element(nodes, name, attributes) {\n    return claim_element_base(nodes, name, attributes, element);\n}\nfunction claim_svg_element(nodes, name, attributes) {\n    return claim_element_base(nodes, name, attributes, svg_element);\n}\nfunction claim_text(nodes, data) {\n    return claim_node(nodes, (node) => node.nodeType === 3, (node) => {\n        const dataStr = '' + data;\n        if (node.data.startsWith(dataStr)) {\n            if (node.data.length !== dataStr.length) {\n                return node.splitText(dataStr.length);\n            }\n        }\n        else {\n            node.data = dataStr;\n        }\n    }, () => text(data), true // Text nodes should not update last index since it is likely not worth it to eliminate an increasing subsequence of actual elements\n    );\n}\nfunction claim_space(nodes) {\n    return claim_text(nodes, ' ');\n}\nfunction find_comment(nodes, text, start) {\n    for (let i = start; i < nodes.length; i += 1) {\n        const node = nodes[i];\n        if (node.nodeType === 8 /* comment node */ && node.textContent.trim() === text) {\n            return i;\n        }\n    }\n    return nodes.length;\n}\nfunction claim_html_tag(nodes, is_svg) {\n    // find html opening tag\n    const start_index = find_comment(nodes, 'HTML_TAG_START', 0);\n    const end_index = find_comment(nodes, 'HTML_TAG_END', start_index);\n    if (start_index === end_index) {\n        return new HtmlTagHydration(undefined, is_svg);\n    }\n    init_claim_info(nodes);\n    const html_tag_nodes = nodes.splice(start_index, end_index - start_index + 1);\n    detach(html_tag_nodes[0]);\n    detach(html_tag_nodes[html_tag_nodes.length - 1]);\n    const claimed_nodes = html_tag_nodes.slice(1, html_tag_nodes.length - 1);\n    for (const n of claimed_nodes) {\n        n.claim_order = nodes.claim_info.total_claimed;\n        nodes.claim_info.total_claimed += 1;\n    }\n    return new HtmlTagHydration(claimed_nodes, is_svg);\n}\nfunction set_data(text, data) {\n    data = '' + data;\n    if (text.wholeText !== data)\n        text.data = data;\n}\nfunction set_input_value(input, value) {\n    input.value = value == null ? '' : value;\n}\nfunction set_input_type(input, type) {\n    try {\n        input.type = type;\n    }\n    catch (e) {\n        // do nothing\n    }\n}\nfunction set_style(node, key, value, important) {\n    if (value === null) {\n        node.style.removeProperty(key);\n    }\n    else {\n        node.style.setProperty(key, value, important ? 'important' : '');\n    }\n}\nfunction select_option(select, value) {\n    for (let i = 0; i < select.options.length; i += 1) {\n        const option = select.options[i];\n        if (option.__value === value) {\n            option.selected = true;\n            return;\n        }\n    }\n    select.selectedIndex = -1; // no option should be selected\n}\nfunction select_options(select, value) {\n    for (let i = 0; i < select.options.length; i += 1) {\n        const option = select.options[i];\n        option.selected = ~value.indexOf(option.__value);\n    }\n}\nfunction select_value(select) {\n    const selected_option = select.querySelector(':checked') || select.options[0];\n    return selected_option && selected_option.__value;\n}\nfunction select_multiple_value(select) {\n    return [].map.call(select.querySelectorAll(':checked'), option => option.__value);\n}\n// unfortunately this can't be a constant as that wouldn't be tree-shakeable\n// so we cache the result instead\nlet crossorigin;\nfunction is_crossorigin() {\n    if (crossorigin === undefined) {\n        crossorigin = false;\n        try {\n            if (typeof window !== 'undefined' && window.parent) {\n                void window.parent.document;\n            }\n        }\n        catch (error) {\n            crossorigin = true;\n        }\n    }\n    return crossorigin;\n}\nfunction add_resize_listener(node, fn) {\n    const computed_style = getComputedStyle(node);\n    if (computed_style.position === 'static') {\n        node.style.position = 'relative';\n    }\n    const iframe = element('iframe');\n    iframe.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; ' +\n        'overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;');\n    iframe.setAttribute('aria-hidden', 'true');\n    iframe.tabIndex = -1;\n    const crossorigin = is_crossorigin();\n    let unsubscribe;\n    if (crossorigin) {\n        iframe.src = \"data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}</script>\";\n        unsubscribe = listen(window, 'message', (event) => {\n            if (event.source === iframe.contentWindow)\n                fn();\n        });\n    }\n    else {\n        iframe.src = 'about:blank';\n        iframe.onload = () => {\n            unsubscribe = listen(iframe.contentWindow, 'resize', fn);\n        };\n    }\n    append(node, iframe);\n    return () => {\n        if (crossorigin) {\n            unsubscribe();\n        }\n        else if (unsubscribe && iframe.contentWindow) {\n            unsubscribe();\n        }\n        detach(iframe);\n    };\n}\nfunction toggle_class(element, name, toggle) {\n    element.classList[toggle ? 'add' : 'remove'](name);\n}\nfunction custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {\n    const e = document.createEvent('CustomEvent');\n    e.initCustomEvent(type, bubbles, cancelable, detail);\n    return e;\n}\nfunction query_selector_all(selector, parent = document.body) {\n    return Array.from(parent.querySelectorAll(selector));\n}\nclass HtmlTag {\n    constructor(is_svg = false) {\n        this.is_svg = false;\n        this.is_svg = is_svg;\n        this.e = this.n = null;\n    }\n    c(html) {\n        this.h(html);\n    }\n    m(html, target, anchor = null) {\n        if (!this.e) {\n            if (this.is_svg)\n                this.e = svg_element(target.nodeName);\n            else\n                this.e = element(target.nodeName);\n            this.t = target;\n            this.c(html);\n        }\n        this.i(anchor);\n    }\n    h(html) {\n        this.e.innerHTML = html;\n        this.n = Array.from(this.e.childNodes);\n    }\n    i(anchor) {\n        for (let i = 0; i < this.n.length; i += 1) {\n            insert(this.t, this.n[i], anchor);\n        }\n    }\n    p(html) {\n        this.d();\n        this.h(html);\n        this.i(this.a);\n    }\n    d() {\n        this.n.forEach(detach);\n    }\n}\nclass HtmlTagHydration extends HtmlTag {\n    constructor(claimed_nodes, is_svg = false) {\n        super(is_svg);\n        this.e = this.n = null;\n        this.l = claimed_nodes;\n    }\n    c(html) {\n        if (this.l) {\n            this.n = this.l;\n        }\n        else {\n            super.c(html);\n        }\n    }\n    i(anchor) {\n        for (let i = 0; i < this.n.length; i += 1) {\n            insert_hydration(this.t, this.n[i], anchor);\n        }\n    }\n}\nfunction attribute_to_object(attributes) {\n    const result = {};\n    for (const attribute of attributes) {\n        result[attribute.name] = attribute.value;\n    }\n    return result;\n}\nfunction get_custom_elements_slots(element) {\n    const result = {};\n    element.childNodes.forEach((node) => {\n        result[node.slot || 'default'] = true;\n    });\n    return result;\n}\n\n// we need to store the information for multiple documents because a Svelte application could also contain iframes\n// https://github.com/sveltejs/svelte/issues/3624\nconst managed_styles = new Map();\nlet active = 0;\n// https://github.com/darkskyapp/string-hash/blob/master/index.js\nfunction hash(str) {\n    let hash = 5381;\n    let i = str.length;\n    while (i--)\n        hash = ((hash << 5) - hash) ^ str.charCodeAt(i);\n    return hash >>> 0;\n}\nfunction create_style_information(doc, node) {\n    const info = { stylesheet: append_empty_stylesheet(node), rules: {} };\n    managed_styles.set(doc, info);\n    return info;\n}\nfunction create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {\n    const step = 16.666 / duration;\n    let keyframes = '{\\n';\n    for (let p = 0; p <= 1; p += step) {\n        const t = a + (b - a) * ease(p);\n        keyframes += p * 100 + `%{${fn(t, 1 - t)}}\\n`;\n    }\n    const rule = keyframes + `100% {${fn(b, 1 - b)}}\\n}`;\n    const name = `__svelte_${hash(rule)}_${uid}`;\n    const doc = get_root_for_style(node);\n    const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);\n    if (!rules[name]) {\n        rules[name] = true;\n        stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);\n    }\n    const animation = node.style.animation || '';\n    node.style.animation = `${animation ? `${animation}, ` : ''}${name} ${duration}ms linear ${delay}ms 1 both`;\n    active += 1;\n    return name;\n}\nfunction delete_rule(node, name) {\n    const previous = (node.style.animation || '').split(', ');\n    const next = previous.filter(name\n        ? anim => anim.indexOf(name) < 0 // remove specific animation\n        : anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations\n    );\n    const deleted = previous.length - next.length;\n    if (deleted) {\n        node.style.animation = next.join(', ');\n        active -= deleted;\n        if (!active)\n            clear_rules();\n    }\n}\nfunction clear_rules() {\n    raf(() => {\n        if (active)\n            return;\n        managed_styles.forEach(info => {\n            const { stylesheet } = info;\n            let i = stylesheet.cssRules.length;\n            while (i--)\n                stylesheet.deleteRule(i);\n            info.rules = {};\n        });\n        managed_styles.clear();\n    });\n}\n\nfunction create_animation(node, from, fn, params) {\n    if (!from)\n        return noop;\n    const to = node.getBoundingClientRect();\n    if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom)\n        return noop;\n    const { delay = 0, duration = 300, easing = identity, \n    // @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?\n    start: start_time = now() + delay, \n    // @ts-ignore todo:\n    end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params);\n    let running = true;\n    let started = false;\n    let name;\n    function start() {\n        if (css) {\n            name = create_rule(node, 0, 1, duration, delay, easing, css);\n        }\n        if (!delay) {\n            started = true;\n        }\n    }\n    function stop() {\n        if (css)\n            delete_rule(node, name);\n        running = false;\n    }\n    loop(now => {\n        if (!started && now >= start_time) {\n            started = true;\n        }\n        if (started && now >= end) {\n            tick(1, 0);\n            stop();\n        }\n        if (!running) {\n            return false;\n        }\n        if (started) {\n            const p = now - start_time;\n            const t = 0 + 1 * easing(p / duration);\n            tick(t, 1 - t);\n        }\n        return true;\n    });\n    start();\n    tick(0, 1);\n    return stop;\n}\nfunction fix_position(node) {\n    const style = getComputedStyle(node);\n    if (style.position !== 'absolute' && style.position !== 'fixed') {\n        const { width, height } = style;\n        const a = node.getBoundingClientRect();\n        node.style.position = 'absolute';\n        node.style.width = width;\n        node.style.height = height;\n        add_transform(node, a);\n    }\n}\nfunction add_transform(node, a) {\n    const b = node.getBoundingClientRect();\n    if (a.left !== b.left || a.top !== b.top) {\n        const style = getComputedStyle(node);\n        const transform = style.transform === 'none' ? '' : style.transform;\n        node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;\n    }\n}\n\nlet current_component;\nfunction set_current_component(component) {\n    current_component = component;\n}\nfunction get_current_component() {\n    if (!current_component)\n        throw new Error('Function called outside component initialization');\n    return current_component;\n}\nfunction beforeUpdate(fn) {\n    get_current_component().$$.before_update.push(fn);\n}\nfunction onMount(fn) {\n    get_current_component().$$.on_mount.push(fn);\n}\nfunction afterUpdate(fn) {\n    get_current_component().$$.after_update.push(fn);\n}\nfunction onDestroy(fn) {\n    get_current_component().$$.on_destroy.push(fn);\n}\nfunction createEventDispatcher() {\n    const component = get_current_component();\n    return (type, detail, { cancelable = false } = {}) => {\n        const callbacks = component.$$.callbacks[type];\n        if (callbacks) {\n            // TODO are there situations where events could be dispatched\n            // in a server (non-DOM) environment?\n            const event = custom_event(type, detail, { cancelable });\n            callbacks.slice().forEach(fn => {\n                fn.call(component, event);\n            });\n            return !event.defaultPrevented;\n        }\n        return true;\n    };\n}\nfunction setContext(key, context) {\n    get_current_component().$$.context.set(key, context);\n    return context;\n}\nfunction getContext(key) {\n    return get_current_component().$$.context.get(key);\n}\nfunction getAllContexts() {\n    return get_current_component().$$.context;\n}\nfunction hasContext(key) {\n    return get_current_component().$$.context.has(key);\n}\n// TODO figure out if we still want to support\n// shorthand events, or if we want to implement\n// a real bubbling mechanism\nfunction bubble(component, event) {\n    const callbacks = component.$$.callbacks[event.type];\n    if (callbacks) {\n        // @ts-ignore\n        callbacks.slice().forEach(fn => fn.call(this, event));\n    }\n}\n\nconst dirty_components = [];\nconst intros = { enabled: false };\nconst binding_callbacks = [];\nconst render_callbacks = [];\nconst flush_callbacks = [];\nconst resolved_promise = Promise.resolve();\nlet update_scheduled = false;\nfunction schedule_update() {\n    if (!update_scheduled) {\n        update_scheduled = true;\n        resolved_promise.then(flush);\n    }\n}\nfunction tick() {\n    schedule_update();\n    return resolved_promise;\n}\nfunction add_render_callback(fn) {\n    render_callbacks.push(fn);\n}\nfunction add_flush_callback(fn) {\n    flush_callbacks.push(fn);\n}\n// flush() calls callbacks in this order:\n// 1. All beforeUpdate callbacks, in order: parents before children\n// 2. All bind:this callbacks, in reverse order: children before parents.\n// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT\n//    for afterUpdates called during the initial onMount, which are called in\n//    reverse order: children before parents.\n// Since callbacks might update component values, which could trigger another\n// call to flush(), the following steps guard against this:\n// 1. During beforeUpdate, any updated components will be added to the\n//    dirty_components array and will cause a reentrant call to flush(). Because\n//    the flush index is kept outside the function, the reentrant call will pick\n//    up where the earlier call left off and go through all dirty components. The\n//    current_component value is saved and restored so that the reentrant call will\n//    not interfere with the \"parent\" flush() call.\n// 2. bind:this callbacks cannot trigger new flush() calls.\n// 3. During afterUpdate, any updated components will NOT have their afterUpdate\n//    callback called a second time; the seen_callbacks set, outside the flush()\n//    function, guarantees this behavior.\nconst seen_callbacks = new Set();\nlet flushidx = 0; // Do *not* move this inside the flush() function\nfunction flush() {\n    const saved_component = current_component;\n    do {\n        // first, call beforeUpdate functions\n        // and update components\n        while (flushidx < dirty_components.length) {\n            const component = dirty_components[flushidx];\n            flushidx++;\n            set_current_component(component);\n            update(component.$$);\n        }\n        set_current_component(null);\n        dirty_components.length = 0;\n        flushidx = 0;\n        while (binding_callbacks.length)\n            binding_callbacks.pop()();\n        // then, once components are updated, call\n        // afterUpdate functions. This may cause\n        // subsequent updates...\n        for (let i = 0; i < render_callbacks.length; i += 1) {\n            const callback = render_callbacks[i];\n            if (!seen_callbacks.has(callback)) {\n                // ...so guard against infinite loops\n                seen_callbacks.add(callback);\n                callback();\n            }\n        }\n        render_callbacks.length = 0;\n    } while (dirty_components.length);\n    while (flush_callbacks.length) {\n        flush_callbacks.pop()();\n    }\n    update_scheduled = false;\n    seen_callbacks.clear();\n    set_current_component(saved_component);\n}\nfunction update($$) {\n    if ($$.fragment !== null) {\n        $$.update();\n        run_all($$.before_update);\n        const dirty = $$.dirty;\n        $$.dirty = [-1];\n        $$.fragment && $$.fragment.p($$.ctx, dirty);\n        $$.after_update.forEach(add_render_callback);\n    }\n}\n\nlet promise;\nfunction wait() {\n    if (!promise) {\n        promise = Promise.resolve();\n        promise.then(() => {\n            promise = null;\n        });\n    }\n    return promise;\n}\nfunction dispatch(node, direction, kind) {\n    node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));\n}\nconst outroing = new Set();\nlet outros;\nfunction group_outros() {\n    outros = {\n        r: 0,\n        c: [],\n        p: outros // parent group\n    };\n}\nfunction check_outros() {\n    if (!outros.r) {\n        run_all(outros.c);\n    }\n    outros = outros.p;\n}\nfunction transition_in(block, local) {\n    if (block && block.i) {\n        outroing.delete(block);\n        block.i(local);\n    }\n}\nfunction transition_out(block, local, detach, callback) {\n    if (block && block.o) {\n        if (outroing.has(block))\n            return;\n        outroing.add(block);\n        outros.c.push(() => {\n            outroing.delete(block);\n            if (callback) {\n                if (detach)\n                    block.d(1);\n                callback();\n            }\n        });\n        block.o(local);\n    }\n    else if (callback) {\n        callback();\n    }\n}\nconst null_transition = { duration: 0 };\nfunction create_in_transition(node, fn, params) {\n    let config = fn(node, params);\n    let running = false;\n    let animation_name;\n    let task;\n    let uid = 0;\n    function cleanup() {\n        if (animation_name)\n            delete_rule(node, animation_name);\n    }\n    function go() {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        if (css)\n            animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);\n        tick(0, 1);\n        const start_time = now() + delay;\n        const end_time = start_time + duration;\n        if (task)\n            task.abort();\n        running = true;\n        add_render_callback(() => dispatch(node, true, 'start'));\n        task = loop(now => {\n            if (running) {\n                if (now >= end_time) {\n                    tick(1, 0);\n                    dispatch(node, true, 'end');\n                    cleanup();\n                    return running = false;\n                }\n                if (now >= start_time) {\n                    const t = easing((now - start_time) / duration);\n                    tick(t, 1 - t);\n                }\n            }\n            return running;\n        });\n    }\n    let started = false;\n    return {\n        start() {\n            if (started)\n                return;\n            started = true;\n            delete_rule(node);\n            if (is_function(config)) {\n                config = config();\n                wait().then(go);\n            }\n            else {\n                go();\n            }\n        },\n        invalidate() {\n            started = false;\n        },\n        end() {\n            if (running) {\n                cleanup();\n                running = false;\n            }\n        }\n    };\n}\nfunction create_out_transition(node, fn, params) {\n    let config = fn(node, params);\n    let running = true;\n    let animation_name;\n    const group = outros;\n    group.r += 1;\n    function go() {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        if (css)\n            animation_name = create_rule(node, 1, 0, duration, delay, easing, css);\n        const start_time = now() + delay;\n        const end_time = start_time + duration;\n        add_render_callback(() => dispatch(node, false, 'start'));\n        loop(now => {\n            if (running) {\n                if (now >= end_time) {\n                    tick(0, 1);\n                    dispatch(node, false, 'end');\n                    if (!--group.r) {\n                        // this will result in `end()` being called,\n                        // so we don't need to clean up here\n                        run_all(group.c);\n                    }\n                    return false;\n                }\n                if (now >= start_time) {\n                    const t = easing((now - start_time) / duration);\n                    tick(1 - t, t);\n                }\n            }\n            return running;\n        });\n    }\n    if (is_function(config)) {\n        wait().then(() => {\n            // @ts-ignore\n            config = config();\n            go();\n        });\n    }\n    else {\n        go();\n    }\n    return {\n        end(reset) {\n            if (reset && config.tick) {\n                config.tick(1, 0);\n            }\n            if (running) {\n                if (animation_name)\n                    delete_rule(node, animation_name);\n                running = false;\n            }\n        }\n    };\n}\nfunction create_bidirectional_transition(node, fn, params, intro) {\n    let config = fn(node, params);\n    let t = intro ? 0 : 1;\n    let running_program = null;\n    let pending_program = null;\n    let animation_name = null;\n    function clear_animation() {\n        if (animation_name)\n            delete_rule(node, animation_name);\n    }\n    function init(program, duration) {\n        const d = (program.b - t);\n        duration *= Math.abs(d);\n        return {\n            a: t,\n            b: program.b,\n            d,\n            duration,\n            start: program.start,\n            end: program.start + duration,\n            group: program.group\n        };\n    }\n    function go(b) {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        const program = {\n            start: now() + delay,\n            b\n        };\n        if (!b) {\n            // @ts-ignore todo: improve typings\n            program.group = outros;\n            outros.r += 1;\n        }\n        if (running_program || pending_program) {\n            pending_program = program;\n        }\n        else {\n            // if this is an intro, and there's a delay, we need to do\n            // an initial tick and/or apply CSS animation immediately\n            if (css) {\n                clear_animation();\n                animation_name = create_rule(node, t, b, duration, delay, easing, css);\n            }\n            if (b)\n                tick(0, 1);\n            running_program = init(program, duration);\n            add_render_callback(() => dispatch(node, b, 'start'));\n            loop(now => {\n                if (pending_program && now > pending_program.start) {\n                    running_program = init(pending_program, duration);\n                    pending_program = null;\n                    dispatch(node, running_program.b, 'start');\n                    if (css) {\n                        clear_animation();\n                        animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);\n                    }\n                }\n                if (running_program) {\n                    if (now >= running_program.end) {\n                        tick(t = running_program.b, 1 - t);\n                        dispatch(node, running_program.b, 'end');\n                        if (!pending_program) {\n                            // we're done\n                            if (running_program.b) {\n                                // intro — we can tidy up immediately\n                                clear_animation();\n                            }\n                            else {\n                                // outro — needs to be coordinated\n                                if (!--running_program.group.r)\n                                    run_all(running_program.group.c);\n                            }\n                        }\n                        running_program = null;\n                    }\n                    else if (now >= running_program.start) {\n                        const p = now - running_program.start;\n                        t = running_program.a + running_program.d * easing(p / running_program.duration);\n                        tick(t, 1 - t);\n                    }\n                }\n                return !!(running_program || pending_program);\n            });\n        }\n    }\n    return {\n        run(b) {\n            if (is_function(config)) {\n                wait().then(() => {\n                    // @ts-ignore\n                    config = config();\n                    go(b);\n                });\n            }\n            else {\n                go(b);\n            }\n        },\n        end() {\n            clear_animation();\n            running_program = pending_program = null;\n        }\n    };\n}\n\nfunction handle_promise(promise, info) {\n    const token = info.token = {};\n    function update(type, index, key, value) {\n        if (info.token !== token)\n            return;\n        info.resolved = value;\n        let child_ctx = info.ctx;\n        if (key !== undefined) {\n            child_ctx = child_ctx.slice();\n            child_ctx[key] = value;\n        }\n        const block = type && (info.current = type)(child_ctx);\n        let needs_flush = false;\n        if (info.block) {\n            if (info.blocks) {\n                info.blocks.forEach((block, i) => {\n                    if (i !== index && block) {\n                        group_outros();\n                        transition_out(block, 1, 1, () => {\n                            if (info.blocks[i] === block) {\n                                info.blocks[i] = null;\n                            }\n                        });\n                        check_outros();\n                    }\n                });\n            }\n            else {\n                info.block.d(1);\n            }\n            block.c();\n            transition_in(block, 1);\n            block.m(info.mount(), info.anchor);\n            needs_flush = true;\n        }\n        info.block = block;\n        if (info.blocks)\n            info.blocks[index] = block;\n        if (needs_flush) {\n            flush();\n        }\n    }\n    if (is_promise(promise)) {\n        const current_component = get_current_component();\n        promise.then(value => {\n            set_current_component(current_component);\n            update(info.then, 1, info.value, value);\n            set_current_component(null);\n        }, error => {\n            set_current_component(current_component);\n            update(info.catch, 2, info.error, error);\n            set_current_component(null);\n            if (!info.hasCatch) {\n                throw error;\n            }\n        });\n        // if we previously had a then/catch block, destroy it\n        if (info.current !== info.pending) {\n            update(info.pending, 0);\n            return true;\n        }\n    }\n    else {\n        if (info.current !== info.then) {\n            update(info.then, 1, info.value, promise);\n            return true;\n        }\n        info.resolved = promise;\n    }\n}\nfunction update_await_block_branch(info, ctx, dirty) {\n    const child_ctx = ctx.slice();\n    const { resolved } = info;\n    if (info.current === info.then) {\n        child_ctx[info.value] = resolved;\n    }\n    if (info.current === info.catch) {\n        child_ctx[info.error] = resolved;\n    }\n    info.block.p(child_ctx, dirty);\n}\n\nconst globals = (typeof window !== 'undefined'\n    ? window\n    : typeof globalThis !== 'undefined'\n        ? globalThis\n        : global);\n\nfunction destroy_block(block, lookup) {\n    block.d(1);\n    lookup.delete(block.key);\n}\nfunction outro_and_destroy_block(block, lookup) {\n    transition_out(block, 1, 1, () => {\n        lookup.delete(block.key);\n    });\n}\nfunction fix_and_destroy_block(block, lookup) {\n    block.f();\n    destroy_block(block, lookup);\n}\nfunction fix_and_outro_and_destroy_block(block, lookup) {\n    block.f();\n    outro_and_destroy_block(block, lookup);\n}\nfunction update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {\n    let o = old_blocks.length;\n    let n = list.length;\n    let i = o;\n    const old_indexes = {};\n    while (i--)\n        old_indexes[old_blocks[i].key] = i;\n    const new_blocks = [];\n    const new_lookup = new Map();\n    const deltas = new Map();\n    i = n;\n    while (i--) {\n        const child_ctx = get_context(ctx, list, i);\n        const key = get_key(child_ctx);\n        let block = lookup.get(key);\n        if (!block) {\n            block = create_each_block(key, child_ctx);\n            block.c();\n        }\n        else if (dynamic) {\n            block.p(child_ctx, dirty);\n        }\n        new_lookup.set(key, new_blocks[i] = block);\n        if (key in old_indexes)\n            deltas.set(key, Math.abs(i - old_indexes[key]));\n    }\n    const will_move = new Set();\n    const did_move = new Set();\n    function insert(block) {\n        transition_in(block, 1);\n        block.m(node, next);\n        lookup.set(block.key, block);\n        next = block.first;\n        n--;\n    }\n    while (o && n) {\n        const new_block = new_blocks[n - 1];\n        const old_block = old_blocks[o - 1];\n        const new_key = new_block.key;\n        const old_key = old_block.key;\n        if (new_block === old_block) {\n            // do nothing\n            next = new_block.first;\n            o--;\n            n--;\n        }\n        else if (!new_lookup.has(old_key)) {\n            // remove old block\n            destroy(old_block, lookup);\n            o--;\n        }\n        else if (!lookup.has(new_key) || will_move.has(new_key)) {\n            insert(new_block);\n        }\n        else if (did_move.has(old_key)) {\n            o--;\n        }\n        else if (deltas.get(new_key) > deltas.get(old_key)) {\n            did_move.add(new_key);\n            insert(new_block);\n        }\n        else {\n            will_move.add(old_key);\n            o--;\n        }\n    }\n    while (o--) {\n        const old_block = old_blocks[o];\n        if (!new_lookup.has(old_block.key))\n            destroy(old_block, lookup);\n    }\n    while (n)\n        insert(new_blocks[n - 1]);\n    return new_blocks;\n}\nfunction validate_each_keys(ctx, list, get_context, get_key) {\n    const keys = new Set();\n    for (let i = 0; i < list.length; i++) {\n        const key = get_key(get_context(ctx, list, i));\n        if (keys.has(key)) {\n            throw new Error('Cannot have duplicate keys in a keyed each');\n        }\n        keys.add(key);\n    }\n}\n\nfunction get_spread_update(levels, updates) {\n    const update = {};\n    const to_null_out = {};\n    const accounted_for = { $$scope: 1 };\n    let i = levels.length;\n    while (i--) {\n        const o = levels[i];\n        const n = updates[i];\n        if (n) {\n            for (const key in o) {\n                if (!(key in n))\n                    to_null_out[key] = 1;\n            }\n            for (const key in n) {\n                if (!accounted_for[key]) {\n                    update[key] = n[key];\n                    accounted_for[key] = 1;\n                }\n            }\n            levels[i] = n;\n        }\n        else {\n            for (const key in o) {\n                accounted_for[key] = 1;\n            }\n        }\n    }\n    for (const key in to_null_out) {\n        if (!(key in update))\n            update[key] = undefined;\n    }\n    return update;\n}\nfunction get_spread_object(spread_props) {\n    return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};\n}\n\n// source: https://html.spec.whatwg.org/multipage/indices.html\nconst boolean_attributes = new Set([\n    'allowfullscreen',\n    'allowpaymentrequest',\n    'async',\n    'autofocus',\n    'autoplay',\n    'checked',\n    'controls',\n    'default',\n    'defer',\n    'disabled',\n    'formnovalidate',\n    'hidden',\n    'ismap',\n    'loop',\n    'multiple',\n    'muted',\n    'nomodule',\n    'novalidate',\n    'open',\n    'playsinline',\n    'readonly',\n    'required',\n    'reversed',\n    'selected'\n]);\n\nconst void_element_names = /^(?:area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)$/;\nfunction is_void(name) {\n    return void_element_names.test(name) || name.toLowerCase() === '!doctype';\n}\n\nconst invalid_attribute_name_character = /[\\s'\">/=\\u{FDD0}-\\u{FDEF}\\u{FFFE}\\u{FFFF}\\u{1FFFE}\\u{1FFFF}\\u{2FFFE}\\u{2FFFF}\\u{3FFFE}\\u{3FFFF}\\u{4FFFE}\\u{4FFFF}\\u{5FFFE}\\u{5FFFF}\\u{6FFFE}\\u{6FFFF}\\u{7FFFE}\\u{7FFFF}\\u{8FFFE}\\u{8FFFF}\\u{9FFFE}\\u{9FFFF}\\u{AFFFE}\\u{AFFFF}\\u{BFFFE}\\u{BFFFF}\\u{CFFFE}\\u{CFFFF}\\u{DFFFE}\\u{DFFFF}\\u{EFFFE}\\u{EFFFF}\\u{FFFFE}\\u{FFFFF}\\u{10FFFE}\\u{10FFFF}]/u;\n// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n// https://infra.spec.whatwg.org/#noncharacter\nfunction spread(args, attrs_to_add) {\n    const attributes = Object.assign({}, ...args);\n    if (attrs_to_add) {\n        const classes_to_add = attrs_to_add.classes;\n        const styles_to_add = attrs_to_add.styles;\n        if (classes_to_add) {\n            if (attributes.class == null) {\n                attributes.class = classes_to_add;\n            }\n            else {\n                attributes.class += ' ' + classes_to_add;\n            }\n        }\n        if (styles_to_add) {\n            if (attributes.style == null) {\n                attributes.style = style_object_to_string(styles_to_add);\n            }\n            else {\n                attributes.style = style_object_to_string(merge_ssr_styles(attributes.style, styles_to_add));\n            }\n        }\n    }\n    let str = '';\n    Object.keys(attributes).forEach(name => {\n        if (invalid_attribute_name_character.test(name))\n            return;\n        const value = attributes[name];\n        if (value === true)\n            str += ' ' + name;\n        else if (boolean_attributes.has(name.toLowerCase())) {\n            if (value)\n                str += ' ' + name;\n        }\n        else if (value != null) {\n            str += ` ${name}=\"${value}\"`;\n        }\n    });\n    return str;\n}\nfunction merge_ssr_styles(style_attribute, style_directive) {\n    const style_object = {};\n    for (const individual_style of style_attribute.split(';')) {\n        const colon_index = individual_style.indexOf(':');\n        const name = individual_style.slice(0, colon_index).trim();\n        const value = individual_style.slice(colon_index + 1).trim();\n        if (!name)\n            continue;\n        style_object[name] = value;\n    }\n    for (const name in style_directive) {\n        const value = style_directive[name];\n        if (value) {\n            style_object[name] = value;\n        }\n        else {\n            delete style_object[name];\n        }\n    }\n    return style_object;\n}\nconst ATTR_REGEX = /[&\"]/g;\nconst CONTENT_REGEX = /[&<]/g;\n/**\n * Note: this method is performance sensitive and has been optimized\n * https://github.com/sveltejs/svelte/pull/5701\n */\nfunction escape(value, is_attr = false) {\n    const str = String(value);\n    const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;\n    pattern.lastIndex = 0;\n    let escaped = '';\n    let last = 0;\n    while (pattern.test(str)) {\n        const i = pattern.lastIndex - 1;\n        const ch = str[i];\n        escaped += str.substring(last, i) + (ch === '&' ? '&amp;' : (ch === '\"' ? '&quot;' : '&lt;'));\n        last = i + 1;\n    }\n    return escaped + str.substring(last);\n}\nfunction escape_attribute_value(value) {\n    // keep booleans, null, and undefined for the sake of `spread`\n    const should_escape = typeof value === 'string' || (value && typeof value === 'object');\n    return should_escape ? escape(value, true) : value;\n}\nfunction escape_object(obj) {\n    const result = {};\n    for (const key in obj) {\n        result[key] = escape_attribute_value(obj[key]);\n    }\n    return result;\n}\nfunction each(items, fn) {\n    let str = '';\n    for (let i = 0; i < items.length; i += 1) {\n        str += fn(items[i], i);\n    }\n    return str;\n}\nconst missing_component = {\n    $$render: () => ''\n};\nfunction validate_component(component, name) {\n    if (!component || !component.$$render) {\n        if (name === 'svelte:component')\n            name += ' this={...}';\n        throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);\n    }\n    return component;\n}\nfunction debug(file, line, column, values) {\n    console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console\n    console.log(values); // eslint-disable-line no-console\n    return '';\n}\nlet on_destroy;\nfunction create_ssr_component(fn) {\n    function $$render(result, props, bindings, slots, context) {\n        const parent_component = current_component;\n        const $$ = {\n            on_destroy,\n            context: new Map(context || (parent_component ? parent_component.$$.context : [])),\n            // these will be immediately discarded\n            on_mount: [],\n            before_update: [],\n            after_update: [],\n            callbacks: blank_object()\n        };\n        set_current_component({ $$ });\n        const html = fn(result, props, bindings, slots);\n        set_current_component(parent_component);\n        return html;\n    }\n    return {\n        render: (props = {}, { $$slots = {}, context = new Map() } = {}) => {\n            on_destroy = [];\n            const result = { title: '', head: '', css: new Set() };\n            const html = $$render(result, props, {}, $$slots, context);\n            run_all(on_destroy);\n            return {\n                html,\n                css: {\n                    code: Array.from(result.css).map(css => css.code).join('\\n'),\n                    map: null // TODO\n                },\n                head: result.title + result.head\n            };\n        },\n        $$render\n    };\n}\nfunction add_attribute(name, value, boolean) {\n    if (value == null || (boolean && !value))\n        return '';\n    const assignment = (boolean && value === true) ? '' : `=\"${escape(value, true)}\"`;\n    return ` ${name}${assignment}`;\n}\nfunction add_classes(classes) {\n    return classes ? ` class=\"${classes}\"` : '';\n}\nfunction style_object_to_string(style_object) {\n    return Object.keys(style_object)\n        .filter(key => style_object[key])\n        .map(key => `${key}: ${style_object[key]};`)\n        .join(' ');\n}\nfunction add_styles(style_object) {\n    const styles = style_object_to_string(style_object);\n    return styles ? ` style=\"${styles}\"` : '';\n}\n\nfunction bind(component, name, callback) {\n    const index = component.$$.props[name];\n    if (index !== undefined) {\n        component.$$.bound[index] = callback;\n        callback(component.$$.ctx[index]);\n    }\n}\nfunction create_component(block) {\n    block && block.c();\n}\nfunction claim_component(block, parent_nodes) {\n    block && block.l(parent_nodes);\n}\nfunction mount_component(component, target, anchor, customElement) {\n    const { fragment, on_mount, on_destroy, after_update } = component.$$;\n    fragment && fragment.m(target, anchor);\n    if (!customElement) {\n        // onMount happens before the initial afterUpdate\n        add_render_callback(() => {\n            const new_on_destroy = on_mount.map(run).filter(is_function);\n            if (on_destroy) {\n                on_destroy.push(...new_on_destroy);\n            }\n            else {\n                // Edge case - component was destroyed immediately,\n                // most likely as a result of a binding initialising\n                run_all(new_on_destroy);\n            }\n            component.$$.on_mount = [];\n        });\n    }\n    after_update.forEach(add_render_callback);\n}\nfunction destroy_component(component, detaching) {\n    const $$ = component.$$;\n    if ($$.fragment !== null) {\n        run_all($$.on_destroy);\n        $$.fragment && $$.fragment.d(detaching);\n        // TODO null out other refs, including component.$$ (but need to\n        // preserve final state?)\n        $$.on_destroy = $$.fragment = null;\n        $$.ctx = [];\n    }\n}\nfunction make_dirty(component, i) {\n    if (component.$$.dirty[0] === -1) {\n        dirty_components.push(component);\n        schedule_update();\n        component.$$.dirty.fill(0);\n    }\n    component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));\n}\nfunction init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {\n    const parent_component = current_component;\n    set_current_component(component);\n    const $$ = component.$$ = {\n        fragment: null,\n        ctx: null,\n        // state\n        props,\n        update: noop,\n        not_equal,\n        bound: blank_object(),\n        // lifecycle\n        on_mount: [],\n        on_destroy: [],\n        on_disconnect: [],\n        before_update: [],\n        after_update: [],\n        context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),\n        // everything else\n        callbacks: blank_object(),\n        dirty,\n        skip_bound: false,\n        root: options.target || parent_component.$$.root\n    };\n    append_styles && append_styles($$.root);\n    let ready = false;\n    $$.ctx = instance\n        ? instance(component, options.props || {}, (i, ret, ...rest) => {\n            const value = rest.length ? rest[0] : ret;\n            if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {\n                if (!$$.skip_bound && $$.bound[i])\n                    $$.bound[i](value);\n                if (ready)\n                    make_dirty(component, i);\n            }\n            return ret;\n        })\n        : [];\n    $$.update();\n    ready = true;\n    run_all($$.before_update);\n    // `false` as a special case of no DOM component\n    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;\n    if (options.target) {\n        if (options.hydrate) {\n            start_hydrating();\n            const nodes = children(options.target);\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            $$.fragment && $$.fragment.l(nodes);\n            nodes.forEach(detach);\n        }\n        else {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            $$.fragment && $$.fragment.c();\n        }\n        if (options.intro)\n            transition_in(component.$$.fragment);\n        mount_component(component, options.target, options.anchor, options.customElement);\n        end_hydrating();\n        flush();\n    }\n    set_current_component(parent_component);\n}\nlet SvelteElement;\nif (typeof HTMLElement === 'function') {\n    SvelteElement = class extends HTMLElement {\n        constructor() {\n            super();\n            this.attachShadow({ mode: 'open' });\n        }\n        connectedCallback() {\n            const { on_mount } = this.$$;\n            this.$$.on_disconnect = on_mount.map(run).filter(is_function);\n            // @ts-ignore todo: improve typings\n            for (const key in this.$$.slotted) {\n                // @ts-ignore todo: improve typings\n                this.appendChild(this.$$.slotted[key]);\n            }\n        }\n        attributeChangedCallback(attr, _oldValue, newValue) {\n            this[attr] = newValue;\n        }\n        disconnectedCallback() {\n            run_all(this.$$.on_disconnect);\n        }\n        $destroy() {\n            destroy_component(this, 1);\n            this.$destroy = noop;\n        }\n        $on(type, callback) {\n            // TODO should this delegate to addEventListener?\n            const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n            callbacks.push(callback);\n            return () => {\n                const index = callbacks.indexOf(callback);\n                if (index !== -1)\n                    callbacks.splice(index, 1);\n            };\n        }\n        $set($$props) {\n            if (this.$$set && !is_empty($$props)) {\n                this.$$.skip_bound = true;\n                this.$$set($$props);\n                this.$$.skip_bound = false;\n            }\n        }\n    };\n}\n/**\n * Base class for Svelte components. Used when dev=false.\n */\nclass SvelteComponent {\n    $destroy() {\n        destroy_component(this, 1);\n        this.$destroy = noop;\n    }\n    $on(type, callback) {\n        const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n        callbacks.push(callback);\n        return () => {\n            const index = callbacks.indexOf(callback);\n            if (index !== -1)\n                callbacks.splice(index, 1);\n        };\n    }\n    $set($$props) {\n        if (this.$$set && !is_empty($$props)) {\n            this.$$.skip_bound = true;\n            this.$$set($$props);\n            this.$$.skip_bound = false;\n        }\n    }\n}\n\nfunction dispatch_dev(type, detail) {\n    document.dispatchEvent(custom_event(type, Object.assign({ version: '3.49.0' }, detail), { bubbles: true }));\n}\nfunction append_dev(target, node) {\n    dispatch_dev('SvelteDOMInsert', { target, node });\n    append(target, node);\n}\nfunction append_hydration_dev(target, node) {\n    dispatch_dev('SvelteDOMInsert', { target, node });\n    append_hydration(target, node);\n}\nfunction insert_dev(target, node, anchor) {\n    dispatch_dev('SvelteDOMInsert', { target, node, anchor });\n    insert(target, node, anchor);\n}\nfunction insert_hydration_dev(target, node, anchor) {\n    dispatch_dev('SvelteDOMInsert', { target, node, anchor });\n    insert_hydration(target, node, anchor);\n}\nfunction detach_dev(node) {\n    dispatch_dev('SvelteDOMRemove', { node });\n    detach(node);\n}\nfunction detach_between_dev(before, after) {\n    while (before.nextSibling && before.nextSibling !== after) {\n        detach_dev(before.nextSibling);\n    }\n}\nfunction detach_before_dev(after) {\n    while (after.previousSibling) {\n        detach_dev(after.previousSibling);\n    }\n}\nfunction detach_after_dev(before) {\n    while (before.nextSibling) {\n        detach_dev(before.nextSibling);\n    }\n}\nfunction listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {\n    const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];\n    if (has_prevent_default)\n        modifiers.push('preventDefault');\n    if (has_stop_propagation)\n        modifiers.push('stopPropagation');\n    dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });\n    const dispose = listen(node, event, handler, options);\n    return () => {\n        dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });\n        dispose();\n    };\n}\nfunction attr_dev(node, attribute, value) {\n    attr(node, attribute, value);\n    if (value == null)\n        dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });\n    else\n        dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });\n}\nfunction prop_dev(node, property, value) {\n    node[property] = value;\n    dispatch_dev('SvelteDOMSetProperty', { node, property, value });\n}\nfunction dataset_dev(node, property, value) {\n    node.dataset[property] = value;\n    dispatch_dev('SvelteDOMSetDataset', { node, property, value });\n}\nfunction set_data_dev(text, data) {\n    data = '' + data;\n    if (text.wholeText === data)\n        return;\n    dispatch_dev('SvelteDOMSetData', { node: text, data });\n    text.data = data;\n}\nfunction validate_each_argument(arg) {\n    if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {\n        let msg = '{#each} only iterates over array-like objects.';\n        if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {\n            msg += ' You can use a spread to convert this iterable into an array.';\n        }\n        throw new Error(msg);\n    }\n}\nfunction validate_slots(name, slot, keys) {\n    for (const slot_key of Object.keys(slot)) {\n        if (!~keys.indexOf(slot_key)) {\n            console.warn(`<${name}> received an unexpected slot \"${slot_key}\".`);\n        }\n    }\n}\nfunction validate_dynamic_element(tag) {\n    const is_string = typeof tag === 'string';\n    if (tag && !is_string) {\n        throw new Error('<svelte:element> expects \"this\" attribute to be a string.');\n    }\n}\nfunction validate_void_dynamic_element(tag) {\n    if (tag && is_void(tag)) {\n        throw new Error(`<svelte:element this=\"${tag}\"> is self-closing and cannot have content.`);\n    }\n}\n/**\n * Base class for Svelte components with some minor dev-enhancements. Used when dev=true.\n */\nclass SvelteComponentDev extends SvelteComponent {\n    constructor(options) {\n        if (!options || (!options.target && !options.$$inline)) {\n            throw new Error(\"'target' is a required option\");\n        }\n        super();\n    }\n    $destroy() {\n        super.$destroy();\n        this.$destroy = () => {\n            console.warn('Component was already destroyed'); // eslint-disable-line no-console\n        };\n    }\n    $capture_state() { }\n    $inject_state() { }\n}\n/**\n * Base class to create strongly typed Svelte components.\n * This only exists for typing purposes and should be used in `.d.ts` files.\n *\n * ### Example:\n *\n * You have component library on npm called `component-library`, from which\n * you export a component called `MyComponent`. For Svelte+TypeScript users,\n * you want to provide typings. Therefore you create a `index.d.ts`:\n * ```ts\n * import { SvelteComponentTyped } from \"svelte\";\n * export class MyComponent extends SvelteComponentTyped<{foo: string}> {}\n * ```\n * Typing this makes it possible for IDEs like VS Code with the Svelte extension\n * to provide intellisense and to use the component like this in a Svelte file\n * with TypeScript:\n * ```svelte\n * <script lang=\"ts\">\n * \timport { MyComponent } from \"component-library\";\n * </script>\n * <MyComponent foo={'bar'} />\n * ```\n *\n * #### Why not make this part of `SvelteComponent(Dev)`?\n * Because\n * ```ts\n * class ASubclassOfSvelteComponent extends SvelteComponent<{foo: string}> {}\n * const component: typeof SvelteComponent = ASubclassOfSvelteComponent;\n * ```\n * will throw a type error, so we need to separate the more strictly typed class.\n */\nclass SvelteComponentTyped extends SvelteComponentDev {\n    constructor(options) {\n        super(options);\n    }\n}\nfunction loop_guard(timeout) {\n    const start = Date.now();\n    return () => {\n        if (Date.now() - start > timeout) {\n            throw new Error('Infinite loop detected');\n        }\n    };\n}\n\nexport { HtmlTag, HtmlTagHydration, SvelteComponent, SvelteComponentDev, SvelteComponentTyped, SvelteElement, action_destroyer, add_attribute, add_classes, add_flush_callback, add_location, add_render_callback, add_resize_listener, add_styles, add_transform, afterUpdate, append, append_dev, append_empty_stylesheet, append_hydration, append_hydration_dev, append_styles, assign, attr, attr_dev, attribute_to_object, beforeUpdate, bind, binding_callbacks, blank_object, bubble, check_outros, children, claim_component, claim_element, claim_html_tag, claim_space, claim_svg_element, claim_text, clear_loops, component_subscribe, compute_rest_props, compute_slots, createEventDispatcher, create_animation, create_bidirectional_transition, create_component, create_in_transition, create_out_transition, create_slot, create_ssr_component, current_component, custom_event, dataset_dev, debug, destroy_block, destroy_component, destroy_each, detach, detach_after_dev, detach_before_dev, detach_between_dev, detach_dev, dirty_components, dispatch_dev, each, element, element_is, empty, end_hydrating, escape, escape_attribute_value, escape_object, exclude_internal_props, fix_and_destroy_block, fix_and_outro_and_destroy_block, fix_position, flush, getAllContexts, getContext, get_all_dirty_from_scope, get_binding_group_value, get_current_component, get_custom_elements_slots, get_root_for_style, get_slot_changes, get_spread_object, get_spread_update, get_store_value, globals, group_outros, handle_promise, hasContext, has_prop, identity, init, insert, insert_dev, insert_hydration, insert_hydration_dev, intros, invalid_attribute_name_character, is_client, is_crossorigin, is_empty, is_function, is_promise, is_void, listen, listen_dev, loop, loop_guard, merge_ssr_styles, missing_component, mount_component, noop, not_equal, now, null_to_empty, object_without_properties, onDestroy, onMount, once, outro_and_destroy_block, prevent_default, prop_dev, query_selector_all, raf, run, run_all, safe_not_equal, schedule_update, select_multiple_value, select_option, select_options, select_value, self, setContext, set_attributes, set_current_component, set_custom_element_data, set_data, set_data_dev, set_input_type, set_input_value, set_now, set_raf, set_store_value, set_style, set_svg_attributes, space, spread, src_url_equal, start_hydrating, stop_propagation, subscribe, svg_element, text, tick, time_ranges_to_array, to_number, toggle_class, transition_in, transition_out, trusted, update_await_block_branch, update_keyed_each, update_slot, update_slot_base, validate_component, validate_dynamic_element, validate_each_argument, validate_each_keys, validate_slots, validate_store, validate_void_dynamic_element, xlink_attr };\n","<script lang=\"ts\">\n  import { createEventDispatcher } from \"svelte\";\n\n  export let popup: string;\n  export let disabled = false;\n\n  const dispatcher = createEventDispatcher();\n  const handleClick = () => {\n    dispatcher(\"click\");\n  };\n</script>\n\n<button\n  aria-label={popup}\n  class:mod-cta={!disabled}\n  {disabled}\n  on:click={handleClick}\n>\n  <slot />\n</button>\n","<script>\n  export let size = 24\n</script>\n<svg\n  xmlns=\"http://www.w3.org/2000/svg\"\n  width={size}\n  height={size}\n  viewBox=\"0 0 24 24\"\n  fill=\"none\"\n  stroke=\"currentColor\"\n  stroke-width=\"2\"\n  stroke-linecap=\"round\"\n  stroke-linejoin=\"round\"\n  {...$$restProps}\n>\n  <slot />\n  <path d=\"M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z\" />\n  <polyline points=\"14 2 14 8 20 8\" />\n</svg>","<script lang=\"ts\">\n  import { createEventDispatcher } from \"svelte\";\n\n  export let popup: string;\n  export let disabled = false;\n\n  const dispatcher = createEventDispatcher();\n  const handleClick = () => {\n    if (!disabled) {\n      dispatcher(\"click\");\n    }\n  };\n</script>\n\n<div class=\"wrapper\">\n  <button\n    aria-label={popup}\n    {disabled}\n    on:click={handleClick}\n    class={disabled ? \"button-disabled\" : \"button-enabled\"}\n    style=\"background-color: transparent; padding: 0\"\n  >\n    <slot />\n  </button>\n</div>\n\n<style>\n  .wrapper {\n    display: flex;\n    justify-content: center;\n    margin: 0;\n  }\n  .button-enabled:hover {\n    /*noinspection CssUnresolvedCustomProperty*/\n    color: var(--interactive-accent);\n  }\n  .button-disabled {\n    /*noinspection CssUnresolvedCustomProperty*/\n    color: var(--text-muted);\n  }\n</style>\n","<!--suppress LabeledStatementJS -->\n<script lang=\"ts\">\n  import ObsidianButton from \"./ObsidianButton.svelte\";\n  import { File } from \"svelte-lucide-icons\";\n  import ObsidianIconButton from \"./ObsidianIconButton.svelte\";\n  import type { CustomDictionaryWord } from \"../../model/Word\";\n  import { onMount } from \"svelte\";\n\n  type Dictionary = {\n    id: string;\n    path: string;\n  };\n\n  export let dictionaries: Dictionary[];\n  export let selectedDictionary: Dictionary;\n  export let inputWord: string = \"\";\n  export let useDisplayedWord = false;\n  export let displayedWord: string = \"\";\n  export let description: string = \"\";\n  export let aliases: string[] = [];\n  export let dividerForDisplay = \"\";\n\n  export let onSubmit: (\n    dictionaryPath: string,\n    word: CustomDictionaryWord\n  ) => void;\n  export let onClickFileIcon: (dictionaryPath: string) => void;\n\n  let aliasesStr = aliases.join(\"\\n\");\n  let wordRef = null;\n  let displayedWordRef = null;\n\n  $: enableSubmit = inputWord.length > 0;\n  $: enableDisplayedWord = Boolean(dividerForDisplay);\n  $: firstWordTitle = useDisplayedWord ? \"Inserted word\" : \"Word\";\n  $: {\n    if (useDisplayedWord) {\n      displayedWordRef?.focus();\n    }\n  }\n\n  const handleSubmit = () => {\n    onSubmit(selectedDictionary.path, {\n      value: displayedWord || inputWord,\n      description,\n      aliases: aliasesStr.split(\"\\n\"),\n      type: \"customDictionary\",\n      createdPath: selectedDictionary.path,\n      insertedText: displayedWord ? inputWord : undefined,\n    });\n  };\n\n  onMount(() => {\n    setTimeout(() => wordRef.focus(), 50);\n  });\n</script>\n\n<div>\n  <h2>Add a word to a custom dictionary</h2>\n\n  <h3>Dictionary</h3>\n  <div style=\"display: flex; gap: 10px\">\n    <select bind:value={selectedDictionary} class=\"dropdown\">\n      {#each dictionaries as dictionary}\n        <option value={dictionary}>\n          {dictionary.path}\n        </option>\n      {/each}\n    </select>\n    <ObsidianIconButton\n      popup=\"Open the file\"\n      on:click={() => onClickFileIcon(selectedDictionary.path)}\n    >\n      <File />\n    </ObsidianIconButton>\n  </div>\n\n  <h3>{firstWordTitle}</h3>\n  <textarea\n    bind:value={inputWord}\n    style=\"width: 100%;\"\n    rows=\"3\"\n    bind:this={wordRef}\n  />\n\n  {#if enableDisplayedWord}\n    <label>\n      <input type=\"checkbox\" bind:checked={useDisplayedWord} />\n      Distinguish between display and insertion\n    </label>\n  {/if}\n\n  {#if useDisplayedWord}\n    <h3>Displayed Word</h3>\n    <textarea\n      bind:value={displayedWord}\n      style=\"width: 100%;\"\n      rows=\"3\"\n      bind:this={displayedWordRef}\n    />\n  {/if}\n\n  <h3>Description</h3>\n  <input type=\"text\" bind:value={description} style=\"width: 100%;\" />\n\n  <h3>Aliases (for each line)</h3>\n  <textarea bind:value={aliasesStr} style=\"width: 100%;\" rows=\"3\" />\n\n  <div style=\"text-align: center; width: 100%; padding-top: 15px;\">\n    <ObsidianButton disabled={!enableSubmit} on:click={handleSubmit}\n      >Submit</ObsidianButton\n    >\n  </div>\n</div>\n\n<style>\n</style>\n","import { App, Modal, Notice } from \"obsidian\";\nimport { AppHelper } from \"../app-helper\";\nimport type { CustomDictionaryWord } from \"../model/Word\";\nimport CustomDictionaryWordAdd from \"./component/CustomDictionaryWordAdd.svelte\";\n\nexport class CustomDictionaryWordAddModal extends Modal {\n  component: CustomDictionaryWordAdd;\n\n  constructor(\n    app: App,\n    dictionaryPaths: string[],\n    initialValue: string = \"\",\n    dividerForDisplay: string = \"\",\n    onSubmit: (dictionaryPath: string, word: CustomDictionaryWord) => void\n  ) {\n    super(app);\n    const appHelper = new AppHelper(app);\n\n    const dictionaries = dictionaryPaths.map((x) => ({ id: x, path: x }));\n\n    const { contentEl } = this;\n    this.component = new CustomDictionaryWordAdd({\n      target: contentEl,\n      props: {\n        dictionaries,\n        selectedDictionary: dictionaries[0],\n        inputWord: initialValue,\n        dividerForDisplay,\n        onSubmit,\n        onClickFileIcon: (dictionaryPath: string) => {\n          const markdownFile = appHelper.getMarkdownFileByPath(dictionaryPath);\n          if (!markdownFile) {\n            // noinspection ObjectAllocationIgnored\n            new Notice(`Can't open ${dictionaryPath}`);\n            return;\n          }\n\n          this.close();\n          appHelper.openMarkdownFile(markdownFile, true);\n        },\n      },\n    });\n  }\n\n  onClose() {\n    super.onClose();\n    this.component.$destroy();\n  }\n}\n","import { debounce, Notice, Plugin } from \"obsidian\";\nimport { AutoCompleteSuggest } from \"./ui/AutoCompleteSuggest\";\nimport {\n  DEFAULT_SETTINGS,\n  type Settings,\n  VariousComplementsSettingTab,\n} from \"./setting/settings\";\nimport { AppHelper } from \"./app-helper\";\nimport { ProviderStatusBar } from \"./ui/ProviderStatusBar\";\nimport { CustomDictionaryWordAddModal } from \"./ui/CustomDictionaryWordAddModal\";\n\nexport default class VariousComponents extends Plugin {\n  appHelper: AppHelper;\n  settings: Settings;\n  settingTab: VariousComplementsSettingTab;\n  suggester: AutoCompleteSuggest;\n  statusBar?: ProviderStatusBar;\n\n  onunload() {\n    super.onunload();\n    this.suggester.unregister();\n  }\n\n  async onload() {\n    this.appHelper = new AppHelper(this.app);\n\n    this.registerEvent(\n      this.app.workspace.on(\"editor-menu\", (menu) => {\n        if (!this.appHelper.getSelection()) {\n          return;\n        }\n\n        menu.addItem((item) =>\n          item\n            .setTitle(\"Add to custom dictionary\")\n            .setIcon(\"stacked-levels\")\n            .onClick(() => {\n              this.addWordToCustomDictionary();\n            })\n        );\n      })\n    );\n\n    await this.loadSettings();\n\n    this.settingTab = new VariousComplementsSettingTab(this.app, this);\n    this.addSettingTab(this.settingTab);\n\n    this.statusBar = ProviderStatusBar.new(\n      this.addStatusBarItem(),\n      this.settings.showMatchStrategy,\n      this.settings.showIndexingStatus,\n      this.settings.showComplementAutomatically\n    );\n    this.statusBar.setOnClickStrategyListener(async () => {\n      await this.settingTab.toggleMatchStrategy();\n    });\n    this.statusBar.setOnClickComplementAutomatically(async () => {\n      await this.settingTab.toggleComplementAutomatically();\n    });\n\n    const debouncedSaveData = debounce(async () => {\n      await this.saveData(this.settings);\n    }, 5000);\n\n    this.suggester = await AutoCompleteSuggest.new(\n      this.app,\n      this.settings,\n      this.statusBar,\n      debouncedSaveData\n    );\n    this.registerEditorSuggest(this.suggester);\n\n    this.addCommand({\n      id: \"reload-custom-dictionaries\",\n      name: \"Reload custom dictionaries\",\n      hotkeys: [{ modifiers: [\"Mod\", \"Shift\"], key: \"r\" }],\n      callback: async () => {\n        await this.suggester.refreshCustomDictionaryTokens();\n      },\n    });\n\n    this.addCommand({\n      id: \"reload-current-vault\",\n      name: \"Reload current vault\",\n      callback: async () => {\n        await this.suggester.refreshCurrentVaultTokens();\n      },\n    });\n\n    this.addCommand({\n      id: \"toggle-match-strategy\",\n      name: \"Toggle Match strategy\",\n      callback: async () => {\n        await this.settingTab.toggleMatchStrategy();\n      },\n    });\n\n    this.addCommand({\n      id: \"toggle-complement-automatically\",\n      name: \"Toggle Complement automatically\",\n      callback: async () => {\n        await this.settingTab.toggleComplementAutomatically();\n      },\n    });\n\n    this.addCommand({\n      id: \"show-suggestions\",\n      name: \"Show suggestions\",\n      hotkeys: [{ modifiers: [\"Mod\"], key: \" \" }],\n      callback: async () => {\n        this.suggester.triggerComplete();\n      },\n    });\n\n    this.addCommand({\n      id: \"add-word-custom-dictionary\",\n      name: \"Add a word to a custom dictionary\",\n      hotkeys: [{ modifiers: [\"Mod\", \"Shift\"], key: \" \" }],\n      callback: async () => {\n        this.addWordToCustomDictionary();\n      },\n    });\n\n    this.addCommand({\n      id: \"predictable-complements\",\n      name: \"Predictable complement\",\n      callback: async () => {\n        this.suggester.predictableComplete();\n      },\n    });\n\n    this.addCommand({\n      id: \"copy-plugin-settings\",\n      name: \"Copy plugin settings\",\n      callback: async () => {\n        await navigator.clipboard.writeText(\n          this.settingTab.getPluginSettingsAsJsonString()\n        );\n        // noinspection ObjectAllocationIgnored\n        new Notice(\"Copy settings of Various Complements\");\n      },\n    });\n  }\n\n  async loadSettings(): Promise<void> {\n    this.settings = { ...DEFAULT_SETTINGS, ...(await this.loadData()) };\n  }\n\n  async saveSettings(\n    needUpdateTokens: {\n      currentFile?: boolean;\n      currentVault?: boolean;\n      customDictionary?: boolean;\n      internalLink?: boolean;\n      frontMatter?: boolean;\n    } = {}\n  ): Promise<void> {\n    await this.saveData(this.settings);\n    await this.suggester.updateSettings(this.settings);\n    if (needUpdateTokens.currentFile) {\n      await this.suggester.refreshCurrentFileTokens();\n    }\n    if (needUpdateTokens.currentVault) {\n      await this.suggester.refreshCurrentVaultTokens();\n    }\n    if (needUpdateTokens.customDictionary) {\n      await this.suggester.refreshCustomDictionaryTokens();\n    }\n    if (needUpdateTokens.internalLink) {\n      await this.suggester.refreshInternalLinkTokens();\n    }\n    if (needUpdateTokens.frontMatter) {\n      await this.suggester.refreshFrontMatterTokens();\n    }\n  }\n\n  addWordToCustomDictionary() {\n    const selectedWord = this.appHelper.getSelection();\n    const provider = this.suggester.customDictionaryWordProvider;\n    const modal = new CustomDictionaryWordAddModal(\n      this.app,\n      provider.editablePaths,\n      selectedWord,\n      this.settings.delimiterToDivideSuggestionsForDisplayFromInsertion,\n      async (dictionaryPath, _word) => {\n        // TODO: If support for JSON, this implementation doesn't work correctly\n        const word = {\n          ..._word,\n          caretSymbol: this.settings.caretLocationSymbolAfterComplement,\n        };\n\n        if (provider.wordByValue[word.value]) {\n          // noinspection ObjectAllocationIgnored\n          new Notice(`⚠ ${word.value} already exists`, 0);\n          return;\n        }\n\n        await provider.addWordWithDictionary(word, dictionaryPath);\n        // noinspection ObjectAllocationIgnored\n        new Notice(`Added ${word.value}`);\n        modal.close();\n      }\n    );\n\n    modal.open();\n  }\n}\n"],"names":["prettify","Trie","require$$0","require$$1","Cedict","chineseTokenizer","parseFrontMatterAliases","parseFrontMatterTags","parseFrontMatterStringArray","MarkdownView","normalizePath","synonymAliases","request","Notice","EditorSuggest","debounce","PluginSettingTab","Setting","Modal","Plugin"],"mappings":"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AG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACtB,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5C,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5C,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5C,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5C,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;AAClC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AACvC,QAAA,KAAK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"} diff --git a/notes/.obsidian/plugins/various-complements/manifest.json b/notes/.obsidian/plugins/various-complements/manifest.json new file mode 100644 index 0000000..7b52509 --- /dev/null +++ b/notes/.obsidian/plugins/various-complements/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "various-complements", + "name": "Various Complements", + "version": "7.1.1", + "minAppVersion": "0.15.4", + "description": "This plugin enables you to complete words like the auto-completion of IDE", + "author": "tadashi-aikawa", + "authorUrl": "https://github.com/tadashi-aikawa", + "isDesktopOnly": false +} diff --git a/notes/.obsidian/plugins/various-complements/styles.css b/notes/.obsidian/plugins/various-complements/styles.css new file mode 100644 index 0000000..928271a --- /dev/null +++ b/notes/.obsidian/plugins/various-complements/styles.css @@ -0,0 +1,141 @@ +.various-complements__settings__text-area-path { + height: 120px; + width: 500px; +} + +.various-complements__settings__current-settings-json { + font-size: 0.75em; + height: 800px; + width: 500px; +} + +.various-complements__settings__warning { + color: darkorange; + text-align: right; +} + +.various-complements__settings__header { + position: relative; + padding-left: 25px; +} +.various-complements__settings__header::before { + position: absolute; + width: 20px; + margin-top: 3px; + margin-left: -25px; + filter: invert(0.5) hue-rotate(180deg); +} + +.various-complements__settings__header__current-file::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTYgMTYiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik01IDFhMiAyIDAgMCAwLTIgMnY5Ljk5OGEyIDIgMCAwIDAgMiAyaDEuMDQ2bC4yNS0xSDVhMSAxIDAgMCAxLTEtMVYzYTEgMSAwIDAgMSAxLTFoM3YyLjVBMS41IDEuNSAwIDAgMCA5LjQ5OCA2aDIuNXYxLjQ0Yy4zMDYtLjIwOS42NDctLjM0NCAxLS40MDVWNS40MTNhMS41IDEuNSAwIDAgMC0uNDQtMS4wNkw5LjY0NSAxLjQzOUExLjUgMS41IDAgMCAwIDguNTg1IDFINXptNi43OTEgNEg5LjVhLjUuNSAwIDAgMS0uNS0uNVYyLjIwNmwyLjc5MiAyLjc5MnptMS4yMDcgMy4wNmMtLjI0Mi4wNzEtLjQ3LjIwMy0uNjYyLjM5NEw4LjA1IDEyLjc0YTIuNzc3IDIuNzc3IDAgMCAwLS43MjIgMS4yNTdsLS4wMDkuMDMzbC0uMzAyIDEuMjExYS42MS42MSAwIDAgMCAuNzM4Ljc0bDEuMjExLS4zMDNhMi43NzYgMi43NzYgMCAwIDAgMS4yOS0uNzNsNC4yODgtNC4yODhhMS41NiAxLjU2IDAgMCAwLTEuNTQ1LTIuNnoiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} +.various-complements__settings__header__current-vault::before { + content: url("data:image/svg+xml;base64,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") +} +.various-complements__settings__header__custom-dictionary::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiI+PHJlY3QgeD0iMzIiIHk9Ijk2IiB3aWR0aD0iNjQiIGhlaWdodD0iMzY4IiByeD0iMTYiIHJ5PSIxNiIgZmlsbD0ibm9uZSIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMzIiPjwvcmVjdD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDIyNGgxMjgiPjwvcGF0aD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDQwMGgxMjgiPjwvcGF0aD48cmVjdCB4PSIxMTIiIHk9IjE2MCIgd2lkdGg9IjEyOCIgaGVpZ2h0PSIzMDQiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxyZWN0IHg9IjI1NiIgeT0iNDgiIHdpZHRoPSI5NiIgaGVpZ2h0PSI0MTYiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxwYXRoIGQ9Ik00MjIuNDYgOTYuMTFsLTQwLjQgNC4yNWMtMTEuMTIgMS4xNy0xOS4xOCAxMS41Ny0xNy45MyAyMy4xbDM0LjkyIDMyMS41OWMxLjI2IDExLjUzIDExLjM3IDIwIDIyLjQ5IDE4Ljg0bDQwLjQtNC4yNWMxMS4xMi0xLjE3IDE5LjE4LTExLjU3IDE3LjkzLTIzLjFMNDQ1IDExNWMtMS4zMS0xMS41OC0xMS40Mi0yMC4wNi0yMi41NC0xOC44OXoiIGZpbGw9Im5vbmUiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIj48L3BhdGg+PC9zdmc+") +} +.various-complements__settings__header__internal-link::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0iY3VycmVudENvbG9yIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgZD0iTTEyLDBDNS40LDAsMCw1LjQsMCwxMnM1LjQsMTIsMTIsMTJjMi42LDAsNS0wLjgsNi45LTIuMmwxNS42LDE1LjZDMzEuNyw0MC44LDMwLDQ1LjIsMzAsNTBjMCw0LDEuMiw3LjYsMy4yLDEwLjcgTDIwLjEsNzEuMWMtMi4xLTEuOS01LTMuMS04LjEtMy4xQzUuNCw2OCwwLDczLjQsMCw4MHM1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyYzAtMi4xLTAuNS00LTEuNS01LjhsMTMuMi0xMC40IEMzOS4zLDY3LjYsNDQuNCw3MCw1MCw3MGMyLjcsMCw1LjItMC41LDcuNS0xLjRsNS4zLDkuOUM1OS45LDgwLjcsNTgsODQuMSw1OCw4OGMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEycy01LjQtMTItMTItMTIgYy0xLjMsMC0yLjYsMC4yLTMuOCwwLjZMNjEsNjYuN2MzLjgtMi41LDYuNy02LjIsOC4xLTEwLjZsNi45LDEuNGMwLDAuMiwwLDAuMywwLDAuNWMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyIGMwLTYuNi01LjQtMTItMTItMTJjLTUuMSwwLTkuNCwzLjItMTEuMiw3LjZsLTYuOS0xLjVjMC4xLTAuNywwLjEtMS40LDAuMS0yLjFjMC03LjktNC42LTE0LjctMTEuMy0xNy45bDMuMS04LjIgYzAuNywwLjEsMS41LDAuMiwyLjIsMC4yYzYuNiwwLDEyLTUuNCwxMi0xMlM3MC42LDAsNjQsMFM1Miw1LjQsNTIsMTJjMCw0LjQsMi41LDguMyw2LjEsMTAuNEw1NSwzMC43Yy0xLjYtMC40LTMuMy0wLjctNS0wLjcgYy00LjgsMC05LjIsMS43LTEyLjYsNC41TDIxLjgsMTguOWMxLjQtMiwyLjItNC40LDIuMi02LjlDMjQsNS40LDE4LjYsMCwxMiwwTDEyLDB6IE0xMiw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LTggUzcuNiw0LDEyLDR6IE02NCw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LThTNTkuNiw0LDY0LDR6IE01MCwzNGM4LjksMCwxNiw3LjEsMTYsMTZjMCw4LjktNy4xLDE2LTE2LDE2IGMtOC45LDAtMTYtNy4xLTE2LTE2YzAtNC4zLDEuNy04LjIsNC40LTExLjFjMC4yLTAuMSwwLjMtMC4zLDAuNC0wLjRDNDEuOCwzNS43LDQ1LjcsMzQsNTAsMzR6IE04OCw1MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhzLTgtMy42LTgtOFM4My42LDUwLDg4LDUweiBNMTIsNzJjNC40LDAsOCwzLjYsOCw4cy0zLjYsOC04LDhzLTgtMy42LTgtOFM3LjYsNzIsMTIsNzJ6IE03MCw4MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhjLTQuNCwwLTgtMy42LTgtOGMwLTMsMS43LTUuNiw0LjEtN2MwLjEsMCwwLjEsMCwwLjItMC4xYzAsMCwwLDAsMC4xLTAuMWMwLDAsMC4xLDAsMC4xLTAuMUM2Ny42LDgwLjMsNjguNyw4MCw3MCw4MHogIj48L3BhdGg+PC9zdmc+") +} +.various-complements__settings__header__front-matter::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMjAgMjAiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik0xMC4zMiAyLjAxM0E0IDQgMCAwIDAgNi4xNjIgNy4xM2wtMy45ODcgMy45ODZhLjYuNiAwIDAgMC0uMTc2LjQyNFYxNC40YS42LjYgMCAwIDAgLjYuNmgyLjhhLjYuNiAwIDAgMCAuNi0uNlYxM2gxLjlhLjYuNiAwIDAgMCAuNi0uNnYtMS42OTNsLjczNS0uNzM1YTUuNTEgNS41MSAwIDAgMS0uNTY5LS44NDZsLS45OS45OTFhLjYuNiAwIDAgMC0uMTc2LjQyNFYxMkg1LjZhLjYuNiAwIDAgMC0uNi42VjE0SDN2LTIuMjkzbDQuMzItNC4zMmwtLjExOC0uMzAzYTMuMDAxIDMuMDAxIDAgMCAxIDEuOTYtMy45NjVjLjMzLS40MjMuNzItLjc5NiAxLjE1Ny0xLjEwNnpNMTMuNSA2LjI1YS43NS43NSAwIDEgMCAwLTEuNWEuNzUuNzUgMCAwIDAgMCAxLjV6TTkgNi41YTQuNSA0LjUgMCAxIDEgNyAzLjc0MnYyLjA1bC43ODMuNzg0YS42LjYgMCAwIDEgMCAuODQ4TDE1LjcwNyAxNWwxLjA2OCAxLjA2N2EuNi42IDAgMCAxLS4wNS44OTNsLTIuMzUgMS44OGEuNi42IDAgMCAxLS43NSAwbC0yLjQtMS45MmEuNi42IDAgMCAxLS4yMjUtLjQ2OHYtNi4yMUE0LjQ5NiA0LjQ5NiAwIDAgMSA5IDYuNXpNMTMuNSAzYTMuNSAzLjUgMCAwIDAtMS43NSA2LjUzMmEuNS41IDAgMCAxIC4yNS40MzN2Ni4yOTVsMiAxLjZsMS43NTEtMS40MDFsLTEuMDM0LTEuMDM1YS42LjYgMCAwIDEgMC0uODQ4bDEuMDc2LTEuMDc2bC0uNjE3LS42MTdhLjYuNiAwIDAgMS0uMTc2LS40MjRWOS45NjVhLjUuNSAwIDAgMSAuMjUtLjQzM0EzLjUgMy41IDAgMCAwIDEzLjUgM3oiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} + +.various-complements__footer { + position: relative; + padding-left: 15px; + margin-left: 15px; +} +.various-complements__footer::before { + position: absolute; + width: 13px; + margin-top: 1px; + margin-left: -15px; + filter: invert(0.5) hue-rotate(180deg); +} +.various-complements__footer__current-file::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTYgMTYiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik01IDFhMiAyIDAgMCAwLTIgMnY5Ljk5OGEyIDIgMCAwIDAgMiAyaDEuMDQ2bC4yNS0xSDVhMSAxIDAgMCAxLTEtMVYzYTEgMSAwIDAgMSAxLTFoM3YyLjVBMS41IDEuNSAwIDAgMCA5LjQ5OCA2aDIuNXYxLjQ0Yy4zMDYtLjIwOS42NDctLjM0NCAxLS40MDVWNS40MTNhMS41IDEuNSAwIDAgMC0uNDQtMS4wNkw5LjY0NSAxLjQzOUExLjUgMS41IDAgMCAwIDguNTg1IDFINXptNi43OTEgNEg5LjVhLjUuNSAwIDAgMS0uNS0uNVYyLjIwNmwyLjc5MiAyLjc5MnptMS4yMDcgMy4wNmMtLjI0Mi4wNzEtLjQ3LjIwMy0uNjYyLjM5NEw4LjA1IDEyLjc0YTIuNzc3IDIuNzc3IDAgMCAwLS43MjIgMS4yNTdsLS4wMDkuMDMzbC0uMzAyIDEuMjExYS42MS42MSAwIDAgMCAuNzM4Ljc0bDEuMjExLS4zMDNhMi43NzYgMi43NzYgMCAwIDAgMS4yOS0uNzNsNC4yODgtNC4yODhhMS41NiAxLjU2IDAgMCAwLTEuNTQ1LTIuNnoiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} +.various-complements__footer__current-vault::before { + content: url("data:image/svg+xml;base64,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") +} +.various-complements__footer__custom-dictionary::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiI+PHJlY3QgeD0iMzIiIHk9Ijk2IiB3aWR0aD0iNjQiIGhlaWdodD0iMzY4IiByeD0iMTYiIHJ5PSIxNiIgZmlsbD0ibm9uZSIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMzIiPjwvcmVjdD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDIyNGgxMjgiPjwvcGF0aD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDQwMGgxMjgiPjwvcGF0aD48cmVjdCB4PSIxMTIiIHk9IjE2MCIgd2lkdGg9IjEyOCIgaGVpZ2h0PSIzMDQiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxyZWN0IHg9IjI1NiIgeT0iNDgiIHdpZHRoPSI5NiIgaGVpZ2h0PSI0MTYiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxwYXRoIGQ9Ik00MjIuNDYgOTYuMTFsLTQwLjQgNC4yNWMtMTEuMTIgMS4xNy0xOS4xOCAxMS41Ny0xNy45MyAyMy4xbDM0LjkyIDMyMS41OWMxLjI2IDExLjUzIDExLjM3IDIwIDIyLjQ5IDE4Ljg0bDQwLjQtNC4yNWMxMS4xMi0xLjE3IDE5LjE4LTExLjU3IDE3LjkzLTIzLjFMNDQ1IDExNWMtMS4zMS0xMS41OC0xMS40Mi0yMC4wNi0yMi41NC0xOC44OXoiIGZpbGw9Im5vbmUiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIj48L3BhdGg+PC9zdmc+") +} +.various-complements__footer__internal-link::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0iY3VycmVudENvbG9yIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgZD0iTTEyLDBDNS40LDAsMCw1LjQsMCwxMnM1LjQsMTIsMTIsMTJjMi42LDAsNS0wLjgsNi45LTIuMmwxNS42LDE1LjZDMzEuNyw0MC44LDMwLDQ1LjIsMzAsNTBjMCw0LDEuMiw3LjYsMy4yLDEwLjcgTDIwLjEsNzEuMWMtMi4xLTEuOS01LTMuMS04LjEtMy4xQzUuNCw2OCwwLDczLjQsMCw4MHM1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyYzAtMi4xLTAuNS00LTEuNS01LjhsMTMuMi0xMC40IEMzOS4zLDY3LjYsNDQuNCw3MCw1MCw3MGMyLjcsMCw1LjItMC41LDcuNS0xLjRsNS4zLDkuOUM1OS45LDgwLjcsNTgsODQuMSw1OCw4OGMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEycy01LjQtMTItMTItMTIgYy0xLjMsMC0yLjYsMC4yLTMuOCwwLjZMNjEsNjYuN2MzLjgtMi41LDYuNy02LjIsOC4xLTEwLjZsNi45LDEuNGMwLDAuMiwwLDAuMywwLDAuNWMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyIGMwLTYuNi01LjQtMTItMTItMTJjLTUuMSwwLTkuNCwzLjItMTEuMiw3LjZsLTYuOS0xLjVjMC4xLTAuNywwLjEtMS40LDAuMS0yLjFjMC03LjktNC42LTE0LjctMTEuMy0xNy45bDMuMS04LjIgYzAuNywwLjEsMS41LDAuMiwyLjIsMC4yYzYuNiwwLDEyLTUuNCwxMi0xMlM3MC42LDAsNjQsMFM1Miw1LjQsNTIsMTJjMCw0LjQsMi41LDguMyw2LjEsMTAuNEw1NSwzMC43Yy0xLjYtMC40LTMuMy0wLjctNS0wLjcgYy00LjgsMC05LjIsMS43LTEyLjYsNC41TDIxLjgsMTguOWMxLjQtMiwyLjItNC40LDIuMi02LjlDMjQsNS40LDE4LjYsMCwxMiwwTDEyLDB6IE0xMiw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LTggUzcuNiw0LDEyLDR6IE02NCw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LThTNTkuNiw0LDY0LDR6IE01MCwzNGM4LjksMCwxNiw3LjEsMTYsMTZjMCw4LjktNy4xLDE2LTE2LDE2IGMtOC45LDAtMTYtNy4xLTE2LTE2YzAtNC4zLDEuNy04LjIsNC40LTExLjFjMC4yLTAuMSwwLjMtMC4zLDAuNC0wLjRDNDEuOCwzNS43LDQ1LjcsMzQsNTAsMzR6IE04OCw1MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhzLTgtMy42LTgtOFM4My42LDUwLDg4LDUweiBNMTIsNzJjNC40LDAsOCwzLjYsOCw4cy0zLjYsOC04LDhzLTgtMy42LTgtOFM3LjYsNzIsMTIsNzJ6IE03MCw4MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhjLTQuNCwwLTgtMy42LTgtOGMwLTMsMS43LTUuNiw0LjEtN2MwLjEsMCwwLjEsMCwwLjItMC4xYzAsMCwwLDAsMC4xLTAuMWMwLDAsMC4xLDAsMC4xLTAuMUM2Ny42LDgwLjMsNjguNyw4MCw3MCw4MHogIj48L3BhdGg+PC9zdmc+") +} +.various-complements__footer__front-matter::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMjAgMjAiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik0xMC4zMiAyLjAxM0E0IDQgMCAwIDAgNi4xNjIgNy4xM2wtMy45ODcgMy45ODZhLjYuNiAwIDAgMC0uMTc2LjQyNFYxNC40YS42LjYgMCAwIDAgLjYuNmgyLjhhLjYuNiAwIDAgMCAuNi0uNlYxM2gxLjlhLjYuNiAwIDAgMCAuNi0uNnYtMS42OTNsLjczNS0uNzM1YTUuNTEgNS41MSAwIDAgMS0uNTY5LS44NDZsLS45OS45OTFhLjYuNiAwIDAgMC0uMTc2LjQyNFYxMkg1LjZhLjYuNiAwIDAgMC0uNi42VjE0SDN2LTIuMjkzbDQuMzItNC4zMmwtLjExOC0uMzAzYTMuMDAxIDMuMDAxIDAgMCAxIDEuOTYtMy45NjVjLjMzLS40MjMuNzItLjc5NiAxLjE1Ny0xLjEwNnpNMTMuNSA2LjI1YS43NS43NSAwIDEgMCAwLTEuNWEuNzUuNzUgMCAwIDAgMCAxLjV6TTkgNi41YTQuNSA0LjUgMCAxIDEgNyAzLjc0MnYyLjA1bC43ODMuNzg0YS42LjYgMCAwIDEgMCAuODQ4TDE1LjcwNyAxNWwxLjA2OCAxLjA2N2EuNi42IDAgMCAxLS4wNS44OTNsLTIuMzUgMS44OGEuNi42IDAgMCAxLS43NSAwbC0yLjQtMS45MmEuNi42IDAgMCAxLS4yMjUtLjQ2OHYtNi4yMUE0LjQ5NiA0LjQ5NiAwIDAgMSA5IDYuNXpNMTMuNSAzYTMuNSAzLjUgMCAwIDAtMS43NSA2LjUzMmEuNS41IDAgMCAxIC4yNS40MzN2Ni4yOTVsMiAxLjZsMS43NTEtMS40MDFsLTEuMDM0LTEuMDM1YS42LjYgMCAwIDEgMC0uODQ4bDEuMDc2LTEuMDc2bC0uNjE3LS42MTdhLjYuNiAwIDAgMS0uMTc2LS40MjRWOS45NjVhLjUuNSAwIDAgMSAuMjUtLjQzM0EzLjUgMy41IDAgMCAwIDEzLjUgM3oiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} +.various-complements__footer__match-strategy { + cursor: pointer; +} +.various-complements__footer__match-strategy::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMjQgMjQiPjxwYXRoIGQ9Ik0yMSAxMWgtMS41di0uNWgtMnYzaDJWMTNIMjF2MWMwIC41NS0uNDUgMS0xIDFoLTNjLS41NSAwLTEtLjQ1LTEtMXYtNGMwLS41NS40NS0xIDEtMWgzYy41NSAwIDEgLjQ1IDEgMXYxek04IDEwdjVINi41di0xLjVoLTJWMTVIM3YtNWMwLS41NS40NS0xIDEtMWgzYy41NSAwIDEgLjQ1IDEgMXptLTEuNS41aC0yVjEyaDJ2LTEuNXptNyAxLjVjLjU1IDAgMSAuNDUgMSAxdjFjMCAuNTUtLjQ1IDEtMSAxaC00VjloNGMuNTUgMCAxIC40NSAxIDF2MWMwIC41NS0uNDUgMS0xIDF6TTExIDEwLjV2Ljc1aDJ2LS43NWgtMnptMiAyLjI1aC0ydi43NWgydi0uNzV6IiBmaWxsPSJjdXJyZW50Q29sb3IiPjwvcGF0aD48L3N2Zz4=") +} +.various-complements__footer__complement-automatically { + cursor: pointer; +} +.various-complements__footer__complement-automatically::before { + content: url("data:image/svg+xml;base64,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") +} + + +.various-complements__suggestion-item::before { + display: inline-block; + width: 16px; + margin-top: 4px; + margin-left: -20px; + margin-right: 5px; + filter: invert(0.5) hue-rotate(180deg); +} + +.various-complements__suggestion-item { + display: flex; + align-items: start; + padding-left: 30px!important; +} + +.various-complements__suggestion-item > div { + display: inline-block; +} + +.various-complements__suggestion-item__description { + font-size: 0.75em; + /*noinspection CssUnresolvedCustomProperty*/ + color: var(--text-muted); +} + +.various-complements__suggestion-item__current-file::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTYgMTYiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik01IDFhMiAyIDAgMCAwLTIgMnY5Ljk5OGEyIDIgMCAwIDAgMiAyaDEuMDQ2bC4yNS0xSDVhMSAxIDAgMCAxLTEtMVYzYTEgMSAwIDAgMSAxLTFoM3YyLjVBMS41IDEuNSAwIDAgMCA5LjQ5OCA2aDIuNXYxLjQ0Yy4zMDYtLjIwOS42NDctLjM0NCAxLS40MDVWNS40MTNhMS41IDEuNSAwIDAgMC0uNDQtMS4wNkw5LjY0NSAxLjQzOUExLjUgMS41IDAgMCAwIDguNTg1IDFINXptNi43OTEgNEg5LjVhLjUuNSAwIDAgMS0uNS0uNVYyLjIwNmwyLjc5MiAyLjc5MnptMS4yMDcgMy4wNmMtLjI0Mi4wNzEtLjQ3LjIwMy0uNjYyLjM5NEw4LjA1IDEyLjc0YTIuNzc3IDIuNzc3IDAgMCAwLS43MjIgMS4yNTdsLS4wMDkuMDMzbC0uMzAyIDEuMjExYS42MS42MSAwIDAgMCAuNzM4Ljc0bDEuMjExLS4zMDNhMi43NzYgMi43NzYgMCAwIDAgMS4yOS0uNzNsNC4yODgtNC4yODhhMS41NiAxLjU2IDAgMCAwLTEuNTQ1LTIuNnoiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} +.various-complements__suggestion-item__current-vault::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0iY3VycmVudENvbG9yIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgZD0iTTEwLDEwYy00LjQsMC04LDMuNi04LDh2NjRjMCw0LjQsMy42LDgsOCw4aDJ2MmgxMHYtMmg1NnYyaDEwdi0yaDJjNC40LDAsOC0zLjYsOC04VjE4YzAtNC40LTMuNi04LTgtOEwxMCwxMHogTTEwLDE0aDgwIGMyLjIsMCw0LDEuOCw0LDR2NjRjMCwyLjItMS44LDQtNCw0SDEwYy0yLjIsMC00LTEuOC00LTRWMThDNiwxNS44LDcuOCwxNCwxMCwxNHogTTEzLjYsMjBjLTEsMC4yLTEuNiwxLTEuNiwydjIzLjQgYy0wLjEsMC40LTAuMSwwLjgsMCwxLjJ2Ny4xYzAsMC4xLDAsMC4xLDAsMC4yYzAsMC4xLDAsMC4zLDAsMC40YzAsMC4xLDAsMC4xLDAsMC4yVjc4YzAsMS4xLDAuOSwyLDIsMmg3MmMxLjEsMCwyLTAuOSwyLTJWMjIgYzAtMS4xLTAuOS0yLTItMkgxNGMtMC4xLDAtMC4xLDAtMC4yLDBTMTMuNywyMCwxMy42LDIweiBNMTYsMjRoNjh2NTJIMTZWNTQuOWwzLjQtMy40YzAuNC0wLjQsMC42LTAuOSwwLjYtMS40cy0wLjItMS4xLTAuNi0xLjQgTDE2LDQ1LjFMMTYsMjR6IE00OS44LDI3LjljLTAuMSwwLTAuMiwwLTAuMywwLjFjLTAuMSwwLTAuMSwwLTAuMiwwLjFjLTUuNSwwLjItMTAuNSwyLjQtMTQuMyw1LjljLTAuNSwwLjItMC45LDAuNi0xLjEsMS4xIGMtMy40LDMuNy01LjYsOC42LTUuOSwxMy45Yy0wLjQsMC42LTAuNCwxLjQsMCwyYzAuMiw1LjMsMi4zLDEwLjEsNS43LDEzLjhjMC4yLDAuNywwLjcsMS4zLDEuNCwxLjRjMy44LDMuNCw4LjgsNS41LDE0LjMsNS43IGMwLjEsMCwwLjEsMCwwLjIsMC4xYzAuMSwwLDAuMywwLDAuNCwwYzAuMSwwLDAuMywwLDAuNCwwYzAuMSwwLDAuMSwwLDAuMi0wLjFjNS40LTAuMiwxMC40LTIuMywxNC4yLTUuNyBjMC43LTAuMiwxLjMtMC44LDEuNC0xLjVjMy40LTMuOCw1LjUtOC43LDUuNy0xNC4yYzAsMCwwLTAuMSwwLjEtMC4xYzAsMCwwLDAsMC0wLjFjMC0wLjEsMC0wLjMsMC0wLjRjMC0wLjEsMC0wLjIsMC0wLjMgYzAtMC4xLDAtMC4zLTAuMS0wLjRjLTAuMi01LjYtMi40LTEwLjctNi0xNC41YzAsMCwwLDAtMC4xLTAuMWMwLDAsMC0wLjEtMC4xLTAuMWMtMC4yLTAuMi0wLjQtMC40LTAuNi0wLjYgYy0zLjgtMy42LTguOS01LjktMTQuNC02LjFDNTAuNSwyNy45LDUwLjEsMjcuOSw0OS44LDI3Ljl6IE00OCwzMi4xYzAsMS4xLDAuOSwyLDIsMmMxLjEsMCwyLTAuOSwyLTJjMy41LDAuNCw2LjYsMS44LDkuMywzLjkgYy0wLjYsMC41LTAuOSwxLjMtMC43LDJjMC4yLDAuNywwLjgsMS4zLDEuNSwxLjVjMC44LDAuMiwxLjUtMC4xLDItMC43YzIuMSwyLjYsMy41LDUuOCwzLjksOS4zYzAsMC0wLjEsMC0wLjEsMCBjLTAuMSwwLTAuMSwwLTAuMiwwYy0xLjEsMC4xLTEuOCwxLjEtMS43LDIuMXMxLDEuOSwyLjEsMS45Yy0wLjQsMy41LTEuOCw2LjYtMy45LDkuM2MtMC40LTAuNC0xLTAuNi0xLjYtMC42Yy0wLjEsMC0wLjEsMC0wLjIsMCBjLTAuNywwLjEtMS4zLDAuNy0xLjUsMS40Yy0wLjIsMC43LDAsMS41LDAuNSwyYy0yLjYsMi4xLTUuOCwzLjUtOS4zLDMuOWMwLTAuNi0wLjItMS4xLTAuNi0xLjVjLTAuNC0wLjQtMS0wLjYtMS41LTAuNSBjLTAuMSwwLTAuMiwwLTAuMywwLjFjLTAuOSwwLjItMS42LDEtMS42LDEuOWMtMy41LTAuNC02LjYtMS44LTkuMy0zLjljMC42LTAuNiwwLjctMS41LDAuNC0yLjJjLTAuMy0wLjctMS4xLTEuMi0xLjktMS4yIGMtMC4xLDAtMC4xLDAtMC4yLDBjLTAuNCwwLjEtMC44LDAuMy0xLjEsMC42Yy0yLjEtMi42LTMuNS01LjgtMy45LTkuM2MxLjEsMCwyLTAuOSwyLTJjMC0xLjEtMC45LTItMi0yYzAuNC0zLjUsMS44LTYuNiwzLjktOS4zIGMwLjUsMC42LDEuMywwLjksMiwwLjdjMC43LTAuMiwxLjMtMC44LDEuNS0xLjVjMC4yLTAuOC0wLjEtMS41LTAuNy0yQzQxLjQsMzMuOSw0NC41LDMyLjQsNDgsMzIuMUw0OCwzMi4xeiBNNTAsNDAgYy01LjUsMC0xMCw0LjUtMTAsMTBzNC41LDEwLDEwLDEwczEwLTQuNSwxMC0xMFM1NS41LDQwLDUwLDQweiBNNTAsNDRjMy4zLDAsNiwyLjcsNiw2cy0yLjcsNi02LDZzLTYtMi43LTYtNlM0Ni43LDQ0LDUwLDQ0eiI+PC9wYXRoPjwvc3ZnPg==") +} +.various-complements__suggestion-item__custom-dictionary::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNTEyIDUxMiI+PHJlY3QgeD0iMzIiIHk9Ijk2IiB3aWR0aD0iNjQiIGhlaWdodD0iMzY4IiByeD0iMTYiIHJ5PSIxNiIgZmlsbD0ibm9uZSIgc3Ryb2tlPSJjdXJyZW50Q29sb3IiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMzIiPjwvcmVjdD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDIyNGgxMjgiPjwvcGF0aD48cGF0aCBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIiBkPSJNMTEyIDQwMGgxMjgiPjwvcGF0aD48cmVjdCB4PSIxMTIiIHk9IjE2MCIgd2lkdGg9IjEyOCIgaGVpZ2h0PSIzMDQiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxyZWN0IHg9IjI1NiIgeT0iNDgiIHdpZHRoPSI5NiIgaGVpZ2h0PSI0MTYiIHJ4PSIxNiIgcnk9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIzMiI+PC9yZWN0PjxwYXRoIGQ9Ik00MjIuNDYgOTYuMTFsLTQwLjQgNC4yNWMtMTEuMTIgMS4xNy0xOS4xOCAxMS41Ny0xNy45MyAyMy4xbDM0LjkyIDMyMS41OWMxLjI2IDExLjUzIDExLjM3IDIwIDIyLjQ5IDE4Ljg0bDQwLjQtNC4yNWMxMS4xMi0xLjE3IDE5LjE4LTExLjU3IDE3LjkzLTIzLjFMNDQ1IDExNWMtMS4zMS0xMS41OC0xMS40Mi0yMC4wNi0yMi41NC0xOC44OXoiIGZpbGw9Im5vbmUiIHN0cm9rZT0iY3VycmVudENvbG9yIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBzdHJva2Utd2lkdGg9IjMyIj48L3BhdGg+PC9zdmc+"); +} +.various-complements__suggestion-item__internal-link::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0iY3VycmVudENvbG9yIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgZD0iTTEyLDBDNS40LDAsMCw1LjQsMCwxMnM1LjQsMTIsMTIsMTJjMi42LDAsNS0wLjgsNi45LTIuMmwxNS42LDE1LjZDMzEuNyw0MC44LDMwLDQ1LjIsMzAsNTBjMCw0LDEuMiw3LjYsMy4yLDEwLjcgTDIwLjEsNzEuMWMtMi4xLTEuOS01LTMuMS04LjEtMy4xQzUuNCw2OCwwLDczLjQsMCw4MHM1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyYzAtMi4xLTAuNS00LTEuNS01LjhsMTMuMi0xMC40IEMzOS4zLDY3LjYsNDQuNCw3MCw1MCw3MGMyLjcsMCw1LjItMC41LDcuNS0xLjRsNS4zLDkuOUM1OS45LDgwLjcsNTgsODQuMSw1OCw4OGMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEycy01LjQtMTItMTItMTIgYy0xLjMsMC0yLjYsMC4yLTMuOCwwLjZMNjEsNjYuN2MzLjgtMi41LDYuNy02LjIsOC4xLTEwLjZsNi45LDEuNGMwLDAuMiwwLDAuMywwLDAuNWMwLDYuNiw1LjQsMTIsMTIsMTJzMTItNS40LDEyLTEyIGMwLTYuNi01LjQtMTItMTItMTJjLTUuMSwwLTkuNCwzLjItMTEuMiw3LjZsLTYuOS0xLjVjMC4xLTAuNywwLjEtMS40LDAuMS0yLjFjMC03LjktNC42LTE0LjctMTEuMy0xNy45bDMuMS04LjIgYzAuNywwLjEsMS41LDAuMiwyLjIsMC4yYzYuNiwwLDEyLTUuNCwxMi0xMlM3MC42LDAsNjQsMFM1Miw1LjQsNTIsMTJjMCw0LjQsMi41LDguMyw2LjEsMTAuNEw1NSwzMC43Yy0xLjYtMC40LTMuMy0wLjctNS0wLjcgYy00LjgsMC05LjIsMS43LTEyLjYsNC41TDIxLjgsMTguOWMxLjQtMiwyLjItNC40LDIuMi02LjlDMjQsNS40LDE4LjYsMCwxMiwwTDEyLDB6IE0xMiw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LTggUzcuNiw0LDEyLDR6IE02NCw0YzQuNCwwLDgsMy42LDgsOHMtMy42LDgtOCw4cy04LTMuNi04LThTNTkuNiw0LDY0LDR6IE01MCwzNGM4LjksMCwxNiw3LjEsMTYsMTZjMCw4LjktNy4xLDE2LTE2LDE2IGMtOC45LDAtMTYtNy4xLTE2LTE2YzAtNC4zLDEuNy04LjIsNC40LTExLjFjMC4yLTAuMSwwLjMtMC4zLDAuNC0wLjRDNDEuOCwzNS43LDQ1LjcsMzQsNTAsMzR6IE04OCw1MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhzLTgtMy42LTgtOFM4My42LDUwLDg4LDUweiBNMTIsNzJjNC40LDAsOCwzLjYsOCw4cy0zLjYsOC04LDhzLTgtMy42LTgtOFM3LjYsNzIsMTIsNzJ6IE03MCw4MGM0LjQsMCw4LDMuNiw4LDggcy0zLjYsOC04LDhjLTQuNCwwLTgtMy42LTgtOGMwLTMsMS43LTUuNiw0LjEtN2MwLjEsMCwwLjEsMCwwLjItMC4xYzAsMCwwLDAsMC4xLTAuMWMwLDAsMC4xLDAsMC4xLTAuMUM2Ny42LDgwLjMsNjguNyw4MCw3MCw4MHogIj48L3BhdGg+PC9zdmc+"); +} +.various-complements__suggestion-item__front-matter::before { + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMjAgMjAiPjxnIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik0xMC4zMiAyLjAxM0E0IDQgMCAwIDAgNi4xNjIgNy4xM2wtMy45ODcgMy45ODZhLjYuNiAwIDAgMC0uMTc2LjQyNFYxNC40YS42LjYgMCAwIDAgLjYuNmgyLjhhLjYuNiAwIDAgMCAuNi0uNlYxM2gxLjlhLjYuNiAwIDAgMCAuNi0uNnYtMS42OTNsLjczNS0uNzM1YTUuNTEgNS41MSAwIDAgMS0uNTY5LS44NDZsLS45OS45OTFhLjYuNiAwIDAgMC0uMTc2LjQyNFYxMkg1LjZhLjYuNiAwIDAgMC0uNi42VjE0SDN2LTIuMjkzbDQuMzItNC4zMmwtLjExOC0uMzAzYTMuMDAxIDMuMDAxIDAgMCAxIDEuOTYtMy45NjVjLjMzLS40MjMuNzItLjc5NiAxLjE1Ny0xLjEwNnpNMTMuNSA2LjI1YS43NS43NSAwIDEgMCAwLTEuNWEuNzUuNzUgMCAwIDAgMCAxLjV6TTkgNi41YTQuNSA0LjUgMCAxIDEgNyAzLjc0MnYyLjA1bC43ODMuNzg0YS42LjYgMCAwIDEgMCAuODQ4TDE1LjcwNyAxNWwxLjA2OCAxLjA2N2EuNi42IDAgMCAxLS4wNS44OTNsLTIuMzUgMS44OGEuNi42IDAgMCAxLS43NSAwbC0yLjQtMS45MmEuNi42IDAgMCAxLS4yMjUtLjQ2OHYtNi4yMUE0LjQ5NiA0LjQ5NiAwIDAgMSA5IDYuNXpNMTMuNSAzYTMuNSAzLjUgMCAwIDAtMS43NSA2LjUzMmEuNS41IDAgMCAxIC4yNS40MzN2Ni4yOTVsMiAxLjZsMS43NTEtMS40MDFsLTEuMDM0LTEuMDM1YS42LjYgMCAwIDEgMC0uODQ4bDEuMDc2LTEuMDc2bC0uNjE3LS42MTdhLjYuNiAwIDAgMS0uMTc2LS40MjRWOS45NjVhLjUuNSAwIDAgMSAuMjUtLjQzM0EzLjUgMy41IDAgMCAwIDEzLjUgM3oiIGZpbGw9ImN1cnJlbnRDb2xvciI+PC9wYXRoPjwvZz48L3N2Zz4=") +} + +.various-complements__suggestion-item__phantom, +.various-complements__suggestion-item__phantom::before { + opacity: 0.6; +} + +.various-complements__suggestion-item__content__alias { + padding-left: 20px; +} +.various-complements__suggestion-item__content__alias::before { + width: 16px; + margin-left: -20px; + margin-right: 3px; + filter: invert(0.5) hue-rotate(180deg); + content: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgY2xhc3M9ImZvcndhcmQtYXJyb3ciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiI+PHBhdGggZmlsbD0iY3VycmVudENvbG9yIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgZD0ibTkuOSw4OS4wOTIyNmMtMC4wMzA5NCwwIC0wLjA1NDE0LDAgLTAuMDg1MDgsMGMtMS4wNjczNCwtMC4wNDY0MSAtMS45MTAzOSwtMC45MjgxMiAtMS44OTQ5MiwtMS45OTU0N2MwLjAwNzc0LC0wLjQ4NzI2IDEuMTQ0NjksLTQ4LjEzMTAxIDQ3LjUyLC00OS40NDU4NmwwLC0xMy44OTA5NGMwLC0wLjc2NTcgMC40NDA4NiwtMS40NjE4IDEuMTI5MjIsLTEuNzg2NjRjMC42ODA2MiwtMC4zMzI1OCAxLjUwODIsLTAuMjMyMDMgMi4wOTYwMSwwLjI0NzVsMzEuNjgsMjUuNzRjMC40NjQwNiwwLjM3ODk5IDAuNzM0NzYsMC45NDM2IDAuNzM0NzYsMS41MzkxNGMwLDAuNTk1NTUgLTAuMjcwNywxLjE2MDE2IC0wLjcyNzAzLDEuNTM5MTRsLTMxLjY4LDI1Ljc0Yy0wLjU5NTU1LDAuNDc5NTMgLTEuNDE1MzksMC41NzIzNCAtMi4xMDM3NSwwLjI0NzVjLTAuNjg4MzYsLTAuMzI0ODUgLTEuMTI5MjIsLTEuMDIwOTQgLTEuMTI5MjIsLTEuNzg2NjRsMCwtMTMuODQ0NTNjLTQxLjI2Mjg5LDAuNzUwMjQgLTQzLjQ5MDM5LDI0LjgxOTYxIC00My41Njc3MywyNS44NTYwMWMtMC4wNjk2MSwxLjA0NDE0IC0wLjkzNTg2LDEuODQwNzggLTEuOTcyMjYsMS44NDA3OHoiPjwvcGF0aD48L3N2Zz4="); +} diff --git a/notes/data/Pasted image 20220920130334.png b/notes/data/Pasted image 20220920130334.png new file mode 100644 index 0000000..6d1f784 Binary files /dev/null and b/notes/data/Pasted image 20220920130334.png differ diff --git a/notes/data/Pasted image 20220920141533.png b/notes/data/Pasted image 20220920141533.png new file mode 100644 index 0000000..1f0fb6a Binary files /dev/null and b/notes/data/Pasted image 20220920141533.png differ diff --git a/notes/fyz/Mechanika tekutin/Hydraulická zařízení.md b/notes/fyz/Mechanika tekutin/Hydraulická zařízení.md new file mode 100644 index 0000000..333674e --- /dev/null +++ b/notes/fyz/Mechanika tekutin/Hydraulická zařízení.md @@ -0,0 +1,38 @@ +# Hydraulická zařízení +![](Pasted%20image%2020220920130334.png) + +$p_1=p_2$ +$\frac{F_1}{S_1}=\frac{F_2}{S_2}$ => $\frac{F_2}{F_1}=\frac{S_2}{S_1}$ +$F_1S_2=F_2S_1$ + +poměr síly je rovný poměru ploch + +- umožňují přenést sílu kam potřebujem (tlak je všude stejný) +- může mít jakýkoliv tlak +- nízké tření + +--- + +# Příklady + +Na píst hydraulického pístu o obsahu $25cm^2$ působí síla o velikosti 100N. +a) Jaký tlak má tato síla v kapalině lisu? +b) Jak velká síla působí na druhý píst o obsahu $1000cm^2$? +c) O jakou vzdálenost se posune druhý píst, jestliže se menší píst posune o 8cm? + +$p=\frac{F}{S}$ +$p=\frac{100}{2.5 * 10^{-3}}$ +$p=\frac{100}{0.0025}$ +$p=\frac{1000000}{25}$ +$p=40kPa$ + +$\frac{S_2}{S_1}=\frac{F_2}{F_1}$ +$\frac{1000}{25}=\frac{F_2}{100}$ | \*4 +$4000=F_2$ +$F_2=4kN$ + +$V_1=V_2$ +$S_1h_1=S_2h_2$ +$h_2=\frac{S_1h_1}{S_2}$ +$h_2=\frac{25*10^{-4}*8*10^{-2}}{1000*10^{-4}}$ +$h_2=0.002m=0.2cm$ diff --git a/notes/fyz/Mechanika tekutin/Mechanika tekutin.md b/notes/fyz/Mechanika tekutin/Mechanika tekutin.md new file mode 100644 index 0000000..87bd208 --- /dev/null +++ b/notes/fyz/Mechanika tekutin/Mechanika tekutin.md @@ -0,0 +1,5 @@ +# Mechanika tekutin +%% Zoottelkeeper: Beginning of the autogenerated index file list %% +- [[fyz/Mechanika tekutin/Hydraulická zařízení|Hydraulická zařízení]] +- [[fyz/Mechanika tekutin/Tekutiny|Tekutiny]] +%% Zoottelkeeper: End of the autogenerated index file list %% diff --git a/notes/fyz/Mechanika tekutin/Tekutiny.md b/notes/fyz/Mechanika tekutin/Tekutiny.md new file mode 100644 index 0000000..498251d --- /dev/null +++ b/notes/fyz/Mechanika tekutin/Tekutiny.md @@ -0,0 +1,15 @@ +# Tekutiny +kapaliny a plyny + +> [!NOTE] tlak +> $p=\frac{F}S$ +> $[p]=\frac{N}{m^2}=Pa$ + +1) tlak způsobený tíhovým polem země + a) v kapalinách - hydrostatický tlak + b) v plynech - atmosférický tlak +2) tlak způsobený vnější silou (např. stlačením) + +> [!NOTE] Pascalův zákon +> tlak způsobený vnější silou je ve všech místech kapaliny stejný + diff --git a/notes/fyz/fyz.md b/notes/fyz/fyz.md index c2f3bae..a235f98 100644 --- a/notes/fyz/fyz.md +++ b/notes/fyz/fyz.md @@ -9,6 +9,7 @@ imagePrefix: 'data/' %% Zoottelkeeper: Beginning of the autogenerated index file list %% - [[fyz/Exponencionální zápis|Exponencionální zápis]] - [[fyz/Jednotky SI|Jednotky SI]] +- [[fyz/Mechanika tekutin/Mechanika tekutin|Mechanika tekutin]] - [[fyz/pohyb/pohyb|pohyb]] - [[fyz/Pohyb|Pohyb]] - [[fyz/Příklad|Příklad]] diff --git a/notes/har/historie počítačů.md b/notes/har/historie počítačů.md index ff21c45..5362d14 100644 --- a/notes/har/historie počítačů.md +++ b/notes/har/historie počítačů.md @@ -63,14 +63,14 @@ tags: #### Maniac - Mathematical analyzer - Matematické výpočty fyzikálních dějů -#### Univac -- Remington ### Druhá generace (1951 - 1965) - polovodičové prvky - tranzistory (1948) - diody - zvýšení kapacity paměti - zvýšení rychlosti přenosu dat +#### Univac +- Remington #### USA - Bell Laboratories - první samočinný počítač na světě - elektronky nahrazené tranzistory diff --git a/notes/mat/Funkce/Funkce.md b/notes/mat/Funkce/Funkce.md index b174703..edf38e3 100644 --- a/notes/mat/Funkce/Funkce.md +++ b/notes/mat/Funkce/Funkce.md @@ -13,6 +13,7 @@ imagePrefix: 'data/' - [[mat/Funkce/Funkční přepis|Funkční přepis]] - [[mat/Funkce/Inverzní funkce|Inverzní funkce]] - [[mat/Funkce/Kartézský součin|Kartézský součin]] +- [[mat/Funkce/Lineární lomené funkce|Lineární lomené funkce]] - [[mat/Funkce/Mocninné funkce|Mocninné funkce]] - [[mat/Funkce/Příklady|Příklady]] - [[mat/Funkce/Prostá funkce|Prostá funkce]] diff --git a/notes/mat/Funkce/Lineární lomené funkce.md b/notes/mat/Funkce/Lineární lomené funkce.md new file mode 100644 index 0000000..8a8635a --- /dev/null +++ b/notes/mat/Funkce/Lineární lomené funkce.md @@ -0,0 +1,26 @@ +# Lineární lomené funkce + +Má proměnnou ve jmenovateli + +$y=\frac{ax+b}{cx+d}$ + +$[a\ne0;ad-bc\ne0]$ + +- grafem je hyperbola +- každá l.l.f. lze dělením převést na tvar $y=\frac{k}{x-m}+n$ + +$o=[m;n]$ +počátek soust. souřadnic +$y=m$ +$x=n$ +kreslíme $y=\frac{k}x$ + +$y=\frac1{5x}$ +$y=\frac{3x+1}{x-5}$ + +$y=\frac1x$ +![](Pasted%20image%2020220920141533.png) + +--- + +a) $y=\frac{2x+3}{x-1}=(2x+3):(x-1)=2+\frac5{x-1}$