From 05d89f6cb54bf1b2a13745d54c6efc83041a0e28 Mon Sep 17 00:00:00 2001 From: Andley Chang Date: Thu, 28 Dec 2023 10:21:05 +0800 Subject: [PATCH] vault backup: 2023-12-28 10:21:05 Affected files: .obsidian/plugins/obsidian-footnotes/main.js .obsidian/plugins/obsidian-footnotes/manifest.json .obsidian/plugins/obsidian-git/main.js .obsidian/plugins/obsidian-git/manifest.json .obsidian/plugins/obsidian-git/styles.css .obsidian/plugins/obsidian-hider/main.js .obsidian/plugins/obsidian-hider/manifest.json .obsidian/plugins/obsidian-hider/styles.css .obsidian/workspace.json Hab.2.20-3.19.md README.md --- .obsidian/plugins/obsidian-footnotes/main.js | 699 +++++--- .../plugins/obsidian-footnotes/manifest.json | 2 +- .obsidian/plugins/obsidian-git/main.js | 1439 +++++++++-------- .obsidian/plugins/obsidian-git/manifest.json | 2 +- .obsidian/plugins/obsidian-git/styles.css | 5 + .obsidian/plugins/obsidian-hider/main.js | 14 +- .../plugins/obsidian-hider/manifest.json | 4 +- .obsidian/plugins/obsidian-hider/styles.css | 2 +- .obsidian/workspace.json | 15 +- Hab.2-3.md => Hab.2.20-3.19.md | 2 +- README.md | 2 +- 11 files changed, 1206 insertions(+), 980 deletions(-) rename Hab.2-3.md => Hab.2.20-3.19.md (90%) diff --git a/.obsidian/plugins/obsidian-footnotes/main.js b/.obsidian/plugins/obsidian-footnotes/main.js index fe12c3b..61a853f 100644 --- a/.obsidian/plugins/obsidian-footnotes/main.js +++ b/.obsidian/plugins/obsidian-footnotes/main.js @@ -27,19 +27,427 @@ function __awaiter(thisArg, _arguments, P, generator) { }); } +const DEFAULT_SETTINGS = { + enableAutoSuggest: true, + enableFootnoteSectionHeading: false, + FootnoteSectionHeading: "Footnotes", +}; +class FootnotePluginSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { + text: "Footnote Shortcut", + }); + const mainDesc = containerEl.createEl('p'); + mainDesc.appendText('Need help? Check the '); + mainDesc.appendChild(createEl('a', { + text: "README", + href: "https://github.com/MichaBrugger/obsidian-footnotes", + })); + mainDesc.appendText('!'); + containerEl.createEl('br'); + new obsidian.Setting(containerEl) + .setName("Enable Footnote Autosuggest") + .setDesc("Suggests existing footnotes when entering named footnotes.") + .addToggle((toggle) => toggle + .setValue(this.plugin.settings.enableAutoSuggest) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableAutoSuggest = value; + yield this.plugin.saveSettings(); + }))); + containerEl.createEl("h3", { + text: "Footnotes Section Behavior", + }); + new obsidian.Setting(containerEl) + .setName("Enable Footnote Section Heading") + .setDesc("Automatically adds a heading separating footnotes at the bottom of the note from the rest of the text.") + .addToggle((toggle) => toggle + .setValue(this.plugin.settings.enableFootnoteSectionHeading) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.enableFootnoteSectionHeading = value; + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName("Footnote Section Heading") + .setDesc("Heading to place above footnotes section (Supports Markdown formatting). Heading will be H1 size.") + .addText((text) => text + .setPlaceholder("Heading is Empty") + .setValue(this.plugin.settings.FootnoteSectionHeading) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.FootnoteSectionHeading = value; + yield this.plugin.saveSettings(); + }))); + } +} + +var AllMarkers = /\[\^([^\[\]]+)\](?!:)/dg; +var AllNumberedMarkers = /\[\^(\d+)\]/gi; +var AllDetailsNameOnly = /\[\^([^\[\]]+)\]:/g; +var DetailInLine = /\[\^([^\[\]]+)\]:/; +var ExtractNameFromFootnote = /(\[\^)([^\[\]]+)(?=\])/; +function listExistingFootnoteDetails(doc) { + let FootnoteDetailList = []; + //search each line for footnote details and add to list + for (let i = 0; i < doc.lineCount(); i++) { + let theLine = doc.getLine(i); + let lineMatch = theLine.match(AllDetailsNameOnly); + if (lineMatch) { + let temp = lineMatch[0]; + temp = temp.replace("[^", ""); + temp = temp.replace("]:", ""); + FootnoteDetailList.push(temp); + } + } + if (FootnoteDetailList.length > 0) { + return FootnoteDetailList; + } + else { + return null; + } +} +function listExistingFootnoteMarkersAndLocations(doc) { + let markerEntry; + let FootnoteMarkerInfo = []; + //search each line for footnote markers + //for each, add their name, line number, and start index to FootnoteMarkerInfo + for (let i = 0; i < doc.lineCount(); i++) { + let theLine = doc.getLine(i); + let lineMatch; + while ((lineMatch = AllMarkers.exec(theLine)) != null) { + markerEntry = { + footnote: lineMatch[0], + lineNum: i, + startIndex: lineMatch.index + }; + FootnoteMarkerInfo.push(markerEntry); + } + } + return FootnoteMarkerInfo; +} +function shouldJumpFromDetailToMarker(lineText, cursorPosition, doc) { + // check if we're in a footnote detail line ("[^1]: footnote") + // if so, jump cursor back to the footnote in the text + let match = lineText.match(DetailInLine); + if (match) { + let s = match[0]; + let index = s.replace("[^", ""); + index = index.replace("]:", ""); + let footnote = s.replace(":", ""); + let returnLineIndex = cursorPosition.line; + // find the FIRST OCCURENCE where this footnote exists in the text + for (let i = 0; i < doc.lineCount(); i++) { + let scanLine = doc.getLine(i); + if (scanLine.contains(footnote)) { + let cursorLocationIndex = scanLine.indexOf(footnote); + returnLineIndex = i; + doc.setCursor({ + line: returnLineIndex, + ch: cursorLocationIndex + footnote.length, + }); + return true; + } + } + } + return false; +} +function shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc) { + // Jump cursor TO detail marker + // does this line have a footnote marker? + // does the cursor overlap with one of them? + // if so, which one? + // find this footnote marker's detail line + // place cursor there + let markerTarget = null; + let FootnoteMarkerInfo = listExistingFootnoteMarkersAndLocations(doc); + let currentLine = cursorPosition.line; + let footnotesOnLine = FootnoteMarkerInfo.filter((markerEntry) => markerEntry.lineNum === currentLine); + if (footnotesOnLine != null) { + for (let i = 0; i <= footnotesOnLine.length - 1; i++) { + if (footnotesOnLine[i].footnote !== null) { + let marker = footnotesOnLine[i].footnote; + let indexOfMarkerInLine = footnotesOnLine[i].startIndex; + if (cursorPosition.ch >= indexOfMarkerInLine && + cursorPosition.ch <= indexOfMarkerInLine + marker.length) { + markerTarget = marker; + break; + } + } + } + } + if (markerTarget !== null) { + // extract name + let match = markerTarget.match(ExtractNameFromFootnote); + if (match) { + let footnoteName = match[2]; + // find the first line with this detail marker name in it. + for (let i = 0; i < doc.lineCount(); i++) { + let theLine = doc.getLine(i); + let lineMatch = theLine.match(DetailInLine); + if (lineMatch) { + // compare to the index + let nameMatch = lineMatch[1]; + if (nameMatch == footnoteName) { + doc.setCursor({ line: i, ch: lineMatch[0].length + 1 }); + return true; + } + } + } + } + } + return false; +} +function addFootnoteSectionHeader(plugin) { + //check if 'Enable Footnote Section Heading' is true + //if so, return the "Footnote Section Heading" + // else, return "" + if (plugin.settings.enableFootnoteSectionHeading == true) { + let returnHeading = `\n# ${plugin.settings.FootnoteSectionHeading}`; + return returnHeading; + } + return ""; +} +//FUNCTIONS FOR AUTONUMBERED FOOTNOTES +function insertAutonumFootnote(plugin) { + const mdView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + if (!mdView) + return false; + if (mdView.editor == undefined) + return false; + const doc = mdView.editor; + const cursorPosition = doc.getCursor(); + const lineText = doc.getLine(cursorPosition.line); + const markdownText = mdView.data; + if (shouldJumpFromDetailToMarker(lineText, cursorPosition, doc)) + return; + if (shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc)) + return; + return shouldCreateAutonumFootnote(lineText, cursorPosition, plugin, doc, markdownText); +} +function shouldCreateAutonumFootnote(lineText, cursorPosition, plugin, doc, markdownText) { + // create new footnote with the next numerical index + let matches = markdownText.match(AllNumberedMarkers); + let currentMax = 1; + if (matches != null) { + for (let i = 0; i <= matches.length - 1; i++) { + let match = matches[i]; + match = match.replace("[^", ""); + match = match.replace("]", ""); + let matchNumber = Number(match); + if (matchNumber + 1 > currentMax) { + currentMax = matchNumber + 1; + } + } + } + let footNoteId = currentMax; + let footnoteMarker = `[^${footNoteId}]`; + let linePart1 = lineText.substr(0, cursorPosition.ch); + let linePart2 = lineText.substr(cursorPosition.ch); + let newLine = linePart1 + footnoteMarker + linePart2; + doc.replaceRange(newLine, { line: cursorPosition.line, ch: 0 }, { line: cursorPosition.line, ch: lineText.length }); + let lastLineIndex = doc.lastLine(); + let lastLine = doc.getLine(lastLineIndex); + while (lastLineIndex > 0) { + lastLine = doc.getLine(lastLineIndex); + if (lastLine.length > 0) { + doc.replaceRange("", { line: lastLineIndex, ch: 0 }, { line: doc.lastLine(), ch: 0 }); + break; + } + lastLineIndex--; + } + let footnoteDetail = `\n[^${footNoteId}]: `; + let list = listExistingFootnoteDetails(doc); + if (list === null && currentMax == 1) { + footnoteDetail = "\n" + footnoteDetail; + let Heading = addFootnoteSectionHeader(plugin); + doc.setLine(doc.lastLine(), lastLine + Heading + footnoteDetail); + doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1); + } + else { + doc.setLine(doc.lastLine(), lastLine + footnoteDetail); + doc.setCursor(doc.lastLine(), footnoteDetail.length - 1); + } +} +//FUNCTIONS FOR NAMED FOOTNOTES +function insertNamedFootnote(plugin) { + const mdView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + if (!mdView) + return false; + if (mdView.editor == undefined) + return false; + const doc = mdView.editor; + const cursorPosition = doc.getCursor(); + const lineText = doc.getLine(cursorPosition.line); + mdView.data; + if (shouldJumpFromDetailToMarker(lineText, cursorPosition, doc)) + return; + if (shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc)) + return; + if (shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, plugin, doc)) + return; + return shouldCreateFootnoteMarker(lineText, cursorPosition, doc); +} +function shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, plugin, doc) { + // Create matching footnote detail for footnote marker + // does this line have a footnote marker? + // does the cursor overlap with one of them? + // if so, which one? + // does this footnote marker have a detail line? + // if not, create it and place cursor there + let reOnlyMarkersMatches = lineText.match(AllMarkers); + let markerTarget = null; + if (reOnlyMarkersMatches) { + for (let i = 0; i <= reOnlyMarkersMatches.length; i++) { + let marker = reOnlyMarkersMatches[i]; + if (marker != undefined) { + let indexOfMarkerInLine = lineText.indexOf(marker); + if (cursorPosition.ch >= indexOfMarkerInLine && + cursorPosition.ch <= indexOfMarkerInLine + marker.length) { + markerTarget = marker; + break; + } + } + } + } + if (markerTarget != null) { + //extract footnote + let match = markerTarget.match(ExtractNameFromFootnote); + //find if this footnote exists by listing existing footnote details + if (match) { + let footnoteId = match[2]; + let list = listExistingFootnoteDetails(doc); + // Check if the list is empty OR if the list doesn't include current footnote + // if so, add detail for the current footnote + if (list === null || !list.includes(footnoteId)) { + let lastLineIndex = doc.lastLine(); + let lastLine = doc.getLine(lastLineIndex); + while (lastLineIndex > 0) { + lastLine = doc.getLine(lastLineIndex); + if (lastLine.length > 0) { + doc.replaceRange("", { line: lastLineIndex, ch: 0 }, { line: doc.lastLine(), ch: 0 }); + break; + } + lastLineIndex--; + } + let footnoteDetail = `\n[^${footnoteId}]: `; + if (list === null || list.length < 1) { + footnoteDetail = "\n" + footnoteDetail; + let Heading = addFootnoteSectionHeader(plugin); + doc.setLine(doc.lastLine(), lastLine + Heading + footnoteDetail); + doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1); + } + else { + doc.setLine(doc.lastLine(), lastLine + footnoteDetail); + doc.setCursor(doc.lastLine(), footnoteDetail.length - 1); + } + return true; + } + return; + } + } +} +function shouldCreateFootnoteMarker(lineText, cursorPosition, doc, markdownText) { + //create empty footnote marker for name input + let emptyMarker = `[^]`; + doc.replaceRange(emptyMarker, doc.getCursor()); + //move cursor in between [^ and ] + doc.setCursor(cursorPosition.line, cursorPosition.ch + 2); + //open footnotePicker popup +} + +class Autocomplete extends obsidian.EditorSuggest { + constructor(plugin) { + super(plugin.app); + this.Footnote_Detail_Names_And_Text = /\[\^([^\[\]]+)\]:(.+(?:\n(?:(?!\[\^[^\[\]]+\]:).)+)*)/g; + this.getSuggestions = (context) => { + const { query } = context; + const mdView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + const doc = mdView.editor; + const matches = this.Extract_Footnote_Detail_Names_And_Text(doc); + const filteredResults = matches.filter((entry) => entry[1].includes(query)); + return filteredResults; + }; + this.plugin = plugin; + } + onTrigger(cursorPosition, doc, file) { + if (this.plugin.settings.enableAutoSuggest) { + const mdView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + const lineText = doc.getLine(cursorPosition.line); + mdView.data; + let reOnlyMarkersMatches = lineText.match(AllMarkers); + let markerTarget = null; + let indexOfMarkerInLine = null; + if (reOnlyMarkersMatches) { + for (let i = 0; i <= reOnlyMarkersMatches.length; i++) { + let marker = reOnlyMarkersMatches[i]; + if (marker != undefined) { + indexOfMarkerInLine = lineText.indexOf(marker); + if (cursorPosition.ch >= indexOfMarkerInLine && + cursorPosition.ch <= indexOfMarkerInLine + marker.length) { + markerTarget = marker; + break; + } + } + } + } + if (markerTarget != null) { + //extract footnote + let match = markerTarget.match(ExtractNameFromFootnote); + //find if this footnote exists by listing existing footnote details + if (match) { + let footnoteId = match[2]; + if (footnoteId !== undefined) { + this.latestTriggerInfo = { + end: cursorPosition, + start: { + ch: indexOfMarkerInLine + 2, + line: cursorPosition.line + }, + query: footnoteId + }; + return this.latestTriggerInfo; + } + } + } + return null; + } + } + Extract_Footnote_Detail_Names_And_Text(doc) { + //search each line for footnote details and add to list + //save the footnote detail name as capture group 1 + //save the footnote detail text as capture group 2 + let docText = doc.getValue(); + const matches = Array.from(docText.matchAll(this.Footnote_Detail_Names_And_Text)); + return matches; + } + renderSuggestion(value, el) { + el.createEl("b", { text: value[1] }); + el.createEl("br"); + el.createEl("p", { text: value[2] }); + } + selectSuggestion(value, evt) { + const { context, plugin } = this; + if (!context) + return; + const mdView = app.workspace.getActiveViewOfType(obsidian.MarkdownView); + mdView.editor; + const field = value[1]; + const replacement = `${field}`; + context.editor.replaceRange(replacement, this.latestTriggerInfo.start, this.latestTriggerInfo.end); + } +} + //Add chevron-up-square icon from lucide for mobile toolbar (temporary until Obsidian updates to Lucide v0.130.0) obsidian.addIcon("chevron-up-square", ``); -class MyPlugin extends obsidian.Plugin { - constructor() { - super(...arguments); - this.AllMarkers = /\[\^([^\[\]]+)\](?!:)/dg; - this.AllNumberedMarkers = /\[\^(\d+)\]/gi; - this.AllDetailsNameOnly = /\[\^([^\[\]]+)\]:/g; - this.DetailInLine = /\[\^([^\[\]]+)\]:/; - this.ExtractNameFromFootnote = /(\[\^)([^\[\]]+)(?=\])/; - } +class FootnotePlugin extends obsidian.Plugin { onload() { return __awaiter(this, void 0, void 0, function* () { + yield this.loadSettings(); + this.registerEditorSuggest(new Autocomplete(this)); this.addCommand({ id: "insert-autonumbered-footnote", name: "Insert / Navigate Auto-Numbered Footnote", @@ -47,7 +455,7 @@ class MyPlugin extends obsidian.Plugin { checkCallback: (checking) => { if (checking) return !!this.app.workspace.getActiveViewOfType(obsidian.MarkdownView); - this.insertAutonumFootnote(); + insertAutonumFootnote(this); }, }); this.addCommand({ @@ -57,270 +465,23 @@ class MyPlugin extends obsidian.Plugin { checkCallback: (checking) => { if (checking) return !!this.app.workspace.getActiveViewOfType(obsidian.MarkdownView); - this.insertNamedFootnote(); + insertNamedFootnote(this); } }); + this.addSettingTab(new FootnotePluginSettingTab(this.app, this)); }); } - //UNIVERSAL FUNCTIONS - listExistingFootnoteDetails(doc) { - let FootnoteDetailList = []; - //search each line for footnote details and add to list - for (let i = 0; i < doc.lineCount(); i++) { - let theLine = doc.getLine(i); - let lineMatch = theLine.match(this.AllDetailsNameOnly); - if (lineMatch) { - let temp = lineMatch[0]; - temp = temp.replace("[^", ""); - temp = temp.replace("]:", ""); - FootnoteDetailList.push(temp); - } - } - if (FootnoteDetailList.length > 0) { - return FootnoteDetailList; - } - else { - return null; - } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); } - listExistingFootnoteMarkersAndLocations(doc) { - let markerEntry; - let FootnoteMarkerInfo = []; - //search each line for footnote markers - //for each, add their name, line number, and start index to FootnoteMarkerInfo - for (let i = 0; i < doc.lineCount(); i++) { - let theLine = doc.getLine(i); - let lineMatch; - while ((lineMatch = this.AllMarkers.exec(theLine)) != null) { - markerEntry = { - footnote: lineMatch[0], - lineNum: i, - startIndex: lineMatch.index - }; - FootnoteMarkerInfo.push(markerEntry); - } - } - return FootnoteMarkerInfo; - } - shouldJumpFromDetailToMarker(lineText, cursorPosition, doc) { - // check if we're in a footnote detail line ("[^1]: footnote") - // if so, jump cursor back to the footnote in the text - // https://github.com/akaalias/obsidian-footnotes#improved-quick-navigation - let match = lineText.match(this.DetailInLine); - if (match) { - let s = match[0]; - let index = s.replace("[^", ""); - index = index.replace("]:", ""); - let footnote = s.replace(":", ""); - let returnLineIndex = cursorPosition.line; - // find the FIRST OCCURENCE where this footnote exists in the text - for (let i = 0; i < doc.lineCount(); i++) { - let scanLine = doc.getLine(i); - if (scanLine.contains(footnote)) { - let cursorLocationIndex = scanLine.indexOf(footnote); - returnLineIndex = i; - doc.setCursor({ - line: returnLineIndex, - ch: cursorLocationIndex + footnote.length, - }); - return true; - } - } - } - return false; - } - shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc) { - // Jump cursor TO detail marker - // does this line have a footnote marker? - // does the cursor overlap with one of them? - // if so, which one? - // find this footnote marker's detail line - // place cursor there - let markerTarget = null; - let FootnoteMarkerInfo = this.listExistingFootnoteMarkersAndLocations(doc); - let currentLine = cursorPosition.line; - let footnotesOnLine = FootnoteMarkerInfo.filter(markerEntry => markerEntry.lineNum === currentLine); - if (footnotesOnLine != null) { - for (let i = 0; i <= footnotesOnLine.length - 1; i++) { - if (footnotesOnLine[i].footnote !== null) { - let marker = footnotesOnLine[i].footnote; - let indexOfMarkerInLine = footnotesOnLine[i].startIndex; - if (cursorPosition.ch >= indexOfMarkerInLine && - cursorPosition.ch <= indexOfMarkerInLine + marker.length) { - markerTarget = marker; - break; - } - } - } - } - if (markerTarget !== null) { - // extract name - let match = markerTarget.match(this.ExtractNameFromFootnote); - if (match) { - let footnoteName = match[2]; - // find the first line with this detail marker name in it. - for (let i = 0; i < doc.lineCount(); i++) { - let theLine = doc.getLine(i); - let lineMatch = theLine.match(this.DetailInLine); - if (lineMatch) { - // compare to the index - let nameMatch = lineMatch[1]; - if (nameMatch == footnoteName) { - doc.setCursor({ line: i, ch: lineMatch[0].length + 1 }); - return true; - } - } - } - } - } - return false; - } - //FUNCTIONS FOR AUTONUMBERED FOOTNOTES - insertAutonumFootnote() { - const mdView = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView); - if (!mdView) - return false; - if (mdView.editor == undefined) - return false; - const doc = mdView.editor; - const cursorPosition = doc.getCursor(); - const lineText = doc.getLine(cursorPosition.line); - const markdownText = mdView.data; - if (this.shouldJumpFromDetailToMarker(lineText, cursorPosition, doc)) - return; - if (this.shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc)) - return; - return this.shouldCreateAutonumFootnote(lineText, cursorPosition, doc, markdownText); - } - shouldCreateAutonumFootnote(lineText, cursorPosition, doc, markdownText) { - // create new footnote with the next numerical index - let matches = markdownText.match(this.AllNumberedMarkers); - let currentMax = 1; - if (matches != null) { - for (let i = 0; i <= matches.length - 1; i++) { - let match = matches[i]; - match = match.replace("[^", ""); - match = match.replace("]", ""); - let matchNumber = Number(match); - if (matchNumber + 1 > currentMax) { - currentMax = matchNumber + 1; - } - } - } - let footNoteId = currentMax; - let footnoteMarker = `[^${footNoteId}]`; - let linePart1 = lineText.substr(0, cursorPosition.ch); - let linePart2 = lineText.substr(cursorPosition.ch); - let newLine = linePart1 + footnoteMarker + linePart2; - doc.replaceRange(newLine, { line: cursorPosition.line, ch: 0 }, { line: cursorPosition.line, ch: lineText.length }); - let lastLineIndex = doc.lastLine(); - let lastLine = doc.getLine(lastLineIndex); - while (lastLineIndex > 0) { - lastLine = doc.getLine(lastLineIndex); - if (lastLine.length > 0) { - doc.replaceRange("", { line: lastLineIndex, ch: 0 }, { line: doc.lastLine(), ch: 0 }); - break; - } - lastLineIndex--; - } - let footnoteDetail = `\n[^${footNoteId}]: `; - let list = this.listExistingFootnoteDetails(doc); - if (list === null && currentMax == 1) { - footnoteDetail = "\n" + footnoteDetail; - doc.setLine(doc.lastLine(), lastLine + footnoteDetail); - doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1); - } - else { - doc.setLine(doc.lastLine(), lastLine + footnoteDetail); - doc.setCursor(doc.lastLine(), footnoteDetail.length - 1); - } - } - //FUNCTIONS FOR NAMED FOOTNOTES - insertNamedFootnote() { - const mdView = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView); - if (!mdView) - return false; - if (mdView.editor == undefined) - return false; - const doc = mdView.editor; - const cursorPosition = doc.getCursor(); - const lineText = doc.getLine(cursorPosition.line); - const markdownText = mdView.data; - if (this.shouldJumpFromDetailToMarker(lineText, cursorPosition, doc)) - return; - if (this.shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc)) - return; - if (this.shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, doc)) - return; - return this.shouldCreateFootnoteMarker(lineText, cursorPosition, doc, markdownText); - } - shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, doc) { - // Create matching footnote detail for footnote marker - // does this line have a footnote marker? - // does the cursor overlap with one of them? - // if so, which one? - // does this footnote marker have a detail line? - // if not, create it and place cursor there - let reOnlyMarkersMatches = lineText.match(this.AllMarkers); - let markerTarget = null; - if (reOnlyMarkersMatches) { - for (let i = 0; i <= reOnlyMarkersMatches.length; i++) { - let marker = reOnlyMarkersMatches[i]; - if (marker != undefined) { - let indexOfMarkerInLine = lineText.indexOf(marker); - if (cursorPosition.ch >= indexOfMarkerInLine && - cursorPosition.ch <= indexOfMarkerInLine + marker.length) { - markerTarget = marker; - break; - } - } - } - } - if (markerTarget != null) { - //extract footnote - let match = markerTarget.match(this.ExtractNameFromFootnote); - //find if this footnote exists by listing existing footnote details - if (match) { - let footnoteId = match[2]; - let list = this.listExistingFootnoteDetails(doc); - // Check if the list is empty OR if the list doesn't include current footnote - // if so, add detail for the current footnote - if (list === null || !list.includes(footnoteId)) { - let lastLineIndex = doc.lastLine(); - let lastLine = doc.getLine(lastLineIndex); - while (lastLineIndex > 0) { - lastLine = doc.getLine(lastLineIndex); - if (lastLine.length > 0) { - doc.replaceRange("", { line: lastLineIndex, ch: 0 }, { line: doc.lastLine(), ch: 0 }); - break; - } - lastLineIndex--; - } - let footnoteDetail = `\n[^${footnoteId}]: `; - if (list === null || list.length < 1) { - footnoteDetail = "\n" + footnoteDetail; - doc.setLine(doc.lastLine(), lastLine + footnoteDetail); - doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1); - } - else { - doc.setLine(doc.lastLine(), lastLine + footnoteDetail); - doc.setCursor(doc.lastLine(), footnoteDetail.length - 1); - } - return true; - } - return; - } - } - } - shouldCreateFootnoteMarker(lineText, cursorPosition, doc, markdownText) { - //create empty footnote marker for name input - let emptyMarker = `[^]`; - doc.replaceRange(emptyMarker, doc.getCursor()); - //move cursor in between [^ and ] - doc.setCursor(cursorPosition.line, cursorPosition.ch + 2); - //open footnotePicker popup + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); } } -module.exports = MyPlugin; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","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 __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.push(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.push(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\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 (g && (g = 0, op[0] && (_ = 0)), _) 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: false } : 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","import { \r\n  addIcon,\r\n  Editor, \r\n  EditorPosition, \r\n  EditorSuggest, \r\n  EditorSuggestContext,\r\n  EditorSuggestTriggerInfo,\r\n  MarkdownView, \r\n  Plugin\r\n} from \"obsidian\";\r\n\r\n//Add chevron-up-square icon from lucide for mobile toolbar (temporary until Obsidian updates to Lucide v0.130.0)\r\naddIcon(\"chevron-up-square\", `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"lucide lucide-chevron-up-square\"><rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\" ry=\"2\"></rect><polyline points=\"8,14 12,10 16,14\"></polyline></svg>`);\r\n\r\nexport default class MyPlugin extends Plugin {\r\n\r\n  private AllMarkers = /\\[\\^([^\\[\\]]+)\\](?!:)/dg;\r\n  private AllNumberedMarkers = /\\[\\^(\\d+)\\]/gi;\r\n  private AllDetailsNameOnly = /\\[\\^([^\\[\\]]+)\\]:/g;\r\n  private DetailInLine = /\\[\\^([^\\[\\]]+)\\]:/;\r\n  private ExtractNameFromFootnote = /(\\[\\^)([^\\[\\]]+)(?=\\])/;\r\n\r\n  async onload() {\r\n    this.addCommand({\r\n      id: \"insert-autonumbered-footnote\",\r\n      name: \"Insert / Navigate Auto-Numbered Footnote\",\r\n      icon: \"plus-square\",\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking)\r\n          return !!this.app.workspace.getActiveViewOfType(MarkdownView);\r\n        this.insertAutonumFootnote();\r\n      },\r\n    });\r\n    this.addCommand({\r\n      id: \"insert-named-footnote\",\r\n      name: \"Insert / Navigate Named Footnote\",\r\n      icon: \"chevron-up-square\",\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking)\r\n          return !!this.app.workspace.getActiveViewOfType(MarkdownView);\r\n        this.insertNamedFootnote();\r\n      }\r\n    });\r\n  }\r\n\r\n  //UNIVERSAL FUNCTIONS\r\n\r\n  private listExistingFootnoteDetails(\r\n    doc: Editor\r\n  ) {\r\n    let FootnoteDetailList: string[] = [];\r\n    \r\n    //search each line for footnote details and add to list\r\n    for (let i = 0; i < doc.lineCount(); i++) {\r\n          let theLine = doc.getLine(i);\r\n          let lineMatch = theLine.match(this.AllDetailsNameOnly);\r\n          if (lineMatch) {\r\n            let temp = lineMatch[0];\r\n            temp = temp.replace(\"[^\",\"\");\r\n            temp = temp.replace(\"]:\",\"\");\r\n\r\n            FootnoteDetailList.push(temp);\r\n          }\r\n        }\r\n    if (FootnoteDetailList.length > 0) {\r\n      return FootnoteDetailList;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private listExistingFootnoteMarkersAndLocations(\r\n    doc: Editor\r\n  ) {\r\n    type markerEntry = {\r\n      footnote: string;\r\n      lineNum: number;\r\n      startIndex: number;\r\n    }\r\n    let markerEntry;\r\n\r\n    let FootnoteMarkerInfo = [];\r\n    //search each line for footnote markers\r\n    //for each, add their name, line number, and start index to FootnoteMarkerInfo\r\n    for (let i = 0; i < doc.lineCount(); i++) {\r\n      let theLine = doc.getLine(i);\r\n      let lineMatch;\r\n\r\n      while ((lineMatch = this.AllMarkers.exec(theLine)) != null) {\r\n        markerEntry = {\r\n          footnote: lineMatch[0],\r\n          lineNum: i,\r\n          startIndex: lineMatch.index\r\n        }\r\n        FootnoteMarkerInfo.push(markerEntry);\r\n      }\r\n    }\r\n    return FootnoteMarkerInfo;\r\n  }\r\n\r\n  private shouldJumpFromDetailToMarker(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor\r\n  ) {\r\n    // check if we're in a footnote detail line (\"[^1]: footnote\")\r\n    // if so, jump cursor back to the footnote in the text\r\n    // https://github.com/akaalias/obsidian-footnotes#improved-quick-navigation\r\n    let match = lineText.match(this.DetailInLine);\r\n    if (match) {\r\n      let s = match[0];\r\n      let index = s.replace(\"[^\", \"\");\r\n      index = index.replace(\"]:\", \"\");\r\n      let footnote = s.replace(\":\", \"\");\r\n\r\n      let returnLineIndex = cursorPosition.line;\r\n      // find the FIRST OCCURENCE where this footnote exists in the text\r\n      for (let i = 0; i < doc.lineCount(); i++) {\r\n        let scanLine = doc.getLine(i);\r\n        if (scanLine.contains(footnote)) {\r\n          let cursorLocationIndex = scanLine.indexOf(footnote);\r\n          returnLineIndex = i;\r\n          doc.setCursor({\r\n            line: returnLineIndex,\r\n            ch: cursorLocationIndex + footnote.length,\r\n          });\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  private shouldJumpFromMarkerToDetail(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor\r\n  ) {\r\n    // Jump cursor TO detail marker\r\n\r\n    // does this line have a footnote marker?\r\n    // does the cursor overlap with one of them?\r\n    // if so, which one?\r\n    // find this footnote marker's detail line\r\n    // place cursor there\r\n    let markerTarget = null;\r\n\r\n    let FootnoteMarkerInfo = this.listExistingFootnoteMarkersAndLocations(doc);\r\n    let currentLine = cursorPosition.line;\r\n    let footnotesOnLine = FootnoteMarkerInfo.filter(markerEntry => markerEntry.lineNum === currentLine);\r\n\r\n    if (footnotesOnLine != null) {\r\n      for (let i = 0; i <= footnotesOnLine.length-1; i++) {\r\n        if (footnotesOnLine[i].footnote !== null) {\r\n          let marker = footnotesOnLine[i].footnote;\r\n          let indexOfMarkerInLine = footnotesOnLine[i].startIndex;\r\n          if (\r\n            cursorPosition.ch >= indexOfMarkerInLine &&\r\n            cursorPosition.ch <= indexOfMarkerInLine + marker.length\r\n          ) {\r\n            markerTarget = marker;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    if (markerTarget !== null) {\r\n      // extract name\r\n      let match = markerTarget.match(this.ExtractNameFromFootnote);\r\n      if (match) {\r\n        let footnoteName = match[2];\r\n\r\n        // find the first line with this detail marker name in it.\r\n        for (let i = 0; i < doc.lineCount(); i++) {\r\n          let theLine = doc.getLine(i);\r\n          let lineMatch = theLine.match(this.DetailInLine);\r\n          if (lineMatch) {\r\n            // compare to the index\r\n            let nameMatch = lineMatch[1];\r\n            if (nameMatch == footnoteName) {\r\n              doc.setCursor({ line: i, ch: lineMatch[0].length + 1 });\r\n              return true;\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  //FUNCTIONS FOR AUTONUMBERED FOOTNOTES\r\n  \r\n  insertAutonumFootnote() {\r\n    const mdView = this.app.workspace.getActiveViewOfType(MarkdownView);\r\n\r\n    if (!mdView) return false;\r\n    if (mdView.editor == undefined) return false;\r\n\r\n    const doc = mdView.editor;\r\n    const cursorPosition = doc.getCursor();\r\n    const lineText = doc.getLine(cursorPosition.line);\r\n    const markdownText = mdView.data;\r\n\r\n    if (this.shouldJumpFromDetailToMarker(lineText, cursorPosition, doc))\r\n      return;\r\n    if (this.shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc))\r\n      return;\r\n\r\n    return this.shouldCreateAutonumFootnote(\r\n      lineText,\r\n      cursorPosition,\r\n      doc,\r\n      markdownText\r\n    );\r\n  }\r\n\r\n\r\n  private shouldCreateAutonumFootnote(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor,\r\n    markdownText: string\r\n  ) {\r\n    // create new footnote with the next numerical index\r\n    let matches = markdownText.match(this.AllNumberedMarkers);\r\n    let numbers: Array<number> = [];\r\n    let currentMax = 1;\r\n\r\n    if (matches != null) {\r\n      for (let i = 0; i <= matches.length - 1; i++) {\r\n        let match = matches[i];\r\n        match = match.replace(\"[^\", \"\");\r\n        match = match.replace(\"]\", \"\");\r\n        let matchNumber = Number(match);\r\n        numbers[i] = matchNumber;\r\n        if (matchNumber + 1 > currentMax) {\r\n          currentMax = matchNumber + 1;\r\n        }\r\n      }\r\n    }\r\n\r\n    let footNoteId = currentMax;\r\n    let footnoteMarker = `[^${footNoteId}]`;\r\n    let linePart1 = lineText.substr(0, cursorPosition.ch);\r\n    let linePart2 = lineText.substr(cursorPosition.ch);\r\n    let newLine = linePart1 + footnoteMarker + linePart2;\r\n\r\n    doc.replaceRange(\r\n      newLine,\r\n      { line: cursorPosition.line, ch: 0 },\r\n      { line: cursorPosition.line, ch: lineText.length }\r\n    );\r\n\r\n    let lastLineIndex = doc.lastLine();\r\n    let lastLine = doc.getLine(lastLineIndex);\r\n\r\n    while (lastLineIndex > 0) {\r\n      lastLine = doc.getLine(lastLineIndex);\r\n      if (lastLine.length > 0) {\r\n        doc.replaceRange(\r\n          \"\",\r\n          { line: lastLineIndex, ch: 0 },\r\n          { line: doc.lastLine(), ch: 0 }\r\n        );\r\n        break;\r\n      }\r\n      lastLineIndex--;\r\n    }\r\n\r\n    let footnoteDetail = `\\n[^${footNoteId}]: `;\r\n\r\n    let list = this.listExistingFootnoteDetails(doc);\r\n    \r\n    if (list===null && currentMax == 1) {\r\n      footnoteDetail = \"\\n\" + footnoteDetail;\r\n      doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n      doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1);\r\n    } else {\r\n      doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n      doc.setCursor(doc.lastLine(), footnoteDetail.length - 1);\r\n    }\r\n  }\r\n\r\n\r\n  //FUNCTIONS FOR NAMED FOOTNOTES\r\n\r\n  insertNamedFootnote() {\r\n    const mdView = this.app.workspace.getActiveViewOfType(MarkdownView);\r\n\r\n    if (!mdView) return false;\r\n    if (mdView.editor == undefined) return false;\r\n\r\n    const doc = mdView.editor;\r\n    const cursorPosition = doc.getCursor();\r\n    const lineText = doc.getLine(cursorPosition.line);\r\n    const markdownText = mdView.data;\r\n\r\n    if (this.shouldJumpFromDetailToMarker(lineText, cursorPosition, doc))\r\n      return;\r\n    if (this.shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc))\r\n      return;\r\n\r\n    if (this.shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, doc))\r\n      return; \r\n    return this.shouldCreateFootnoteMarker(\r\n      lineText,\r\n      cursorPosition,\r\n      doc,\r\n      markdownText\r\n    );\r\n\r\n\r\n  }\r\n  \r\n  private shouldCreateMatchingFootnoteDetail(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor\r\n  ) {\r\n    // Create matching footnote detail for footnote marker\r\n    \r\n    // does this line have a footnote marker?\r\n    // does the cursor overlap with one of them?\r\n    // if so, which one?\r\n    // does this footnote marker have a detail line?\r\n    // if not, create it and place cursor there\r\n    let reOnlyMarkersMatches = lineText.match(this.AllMarkers);\r\n\r\n    let markerTarget = null;\r\n\r\n    if (reOnlyMarkersMatches){\r\n      for (let i = 0; i <= reOnlyMarkersMatches.length; i++) {\r\n        let marker = reOnlyMarkersMatches[i];\r\n        if (marker != undefined) {\r\n          let indexOfMarkerInLine = lineText.indexOf(marker);\r\n          if (\r\n            cursorPosition.ch >= indexOfMarkerInLine &&\r\n            cursorPosition.ch <= indexOfMarkerInLine + marker.length\r\n          ) {\r\n            markerTarget = marker;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (markerTarget != null) {\r\n      //extract footnote\r\n      let match = markerTarget.match(this.ExtractNameFromFootnote)\r\n      //find if this footnote exists by listing existing footnote details\r\n      if (match) {\r\n        let footnoteId = match[2];\r\n\r\n        let list: string[] = this.listExistingFootnoteDetails(doc);\r\n        \r\n        // Check if the list is empty OR if the list doesn't include current footnote\r\n        // if so, add detail for the current footnote\r\n        if(list === null || !list.includes(footnoteId)) {\r\n          let lastLineIndex = doc.lastLine();\r\n          let lastLine = doc.getLine(lastLineIndex);\r\n\r\n          while (lastLineIndex > 0) {\r\n            lastLine = doc.getLine(lastLineIndex);\r\n            if (lastLine.length > 0) {\r\n              doc.replaceRange(\r\n                \"\",\r\n                { line: lastLineIndex, ch: 0 },\r\n                { line: doc.lastLine(), ch: 0 }\r\n              );\r\n              break;\r\n            }\r\n            lastLineIndex--;\r\n          }\r\n          \r\n          let footnoteDetail = `\\n[^${footnoteId}]: `;\r\n                    \r\n          if (list===null || list.length < 1) {\r\n            footnoteDetail = \"\\n\" + footnoteDetail;\r\n            doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n            doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1);\r\n          } else {\r\n            doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n            doc.setCursor(doc.lastLine(), footnoteDetail.length - 1);\r\n          }\r\n\r\n          return true;\r\n        }\r\n        return; \r\n      }\r\n    }\r\n  }\r\n\r\n  private shouldCreateFootnoteMarker(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor,\r\n    markdownText: string\r\n  ) {\r\n    //create empty footnote marker for name input\r\n    let emptyMarker = `[^]`;\r\n    doc.replaceRange(emptyMarker,doc.getCursor());\r\n    //move cursor in between [^ and ]\r\n    doc.setCursor(cursorPosition.line, cursorPosition.ch+2);\r\n    //open footnotePicker popup\r\n    \r\n  }\r\n}"],"names":["addIcon","Plugin","MarkdownView"],"mappings":"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"} +module.exports = FootnotePlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/settings.ts","src/insert-or-navigate-footnotes.ts","src/autosuggest.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 __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.push(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.push(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\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 (g && (g = 0, op[0] && (_ = 0)), _) 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: false } : 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","import { App, PluginSettingTab, Setting } from \"obsidian\";\r\nimport FootnotePlugin from \"./main\";\r\n\r\nexport interface FootnotePluginSettings {\r\n    enableAutoSuggest: boolean;\r\n    \r\n    enableFootnoteSectionHeading: boolean;\r\n    FootnoteSectionHeading: string;\r\n}\r\n\r\nexport const DEFAULT_SETTINGS: FootnotePluginSettings = {\r\n    enableAutoSuggest: true,\r\n\r\n    enableFootnoteSectionHeading: false,\r\n    FootnoteSectionHeading: \"Footnotes\",\r\n};\r\n\r\nexport class FootnotePluginSettingTab extends PluginSettingTab {\r\n    plugin: FootnotePlugin;\r\n\r\n    constructor(app: App, plugin: FootnotePlugin) {\r\n        super(app, plugin);\r\n        this.plugin = plugin;\r\n    }\r\n\r\n    display(): void {\r\n        const {containerEl} = this;\r\n        containerEl.empty();\r\n\r\n        containerEl.createEl(\"h2\", {\r\n        text: \"Footnote Shortcut\",\r\n        });\r\n\r\n        const mainDesc = containerEl.createEl('p');\r\n\r\n            mainDesc.appendText('Need help? Check the ');\r\n            mainDesc.appendChild(\r\n                createEl('a', {\r\n                text: \"README\",\r\n                href: \"https://github.com/MichaBrugger/obsidian-footnotes\",\r\n                })\r\n            );\r\n            mainDesc.appendText('!');\r\n        containerEl.createEl('br');\r\n        \r\n        new Setting(containerEl)\r\n        .setName(\"Enable Footnote Autosuggest\")\r\n        .setDesc(\"Suggests existing footnotes when entering named footnotes.\")\r\n        .addToggle((toggle) =>\r\n            toggle\r\n                .setValue(this.plugin.settings.enableAutoSuggest)\r\n                .onChange(async (value) => {\r\n                    this.plugin.settings.enableAutoSuggest = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n        );\r\n\r\n        containerEl.createEl(\"h3\", {\r\n            text: \"Footnotes Section Behavior\",\r\n        });\r\n\r\n        new Setting(containerEl)\r\n        .setName(\"Enable Footnote Section Heading\")\r\n        .setDesc(\"Automatically adds a heading separating footnotes at the bottom of the note from the rest of the text.\")\r\n        .addToggle((toggle) =>\r\n            toggle\r\n                .setValue(this.plugin.settings.enableFootnoteSectionHeading)\r\n                .onChange(async (value) => {\r\n                    this.plugin.settings.enableFootnoteSectionHeading = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n        );\r\n\r\n        new Setting(containerEl)\r\n        .setName(\"Footnote Section Heading\")\r\n        .setDesc(\"Heading to place above footnotes section (Supports Markdown formatting). Heading will be H1 size.\")\r\n        .addText((text) =>\r\n            text\r\n                .setPlaceholder(\"Heading is Empty\")\r\n                .setValue(this.plugin.settings.FootnoteSectionHeading)\r\n                .onChange(async (value) => {\r\n                    this.plugin.settings.FootnoteSectionHeading = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n        );\r\n    }\r\n}","import { \r\n    Editor, \r\n    EditorPosition, \r\n    MarkdownView\r\n} from \"obsidian\";\r\n\r\nimport FootnotePlugin from \"./main\";\r\n\r\nexport var AllMarkers = /\\[\\^([^\\[\\]]+)\\](?!:)/dg;\r\nvar AllNumberedMarkers = /\\[\\^(\\d+)\\]/gi;\r\nvar AllDetailsNameOnly = /\\[\\^([^\\[\\]]+)\\]:/g;\r\nvar DetailInLine = /\\[\\^([^\\[\\]]+)\\]:/;\r\nexport var ExtractNameFromFootnote = /(\\[\\^)([^\\[\\]]+)(?=\\])/;\r\n\r\n\r\nexport function listExistingFootnoteDetails(\r\n    doc: Editor\r\n) {\r\n    let FootnoteDetailList: string[] = [];\r\n    \r\n    //search each line for footnote details and add to list\r\n    for (let i = 0; i < doc.lineCount(); i++) {\r\n        let theLine = doc.getLine(i);\r\n        let lineMatch = theLine.match(AllDetailsNameOnly);\r\n        if (lineMatch) {\r\n            let temp = lineMatch[0];\r\n            temp = temp.replace(\"[^\",\"\");\r\n            temp = temp.replace(\"]:\",\"\");\r\n\r\n            FootnoteDetailList.push(temp);\r\n        }\r\n    }\r\n    if (FootnoteDetailList.length > 0) {\r\n        return FootnoteDetailList;\r\n    } else {\r\n        return null;\r\n    }\r\n}\r\n\r\nexport function listExistingFootnoteMarkersAndLocations(\r\n    doc: Editor\r\n) {\r\n    type markerEntry = {\r\n        footnote: string;\r\n        lineNum: number;\r\n        startIndex: number;\r\n    }\r\n    let markerEntry;\r\n\r\n    let FootnoteMarkerInfo = [];\r\n    //search each line for footnote markers\r\n    //for each, add their name, line number, and start index to FootnoteMarkerInfo\r\n    for (let i = 0; i < doc.lineCount(); i++) {\r\n        let theLine = doc.getLine(i);\r\n        let lineMatch;\r\n\r\n        while ((lineMatch = AllMarkers.exec(theLine)) != null) {\r\n        markerEntry = {\r\n            footnote: lineMatch[0],\r\n            lineNum: i,\r\n            startIndex: lineMatch.index\r\n        }\r\n        FootnoteMarkerInfo.push(markerEntry);\r\n        }\r\n    }\r\n    return FootnoteMarkerInfo;\r\n}\r\n\r\nexport function shouldJumpFromDetailToMarker(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor\r\n) {\r\n    // check if we're in a footnote detail line (\"[^1]: footnote\")\r\n    // if so, jump cursor back to the footnote in the text\r\n\r\n    let match = lineText.match(DetailInLine);\r\n    if (match) {\r\n        let s = match[0];\r\n        let index = s.replace(\"[^\", \"\");\r\n        index = index.replace(\"]:\", \"\");\r\n        let footnote = s.replace(\":\", \"\");\r\n\r\n        let returnLineIndex = cursorPosition.line;\r\n        // find the FIRST OCCURENCE where this footnote exists in the text\r\n        for (let i = 0; i < doc.lineCount(); i++) {\r\n            let scanLine = doc.getLine(i);\r\n            if (scanLine.contains(footnote)) {\r\n                let cursorLocationIndex = scanLine.indexOf(footnote);\r\n                returnLineIndex = i;\r\n                doc.setCursor({\r\n                line: returnLineIndex,\r\n                ch: cursorLocationIndex + footnote.length,\r\n                });\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\nexport function shouldJumpFromMarkerToDetail(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor\r\n) {\r\n    // Jump cursor TO detail marker\r\n\r\n    // does this line have a footnote marker?\r\n    // does the cursor overlap with one of them?\r\n    // if so, which one?\r\n    // find this footnote marker's detail line\r\n    // place cursor there\r\n    let markerTarget = null;\r\n\r\n    let FootnoteMarkerInfo = listExistingFootnoteMarkersAndLocations(doc);\r\n    let currentLine = cursorPosition.line;\r\n    let footnotesOnLine = FootnoteMarkerInfo.filter((markerEntry: { lineNum: number; }) => markerEntry.lineNum === currentLine);\r\n\r\n    if (footnotesOnLine != null) {\r\n        for (let i = 0; i <= footnotesOnLine.length-1; i++) {\r\n            if (footnotesOnLine[i].footnote !== null) {\r\n                let marker = footnotesOnLine[i].footnote;\r\n                let indexOfMarkerInLine = footnotesOnLine[i].startIndex;\r\n                if (\r\n                cursorPosition.ch >= indexOfMarkerInLine &&\r\n                cursorPosition.ch <= indexOfMarkerInLine + marker.length\r\n                ) {\r\n                markerTarget = marker;\r\n                break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (markerTarget !== null) {\r\n        // extract name\r\n        let match = markerTarget.match(ExtractNameFromFootnote);\r\n        if (match) {\r\n            let footnoteName = match[2];\r\n\r\n            // find the first line with this detail marker name in it.\r\n            for (let i = 0; i < doc.lineCount(); i++) {\r\n                let theLine = doc.getLine(i);\r\n                let lineMatch = theLine.match(DetailInLine);\r\n                if (lineMatch) {\r\n                    // compare to the index\r\n                    let nameMatch = lineMatch[1];\r\n                    if (nameMatch == footnoteName) {\r\n                        doc.setCursor({ line: i, ch: lineMatch[0].length + 1 });\r\n                        return true;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\nexport function addFootnoteSectionHeader(\r\n    plugin: FootnotePlugin,\r\n): string {\r\n    //check if 'Enable Footnote Section Heading' is true\r\n    //if so, return the \"Footnote Section Heading\"\r\n    // else, return \"\"\r\n\r\n    if (plugin.settings.enableFootnoteSectionHeading == true) {\r\n        let returnHeading = `\\n# ${plugin.settings.FootnoteSectionHeading}`;\r\n        return returnHeading;\r\n    }\r\n    return \"\";\r\n}\r\n\r\n//FUNCTIONS FOR AUTONUMBERED FOOTNOTES\r\n\r\nexport function insertAutonumFootnote(plugin: FootnotePlugin) {\r\n    const mdView = app.workspace.getActiveViewOfType(MarkdownView);\r\n\r\n    if (!mdView) return false;\r\n    if (mdView.editor == undefined) return false;\r\n\r\n    const doc = mdView.editor;\r\n    const cursorPosition = doc.getCursor();\r\n    const lineText = doc.getLine(cursorPosition.line);\r\n    const markdownText = mdView.data;\r\n\r\n    if (shouldJumpFromDetailToMarker(lineText, cursorPosition, doc))\r\n        return;\r\n    if (shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc))\r\n        return;\r\n\r\n    return shouldCreateAutonumFootnote(\r\n        lineText,\r\n        cursorPosition,\r\n        plugin,\r\n        doc,\r\n        markdownText\r\n    );\r\n}\r\n\r\n\r\nexport function shouldCreateAutonumFootnote(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    plugin: FootnotePlugin,\r\n    doc: Editor,\r\n    markdownText: string\r\n) {\r\n    // create new footnote with the next numerical index\r\n    let matches = markdownText.match(AllNumberedMarkers);\r\n    let numbers: Array<number> = [];\r\n    let currentMax = 1;\r\n\r\n    if (matches != null) {\r\n        for (let i = 0; i <= matches.length - 1; i++) {\r\n            let match = matches[i];\r\n            match = match.replace(\"[^\", \"\");\r\n            match = match.replace(\"]\", \"\");\r\n            let matchNumber = Number(match);\r\n            numbers[i] = matchNumber;\r\n            if (matchNumber + 1 > currentMax) {\r\n                currentMax = matchNumber + 1;\r\n            }\r\n        }\r\n    }\r\n\r\n    let footNoteId = currentMax;\r\n    let footnoteMarker = `[^${footNoteId}]`;\r\n    let linePart1 = lineText.substr(0, cursorPosition.ch);\r\n    let linePart2 = lineText.substr(cursorPosition.ch);\r\n    let newLine = linePart1 + footnoteMarker + linePart2;\r\n\r\n    doc.replaceRange(\r\n        newLine,\r\n        { line: cursorPosition.line, ch: 0 },\r\n        { line: cursorPosition.line, ch: lineText.length }\r\n    );\r\n\r\n    let lastLineIndex = doc.lastLine();\r\n    let lastLine = doc.getLine(lastLineIndex);\r\n\r\n    while (lastLineIndex > 0) {\r\n        lastLine = doc.getLine(lastLineIndex);\r\n        if (lastLine.length > 0) {\r\n            doc.replaceRange(\r\n                \"\",\r\n                { line: lastLineIndex, ch: 0 },\r\n                { line: doc.lastLine(), ch: 0 }\r\n            );\r\n            break;\r\n        }\r\n        lastLineIndex--;\r\n    }\r\n\r\n    let footnoteDetail = `\\n[^${footNoteId}]: `;\r\n\r\n    let list = listExistingFootnoteDetails(doc);\r\n    \r\n    if (list===null && currentMax == 1) {\r\n        footnoteDetail = \"\\n\" + footnoteDetail;\r\n        let Heading = addFootnoteSectionHeader(plugin);\r\n        doc.setLine(doc.lastLine(), lastLine + Heading + footnoteDetail);\r\n        doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1);\r\n    } else {\r\n        doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n        doc.setCursor(doc.lastLine(), footnoteDetail.length - 1);\r\n    }\r\n}\r\n\r\n\r\n//FUNCTIONS FOR NAMED FOOTNOTES\r\n\r\nexport function insertNamedFootnote(plugin: FootnotePlugin) {\r\n    const mdView = app.workspace.getActiveViewOfType(MarkdownView);\r\n\r\n    if (!mdView) return false;\r\n    if (mdView.editor == undefined) return false;\r\n\r\n    const doc = mdView.editor;\r\n    const cursorPosition = doc.getCursor();\r\n    const lineText = doc.getLine(cursorPosition.line);\r\n    const markdownText = mdView.data;\r\n\r\n    if (shouldJumpFromDetailToMarker(lineText, cursorPosition, doc))\r\n        return;\r\n    if (shouldJumpFromMarkerToDetail(lineText, cursorPosition, doc))\r\n        return;\r\n\r\n    if (shouldCreateMatchingFootnoteDetail(lineText, cursorPosition, plugin, doc))\r\n        return; \r\n    return shouldCreateFootnoteMarker(\r\n        lineText,\r\n        cursorPosition,\r\n        doc,\r\n        markdownText\r\n    );\r\n}\r\n\r\nexport function shouldCreateMatchingFootnoteDetail(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    plugin: FootnotePlugin,\r\n    doc: Editor\r\n) {\r\n    // Create matching footnote detail for footnote marker\r\n    \r\n    // does this line have a footnote marker?\r\n    // does the cursor overlap with one of them?\r\n    // if so, which one?\r\n    // does this footnote marker have a detail line?\r\n    // if not, create it and place cursor there\r\n    let reOnlyMarkersMatches = lineText.match(AllMarkers);\r\n\r\n    let markerTarget = null;\r\n\r\n    if (reOnlyMarkersMatches){\r\n        for (let i = 0; i <= reOnlyMarkersMatches.length; i++) {\r\n            let marker = reOnlyMarkersMatches[i];\r\n            if (marker != undefined) {\r\n                let indexOfMarkerInLine = lineText.indexOf(marker);\r\n                if (\r\n                    cursorPosition.ch >= indexOfMarkerInLine &&\r\n                    cursorPosition.ch <= indexOfMarkerInLine + marker.length\r\n                ) {\r\n                    markerTarget = marker;\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    if (markerTarget != null) {\r\n        //extract footnote\r\n        let match = markerTarget.match(ExtractNameFromFootnote)\r\n        //find if this footnote exists by listing existing footnote details\r\n        if (match) {\r\n            let footnoteId = match[2];\r\n\r\n            let list: string[] = listExistingFootnoteDetails(doc);\r\n            \r\n            // Check if the list is empty OR if the list doesn't include current footnote\r\n            // if so, add detail for the current footnote\r\n            if(list === null || !list.includes(footnoteId)) {\r\n                let lastLineIndex = doc.lastLine();\r\n                let lastLine = doc.getLine(lastLineIndex);\r\n\r\n                while (lastLineIndex > 0) {\r\n                    lastLine = doc.getLine(lastLineIndex);\r\n                    if (lastLine.length > 0) {\r\n                        doc.replaceRange(\r\n                            \"\",\r\n                            { line: lastLineIndex, ch: 0 },\r\n                            { line: doc.lastLine(), ch: 0 }\r\n                        );\r\n                        break;\r\n                    }\r\n                    lastLineIndex--;\r\n                }\r\n                \r\n                let footnoteDetail = `\\n[^${footnoteId}]: `;\r\n                            \r\n                if (list===null || list.length < 1) {\r\n                    footnoteDetail = \"\\n\" + footnoteDetail;\r\n                    let Heading = addFootnoteSectionHeader(plugin);\r\n                    doc.setLine(doc.lastLine(), lastLine + Heading + footnoteDetail);\r\n                    doc.setCursor(doc.lastLine() - 1, footnoteDetail.length - 1);\r\n                } else {\r\n                    doc.setLine(doc.lastLine(), lastLine + footnoteDetail);\r\n                    doc.setCursor(doc.lastLine(), footnoteDetail.length - 1);\r\n                }\r\n\r\n                return true;\r\n            }\r\n            return; \r\n        }\r\n    }\r\n}\r\n\r\nexport function shouldCreateFootnoteMarker(\r\n    lineText: string,\r\n    cursorPosition: EditorPosition,\r\n    doc: Editor,\r\n    markdownText: string\r\n) {\r\n    //create empty footnote marker for name input\r\n    let emptyMarker = `[^]`;\r\n    doc.replaceRange(emptyMarker,doc.getCursor());\r\n    //move cursor in between [^ and ]\r\n    doc.setCursor(cursorPosition.line, cursorPosition.ch+2);\r\n    //open footnotePicker popup\r\n    \r\n}","import {\r\n    Editor,\r\n    EditorPosition,\r\n    EditorSuggest,\r\n    EditorSuggestContext,\r\n    EditorSuggestTriggerInfo,\r\n    MarkdownView,\r\n    TFile,\r\n} from \"obsidian\";\r\nimport FootnotePlugin from \"./main\";\r\nimport { AllMarkers, ExtractNameFromFootnote } from \"./insert-or-navigate-footnotes\"\r\n\r\n\r\nexport class Autocomplete extends EditorSuggest<RegExpMatchArray> {\r\n    plugin: FootnotePlugin;\r\n    latestTriggerInfo: EditorSuggestTriggerInfo;\r\n    cursorPosition: EditorPosition;\r\n\r\n    constructor(plugin: FootnotePlugin) {\r\n        super(plugin.app);\r\n        this.plugin = plugin;\r\n    }\r\n\r\n    onTrigger(\r\n        cursorPosition: EditorPosition, \r\n        doc: Editor, \r\n        file: TFile\r\n    ): EditorSuggestTriggerInfo | null{\r\n        if (this.plugin.settings.enableAutoSuggest) {\r\n\r\n            const mdView = app.workspace.getActiveViewOfType(MarkdownView);\r\n            const lineText = doc.getLine(cursorPosition.line);\r\n            const markdownText = mdView.data;\r\n            \r\n            let reOnlyMarkersMatches = lineText.match(AllMarkers);\r\n\r\n            let markerTarget = null;\r\n            let indexOfMarkerInLine = null;\r\n\r\n            if (reOnlyMarkersMatches){\r\n                for (let i = 0; i <= reOnlyMarkersMatches.length; i++) {\r\n                    let marker = reOnlyMarkersMatches[i];\r\n                    if (marker != undefined) {\r\n                        indexOfMarkerInLine = lineText.indexOf(marker);\r\n                        if (\r\n                            cursorPosition.ch >= indexOfMarkerInLine &&\r\n                            cursorPosition.ch <= indexOfMarkerInLine + marker.length\r\n                        ) {\r\n                            markerTarget = marker;\r\n                            break;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (markerTarget != null) {\r\n                //extract footnote\r\n                let match = markerTarget.match(ExtractNameFromFootnote)\r\n                //find if this footnote exists by listing existing footnote details\r\n                if (match) {\r\n                    let footnoteId = match[2];\r\n                    if (footnoteId !== undefined) {\r\n                        this.latestTriggerInfo = {\r\n                            end: cursorPosition,\r\n                            start: {\r\n                                ch: indexOfMarkerInLine + 2,\r\n                                line: cursorPosition.line\r\n                            },\r\n                            query: footnoteId\r\n                        };\r\n                        return this.latestTriggerInfo\r\n                    }\r\n                }\r\n            }\r\n        return null;\r\n        }\r\n    }\r\n\r\n    Footnote_Detail_Names_And_Text = /\\[\\^([^\\[\\]]+)\\]:(.+(?:\\n(?:(?!\\[\\^[^\\[\\]]+\\]:).)+)*)/g;\r\n\r\n    Extract_Footnote_Detail_Names_And_Text(\r\n        doc: Editor\r\n    ) {\r\n        //search each line for footnote details and add to list\r\n        //save the footnote detail name as capture group 1\r\n        //save the footnote detail text as capture group 2\r\n        \r\n        let docText:string = doc.getValue();\r\n        const matches = Array.from(docText.matchAll(this.Footnote_Detail_Names_And_Text));\r\n        return matches;\r\n    }\r\n\r\n    getSuggestions = (context: EditorSuggestContext): RegExpMatchArray[] => {\r\n        const { query } = context;\r\n\r\n        const mdView = app.workspace.getActiveViewOfType(MarkdownView);\r\n        const doc = mdView.editor;\r\n        const matches = this.Extract_Footnote_Detail_Names_And_Text(doc)\r\n        const filteredResults: RegExpMatchArray[] = matches.filter((entry) => entry[1].includes(query));\r\n        return filteredResults\r\n    };\r\n\r\n    renderSuggestion(\r\n        value: RegExpMatchArray, \r\n        el: HTMLElement\r\n    ): void {\r\n        el.createEl(\"b\", { text: value[1] });\r\n        el.createEl(\"br\");\r\n        el.createEl(\"p\", { text: value[2]});\r\n    }\r\n\r\n    selectSuggestion(\r\n        value: RegExpMatchArray, \r\n        evt: MouseEvent | KeyboardEvent\r\n    ): void {\r\n        const { context, plugin } = this;\r\n        if (!context) return;\r\n\r\n        const mdView = app.workspace.getActiveViewOfType(MarkdownView);\r\n        const doc = mdView.editor;\r\n\r\n        const field = value[1];\r\n        const replacement = `${field}`;\r\n\r\n        context.editor.replaceRange(\r\n            replacement,\r\n            this.latestTriggerInfo.start,\r\n            this.latestTriggerInfo.end,\r\n        );\r\n    }\r\n}","import { \r\n  addIcon,\r\n  Editor, \r\n  EditorPosition, \r\n  EditorSuggest, \r\n  EditorSuggestContext,\r\n  EditorSuggestTriggerInfo,\r\n  MarkdownView, \r\n  Plugin\r\n} from \"obsidian\";\r\n\r\nimport { FootnotePluginSettingTab, FootnotePluginSettings, DEFAULT_SETTINGS } from \"./settings\";\r\nimport { Autocomplete } from \"./autosuggest\"\r\nimport { insertAutonumFootnote,insertNamedFootnote } from \"./insert-or-navigate-footnotes\";\r\n\r\n//Add chevron-up-square icon from lucide for mobile toolbar (temporary until Obsidian updates to Lucide v0.130.0)\r\naddIcon(\"chevron-up-square\", `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"lucide lucide-chevron-up-square\"><rect width=\"18\" height=\"18\" x=\"3\" y=\"3\" rx=\"2\" ry=\"2\"></rect><polyline points=\"8,14 12,10 16,14\"></polyline></svg>`);\r\n\r\nexport default class FootnotePlugin extends Plugin {\r\n  public settings: FootnotePluginSettings;\r\n\r\n  async onload() {\r\n    await this.loadSettings();\r\n\r\n    this.registerEditorSuggest(new Autocomplete(this));\r\n\r\n    this.addCommand({\r\n      id: \"insert-autonumbered-footnote\",\r\n      name: \"Insert / Navigate Auto-Numbered Footnote\",\r\n      icon: \"plus-square\",\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking)\r\n          return !!this.app.workspace.getActiveViewOfType(MarkdownView);\r\n        insertAutonumFootnote(this);\r\n      },\r\n    });\r\n    this.addCommand({\r\n      id: \"insert-named-footnote\",\r\n      name: \"Insert / Navigate Named Footnote\",\r\n      icon: \"chevron-up-square\",\r\n      checkCallback: (checking: boolean) => {\r\n        if (checking)\r\n          return !!this.app.workspace.getActiveViewOfType(MarkdownView);\r\n        insertNamedFootnote(this);\r\n      }\r\n    });\r\n  \r\n    this.addSettingTab(new FootnotePluginSettingTab(this.app, this));\r\n  }\r\n\r\n  async loadSettings() {\r\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n  }\r\n\r\n  async saveSettings() {\r\n    await this.saveData(this.settings);\r\n  }\r\n}"],"names":["PluginSettingTab","Setting","MarkdownView","EditorSuggest","addIcon","Plugin"],"mappings":"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"} diff --git a/.obsidian/plugins/obsidian-footnotes/manifest.json b/.obsidian/plugins/obsidian-footnotes/manifest.json index 22c7207..7a0ee47 100644 --- a/.obsidian/plugins/obsidian-footnotes/manifest.json +++ b/.obsidian/plugins/obsidian-footnotes/manifest.json @@ -1,7 +1,7 @@ { "id": "obsidian-footnotes", "name": "Footnote Shortcut", - "version": "0.1.2", + "version": "0.1.3", "minAppVersion": "0.12.0", "description": "Insert and write footnotes faster", "author": "Alexis Rondeau, Micha Brugger, Jason Qin", diff --git a/.obsidian/plugins/obsidian-git/main.js b/.obsidian/plugins/obsidian-git/main.js index e079ea5..dc70752 100644 --- a/.obsidian/plugins/obsidian-git/main.js +++ b/.obsidian/plugins/obsidian-git/main.js @@ -8759,15 +8759,15 @@ var require_implementation = __commonJS({ } }; keysShim = function keys(object) { - var isObject = object !== null && typeof object === "object"; - var isFunction = toStr.call(object) === "[object Function]"; + var isObject2 = object !== null && typeof object === "object"; + var isFunction2 = toStr.call(object) === "[object Function]"; var isArguments = isArgs(object); - var isString = isObject && toStr.call(object) === "[object String]"; + var isString = isObject2 && toStr.call(object) === "[object String]"; var theKeys = []; - if (!isObject && !isFunction && !isArguments) { + if (!isObject2 && !isFunction2 && !isArguments) { throw new TypeError("Object.keys called on a non-object"); } - var skipProto = hasProtoEnumBug && isFunction; + var skipProto = hasProtoEnumBug && isFunction2; if (isString && object.length > 0 && !has.call(object, 0)) { for (var i = 0; i < object.length; ++i) { theKeys.push(String(i)); @@ -9359,7 +9359,7 @@ var require_define_properties = __commonJS({ var toStr = Object.prototype.toString; var concat = Array.prototype.concat; var origDefineProperty = Object.defineProperty; - var isFunction = function(fn) { + var isFunction2 = function(fn) { return typeof fn === "function" && toStr.call(fn) === "[object Function]"; }; var hasPropertyDescriptors = require_has_property_descriptors()(); @@ -9370,7 +9370,7 @@ var require_define_properties = __commonJS({ if (object[name] === value) { return; } - } else if (!isFunction(predicate) || !predicate()) { + } else if (!isFunction2(predicate) || !predicate()) { return; } } @@ -11123,19 +11123,22 @@ var require_gopd = __commonJS({ } }); -// node_modules/.pnpm/is-typed-array@1.1.10/node_modules/is-typed-array/index.js -var require_is_typed_array = __commonJS({ - "node_modules/.pnpm/is-typed-array@1.1.10/node_modules/is-typed-array/index.js"(exports2, module2) { +// node_modules/.pnpm/which-typed-array@1.1.11/node_modules/which-typed-array/index.js +var require_which_typed_array = __commonJS({ + "node_modules/.pnpm/which-typed-array@1.1.11/node_modules/which-typed-array/index.js"(exports2, module2) { "use strict"; init_polyfill_buffer(); var forEach2 = require_for_each(); var availableTypedArrays = require_available_typed_arrays(); + var callBind = require_call_bind(); var callBound = require_callBound(); + var gOPD = require_gopd(); var $toString = callBound("Object.prototype.toString"); var hasToStringTag = require_shams2()(); - var gOPD = require_gopd(); var g = typeof globalThis === "undefined" ? global : globalThis; var typedArrays = availableTypedArrays(); + var $slice = callBound("String.prototype.slice"); + var getPrototypeOf = Object.getPrototypeOf; var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) { for (var i = 0; i < array.length; i += 1) { if (array[i] === value) { @@ -11144,9 +11147,7 @@ var require_is_typed_array = __commonJS({ } return -1; }; - var $slice = callBound("String.prototype.slice"); - var toStrTags = {}; - var getPrototypeOf = Object.getPrototypeOf; + var cache = { __proto__: null }; if (hasToStringTag && gOPD && getPrototypeOf) { forEach2(typedArrays, function(typedArray) { var arr = new g[typedArray](); @@ -11157,38 +11158,76 @@ var require_is_typed_array = __commonJS({ var superProto = getPrototypeOf(proto); descriptor = gOPD(superProto, Symbol.toStringTag); } - toStrTags[typedArray] = descriptor.get; + cache["$" + typedArray] = callBind(descriptor.get); } }); + } else { + forEach2(typedArrays, function(typedArray) { + var arr = new g[typedArray](); + cache["$" + typedArray] = callBind(arr.slice); + }); } var tryTypedArrays = function tryAllTypedArrays(value) { - var anyTrue = false; - forEach2(toStrTags, function(getter, typedArray) { - if (!anyTrue) { + var found = false; + forEach2(cache, function(getter, typedArray) { + if (!found) { try { - anyTrue = getter.call(value) === typedArray; + if ("$" + getter(value) === typedArray) { + found = $slice(typedArray, 1); + } } catch (e) { } } }); - return anyTrue; + return found; }; - module2.exports = function isTypedArray(value) { + var trySlices = function tryAllSlices(value) { + var found = false; + forEach2(cache, function(getter, name) { + if (!found) { + try { + getter(value); + found = $slice(name, 1); + } catch (e) { + } + } + }); + return found; + }; + module2.exports = function whichTypedArray(value) { if (!value || typeof value !== "object") { return false; } - if (!hasToStringTag || !(Symbol.toStringTag in value)) { + if (!hasToStringTag) { var tag2 = $slice($toString(value), 8, -1); - return $indexOf(typedArrays, tag2) > -1; + if ($indexOf(typedArrays, tag2) > -1) { + return tag2; + } + if (tag2 !== "Object") { + return false; + } + return trySlices(value); } if (!gOPD) { - return false; + return null; } return tryTypedArrays(value); }; } }); +// node_modules/.pnpm/is-typed-array@1.1.12/node_modules/is-typed-array/index.js +var require_is_typed_array = __commonJS({ + "node_modules/.pnpm/is-typed-array@1.1.12/node_modules/is-typed-array/index.js"(exports2, module2) { + "use strict"; + init_polyfill_buffer(); + var whichTypedArray = require_which_typed_array(); + module2.exports = function isTypedArray(value) { + return !!whichTypedArray(value); + }; + } +}); + // node_modules/.pnpm/is-array-buffer@3.0.2/node_modules/is-array-buffer/index.js var require_is_array_buffer = __commonJS({ "node_modules/.pnpm/is-array-buffer@3.0.2/node_modules/is-array-buffer/index.js"(exports2, module2) { @@ -11618,66 +11657,6 @@ var require_which_collection = __commonJS({ } }); -// node_modules/.pnpm/which-typed-array@1.1.9/node_modules/which-typed-array/index.js -var require_which_typed_array = __commonJS({ - "node_modules/.pnpm/which-typed-array@1.1.9/node_modules/which-typed-array/index.js"(exports2, module2) { - "use strict"; - init_polyfill_buffer(); - var forEach2 = require_for_each(); - var availableTypedArrays = require_available_typed_arrays(); - var callBound = require_callBound(); - var gOPD = require_gopd(); - var $toString = callBound("Object.prototype.toString"); - var hasToStringTag = require_shams2()(); - var g = typeof globalThis === "undefined" ? global : globalThis; - var typedArrays = availableTypedArrays(); - var $slice = callBound("String.prototype.slice"); - var toStrTags = {}; - var getPrototypeOf = Object.getPrototypeOf; - if (hasToStringTag && gOPD && getPrototypeOf) { - forEach2(typedArrays, function(typedArray) { - if (typeof g[typedArray] === "function") { - var arr = new g[typedArray](); - if (Symbol.toStringTag in arr) { - var proto = getPrototypeOf(arr); - var descriptor = gOPD(proto, Symbol.toStringTag); - if (!descriptor) { - var superProto = getPrototypeOf(proto); - descriptor = gOPD(superProto, Symbol.toStringTag); - } - toStrTags[typedArray] = descriptor.get; - } - } - }); - } - var tryTypedArrays = function tryAllTypedArrays(value) { - var foundName = false; - forEach2(toStrTags, function(getter, typedArray) { - if (!foundName) { - try { - var name = getter.call(value); - if (name === typedArray) { - foundName = name; - } - } catch (e) { - } - } - }); - return foundName; - }; - var isTypedArray = require_is_typed_array(); - module2.exports = function whichTypedArray(value) { - if (!isTypedArray(value)) { - return false; - } - if (!hasToStringTag || !(Symbol.toStringTag in value)) { - return $slice($toString(value), 8, -1); - } - return tryTypedArrays(value); - }; - } -}); - // node_modules/.pnpm/array-buffer-byte-length@1.0.0/node_modules/array-buffer-byte-length/index.js var require_array_buffer_byte_length = __commonJS({ "node_modules/.pnpm/array-buffer-byte-length@1.0.0/node_modules/array-buffer-byte-length/index.js"(exports2, module2) { @@ -11695,9 +11674,9 @@ var require_array_buffer_byte_length = __commonJS({ } }); -// node_modules/.pnpm/deep-equal@2.2.1/node_modules/deep-equal/index.js +// node_modules/.pnpm/deep-equal@2.2.2/node_modules/deep-equal/index.js var require_deep_equal = __commonJS({ - "node_modules/.pnpm/deep-equal@2.2.1/node_modules/deep-equal/index.js"(exports2, module2) { + "node_modules/.pnpm/deep-equal@2.2.2/node_modules/deep-equal/index.js"(exports2, module2) { "use strict"; init_polyfill_buffer(); var assign2 = require_object(); @@ -11980,9 +11959,20 @@ var require_deep_equal = __commonJS({ } var aWhich = whichTypedArray(a); var bWhich = whichTypedArray(b); - if ((aWhich || bWhich) && aWhich !== bWhich) { + if (aWhich !== bWhich) { return false; } + if (aWhich || bWhich) { + if (a.length !== b.length) { + return false; + } + for (i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } var aIsBuffer = isBuffer(a); var bIsBuffer = isBuffer(b); if (aIsBuffer !== bIsBuffer) { @@ -13177,9 +13167,9 @@ var require_hogan = __commonJS({ } }); -// node_modules/.pnpm/feather-icons@4.29.0/node_modules/feather-icons/dist/feather.js +// node_modules/.pnpm/feather-icons@4.29.1/node_modules/feather-icons/dist/feather.js var require_feather = __commonJS({ - "node_modules/.pnpm/feather-icons@4.29.0/node_modules/feather-icons/dist/feather.js"(exports2, module2) { + "node_modules/.pnpm/feather-icons@4.29.1/node_modules/feather-icons/dist/feather.js"(exports2, module2) { init_polyfill_buffer(); (function webpackUniversalModuleDefinition(root2, factory) { if (typeof exports2 === "object" && typeof module2 === "object") @@ -13259,7 +13249,7 @@ var require_feather = __commonJS({ /*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, aperture, archive, arrow-down-circle, arrow-down-left, arrow-down-right, arrow-down, arrow-left-circle, arrow-left, arrow-right-circle, arrow-right, arrow-up-circle, arrow-up-left, arrow-up-right, arrow-up, at-sign, award, bar-chart-2, bar-chart, battery-charging, battery, bell-off, bell, bluetooth, bold, book-open, book, bookmark, box, briefcase, calendar, camera-off, camera, cast, check-circle, check-square, check, chevron-down, chevron-left, chevron-right, chevron-up, chevrons-down, chevrons-left, chevrons-right, chevrons-up, chrome, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-off, cloud-rain, cloud-snow, cloud, code, codepen, codesandbox, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, divide-circle, divide-square, divide, dollar-sign, download-cloud, download, dribbble, droplet, edit-2, edit-3, edit, external-link, eye-off, eye, facebook, fast-forward, feather, figma, file-minus, file-plus, file-text, file, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, grid, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, info, instagram, italic, key, layers, layout, life-buoy, link-2, link, linkedin, list, loader, lock, log-in, log-out, mail, map-pin, map, maximize-2, maximize, meh, menu, message-circle, message-square, mic-off, mic, minimize-2, minimize, minus-circle, minus-square, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation-2, navigation, octagon, package, paperclip, pause-circle, pause, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, pie-chart, play-circle, play, plus-circle, plus-square, plus, pocket, power, printer, radio, refresh-ccw, refresh-cw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, server, settings, share-2, share, shield-off, shield, shopping-bag, shopping-cart, shuffle, sidebar, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, square, star, stop-circle, sun, sunrise, sunset, table, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, tool, trash-2, trash, trello, trending-down, trending-up, triangle, truck, tv, twitch, twitter, type, umbrella, underline, unlock, upload-cloud, upload, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume-1, volume-2, volume-x, volume, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */ /***/ function(module3) { - module3.exports = { "activity": '', "airplay": '', "alert-circle": '', "alert-octagon": '', "alert-triangle": '', "align-center": '', "align-justify": '', "align-left": '', "align-right": '', "anchor": '', "aperture": '', "archive": '', "arrow-down-circle": '', "arrow-down-left": '', "arrow-down-right": '', "arrow-down": '', "arrow-left-circle": '', "arrow-left": '', "arrow-right-circle": '', "arrow-right": '', "arrow-up-circle": '', "arrow-up-left": '', "arrow-up-right": '', "arrow-up": '', "at-sign": '', "award": '', "bar-chart-2": '', "bar-chart": '', "battery-charging": '', "battery": '', "bell-off": '', "bell": '', "bluetooth": '', "bold": '', "book-open": '', "book": '', "bookmark": '', "box": '', "briefcase": '', "calendar": '', "camera-off": '', "camera": '', "cast": '', "check-circle": '', "check-square": '', "check": '', "chevron-down": '', "chevron-left": '', "chevron-right": '', "chevron-up": '', "chevrons-down": '', "chevrons-left": '', "chevrons-right": '', "chevrons-up": '', "chrome": '', "circle": '', "clipboard": '', "clock": '', "cloud-drizzle": '', "cloud-lightning": '', "cloud-off": '', "cloud-rain": '', "cloud-snow": '', "cloud": '', "code": '', "codepen": '', "codesandbox": '', "coffee": '', "columns": '', "command": '', "compass": '', "copy": '', "corner-down-left": '', "corner-down-right": '', "corner-left-down": '', "corner-left-up": '', "corner-right-down": '', "corner-right-up": '', "corner-up-left": '', "corner-up-right": '', "cpu": '', "credit-card": '', "crop": '', "crosshair": '', "database": '', "delete": '', "disc": '', "divide-circle": '', "divide-square": '', "divide": '', "dollar-sign": '', "download-cloud": '', "download": '', "dribbble": '', "droplet": '', "edit-2": '', "edit-3": '', "edit": '', "external-link": '', "eye-off": '', "eye": '', "facebook": '', "fast-forward": '', "feather": '', "figma": '', "file-minus": '', "file-plus": '', "file-text": '', "file": '', "film": '', "filter": '', "flag": '', "folder-minus": '', "folder-plus": '', "folder": '', "framer": '', "frown": '', "gift": '', "git-branch": '', "git-commit": '', "git-merge": '', "git-pull-request": '', "github": '', "gitlab": '', "globe": '', "grid": '', "hard-drive": '', "hash": '', "headphones": '', "heart": '', "help-circle": '', "hexagon": '', "home": '', "image": '', "inbox": '', "info": '', "instagram": '', "italic": '', "key": '', "layers": '', "layout": '', "life-buoy": '', "link-2": '', "link": '', "linkedin": '', "list": '', "loader": '', "lock": '', "log-in": '', "log-out": '', "mail": '', "map-pin": '', "map": '', "maximize-2": '', "maximize": '', "meh": '', "menu": '', "message-circle": '', "message-square": '', "mic-off": '', "mic": '', "minimize-2": '', "minimize": '', "minus-circle": '', "minus-square": '', "minus": '', "monitor": '', "moon": '', "more-horizontal": '', "more-vertical": '', "mouse-pointer": '', "move": '', "music": '', "navigation-2": '', "navigation": '', "octagon": '', "package": '', "paperclip": '', "pause-circle": '', "pause": '', "pen-tool": '', "percent": '', "phone-call": '', "phone-forwarded": '', "phone-incoming": '', "phone-missed": '', "phone-off": '', "phone-outgoing": '', "phone": '', "pie-chart": '', "play-circle": '', "play": '', "plus-circle": '', "plus-square": '', "plus": '', "pocket": '', "power": '', "printer": '', "radio": '', "refresh-ccw": '', "refresh-cw": '', "repeat": '', "rewind": '', "rotate-ccw": '', "rotate-cw": '', "rss": '', "save": '', "scissors": '', "search": '', "send": '', "server": '', "settings": '', "share-2": '', "share": '', "shield-off": '', "shield": '', "shopping-bag": '', "shopping-cart": '', "shuffle": '', "sidebar": '', "skip-back": '', "skip-forward": '', "slack": '', "slash": '', "sliders": '', "smartphone": '', "smile": '', "speaker": '', "square": '', "star": '', "stop-circle": '', "sun": '', "sunrise": '', "sunset": '', "table": '', "tablet": '', "tag": '', "target": '', "terminal": '', "thermometer": '', "thumbs-down": '', "thumbs-up": '', "toggle-left": '', "toggle-right": '', "tool": '', "trash-2": '', "trash": '', "trello": '', "trending-down": '', "trending-up": '', "triangle": '', "truck": '', "tv": '', "twitch": '', "twitter": '', "type": '', "umbrella": '', "underline": '', "unlock": '', "upload-cloud": '', "upload": '', "user-check": '', "user-minus": '', "user-plus": '', "user-x": '', "user": '', "users": '', "video-off": '', "video": '', "voicemail": '', "volume-1": '', "volume-2": '', "volume-x": '', "volume": '', "watch": '', "wifi-off": '', "wifi": '', "wind": '', "x-circle": '', "x-octagon": '', "x-square": '', "x": '', "youtube": '', "zap-off": '', "zap": '', "zoom-in": '', "zoom-out": '' }; + module3.exports = { "activity": '', "airplay": '', "alert-circle": '', "alert-octagon": '', "alert-triangle": '', "align-center": '', "align-justify": '', "align-left": '', "align-right": '', "anchor": '', "aperture": '', "archive": '', "arrow-down-circle": '', "arrow-down-left": '', "arrow-down-right": '', "arrow-down": '', "arrow-left-circle": '', "arrow-left": '', "arrow-right-circle": '', "arrow-right": '', "arrow-up-circle": '', "arrow-up-left": '', "arrow-up-right": '', "arrow-up": '', "at-sign": '', "award": '', "bar-chart-2": '', "bar-chart": '', "battery-charging": '', "battery": '', "bell-off": '', "bell": '', "bluetooth": '', "bold": '', "book-open": '', "book": '', "bookmark": '', "box": '', "briefcase": '', "calendar": '', "camera-off": '', "camera": '', "cast": '', "check-circle": '', "check-square": '', "check": '', "chevron-down": '', "chevron-left": '', "chevron-right": '', "chevron-up": '', "chevrons-down": '', "chevrons-left": '', "chevrons-right": '', "chevrons-up": '', "chrome": '', "circle": '', "clipboard": '', "clock": '', "cloud-drizzle": '', "cloud-lightning": '', "cloud-off": '', "cloud-rain": '', "cloud-snow": '', "cloud": '', "code": '', "codepen": '', "codesandbox": '', "coffee": '', "columns": '', "command": '', "compass": '', "copy": '', "corner-down-left": '', "corner-down-right": '', "corner-left-down": '', "corner-left-up": '', "corner-right-down": '', "corner-right-up": '', "corner-up-left": '', "corner-up-right": '', "cpu": '', "credit-card": '', "crop": '', "crosshair": '', "database": '', "delete": '', "disc": '', "divide-circle": '', "divide-square": '', "divide": '', "dollar-sign": '', "download-cloud": '', "download": '', "dribbble": '', "droplet": '', "edit-2": '', "edit-3": '', "edit": '', "external-link": '', "eye-off": '', "eye": '', "facebook": '', "fast-forward": '', "feather": '', "figma": '', "file-minus": '', "file-plus": '', "file-text": '', "file": '', "film": '', "filter": '', "flag": '', "folder-minus": '', "folder-plus": '', "folder": '', "framer": '', "frown": '', "gift": '', "git-branch": '', "git-commit": '', "git-merge": '', "git-pull-request": '', "github": '', "gitlab": '', "globe": '', "grid": '', "hard-drive": '', "hash": '', "headphones": '', "heart": '', "help-circle": '', "hexagon": '', "home": '', "image": '', "inbox": '', "info": '', "instagram": '', "italic": '', "key": '', "layers": '', "layout": '', "life-buoy": '', "link-2": '', "link": '', "linkedin": '', "list": '', "loader": '', "lock": '', "log-in": '', "log-out": '', "mail": '', "map-pin": '', "map": '', "maximize-2": '', "maximize": '', "meh": '', "menu": '', "message-circle": '', "message-square": '', "mic-off": '', "mic": '', "minimize-2": '', "minimize": '', "minus-circle": '', "minus-square": '', "minus": '', "monitor": '', "moon": '', "more-horizontal": '', "more-vertical": '', "mouse-pointer": '', "move": '', "music": '', "navigation-2": '', "navigation": '', "octagon": '', "package": '', "paperclip": '', "pause-circle": '', "pause": '', "pen-tool": '', "percent": '', "phone-call": '', "phone-forwarded": '', "phone-incoming": '', "phone-missed": '', "phone-off": '', "phone-outgoing": '', "phone": '', "pie-chart": '', "play-circle": '', "play": '', "plus-circle": '', "plus-square": '', "plus": '', "pocket": '', "power": '', "printer": '', "radio": '', "refresh-ccw": '', "refresh-cw": '', "repeat": '', "rewind": '', "rotate-ccw": '', "rotate-cw": '', "rss": '', "save": '', "scissors": '', "search": '', "send": '', "server": '', "settings": '', "share-2": '', "share": '', "shield-off": '', "shield": '', "shopping-bag": '', "shopping-cart": '', "shuffle": '', "sidebar": '', "skip-back": '', "skip-forward": '', "slack": '', "slash": '', "sliders": '', "smartphone": '', "smile": '', "speaker": '', "square": '', "star": '', "stop-circle": '', "sun": '', "sunrise": '', "sunset": '', "table": '', "tablet": '', "tag": '', "target": '', "terminal": '', "thermometer": '', "thumbs-down": '', "thumbs-up": '', "toggle-left": '', "toggle-right": '', "tool": '', "trash-2": '', "trash": '', "trello": '', "trending-down": '', "trending-up": '', "triangle": '', "truck": '', "tv": '', "twitch": '', "twitter": '', "type": '', "umbrella": '', "underline": '', "unlock": '', "upload-cloud": '', "upload": '', "user-check": '', "user-minus": '', "user-plus": '', "user-x": '', "user": '', "users": '', "video-off": '', "video": '', "voicemail": '', "volume-1": '', "volume-2": '', "volume-x": '', "volume": '', "watch": '', "wifi-off": '', "wifi": '', "wind": '', "x-circle": '', "x-octagon": '', "x-square": '', "x": '', "youtube": '', "zap-off": '', "zap": '', "zoom-in": '', "zoom-out": '' }; } ), /***/ @@ -13392,12 +13382,12 @@ var require_feather = __commonJS({ /*! no static exports found */ /***/ function(module3, exports3, __webpack_require__) { - var isObject = __webpack_require__( + var isObject2 = __webpack_require__( /*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js" ); module3.exports = function(it) { - if (!isObject(it)) { + if (!isObject2(it)) { throw TypeError(String(it) + " is not an object"); } return it; @@ -13993,12 +13983,12 @@ var require_feather = __commonJS({ /*! ../internals/global */ "./node_modules/core-js/internals/global.js" ); - var isObject = __webpack_require__( + var isObject2 = __webpack_require__( /*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js" ); var document2 = global2.document; - var exist = isObject(document2) && isObject(document2.createElement); + var exist = isObject2(document2) && isObject2(document2.createElement); module3.exports = function(it) { return exist ? document2.createElement(it) : {}; }; @@ -14312,7 +14302,7 @@ var require_feather = __commonJS({ /*! ../internals/global */ "./node_modules/core-js/internals/global.js" ); - var isObject = __webpack_require__( + var isObject2 = __webpack_require__( /*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js" ); @@ -14340,7 +14330,7 @@ var require_feather = __commonJS({ var getterFor = function(TYPE) { return function(it) { var state; - if (!isObject(it) || (state = get(it)).type !== TYPE) { + if (!isObject2(it) || (state = get(it)).type !== TYPE) { throw TypeError("Incompatible receiver, " + TYPE + " required"); } return state; @@ -15310,19 +15300,19 @@ var require_feather = __commonJS({ /*! no static exports found */ /***/ function(module3, exports3, __webpack_require__) { - var isObject = __webpack_require__( + var isObject2 = __webpack_require__( /*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js" ); module3.exports = function(it, S) { - if (!isObject(it)) + if (!isObject2(it)) return it; var fn, val; - if (S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + if (S && typeof (fn = it.toString) == "function" && !isObject2(val = fn.call(it))) return val; - if (typeof (fn = it.valueOf) == "function" && !isObject(val = fn.call(it))) + if (typeof (fn = it.valueOf) == "function" && !isObject2(val = fn.call(it))) return val; - if (!S && typeof (fn = it.toString) == "function" && !isObject(val = fn.call(it))) + if (!S && typeof (fn = it.toString) == "function" && !isObject2(val = fn.call(it))) return val; throw TypeError("Can't convert object to primitive value"); }; @@ -15351,7 +15341,7 @@ var require_feather = __commonJS({ /*! no static exports found */ /***/ function(module3, exports3, __webpack_require__) { - var isObject = __webpack_require__( + var isObject2 = __webpack_require__( /*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js" ); @@ -15361,7 +15351,7 @@ var require_feather = __commonJS({ ); module3.exports = function(O, proto) { anObject(O); - if (!isObject(proto) && proto !== null) { + if (!isObject2(proto) && proto !== null) { throw TypeError("Can't set " + String(proto) + " as a prototype"); } }; @@ -15739,10 +15729,10 @@ var require_feather = __commonJS({ /*!***********************!*\ !*** ./src/tags.json ***! \***********************/ - /*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, archive, at-sign, award, aperture, bar-chart, bar-chart-2, battery, battery-charging, bell, bell-off, bluetooth, book-open, book, bookmark, box, briefcase, calendar, camera, cast, chevron-down, chevron-up, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-rain, cloud-snow, cloud, codepen, codesandbox, code, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, dollar-sign, droplet, edit, edit-2, edit-3, eye, eye-off, external-link, facebook, fast-forward, figma, file-minus, file-plus, file-text, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, instagram, key, layers, layout, life-bouy, link, link-2, linkedin, list, lock, log-in, log-out, mail, map-pin, map, maximize, maximize-2, meh, menu, message-circle, message-square, mic-off, mic, minimize, minimize-2, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation, navigation-2, octagon, package, paperclip, pause, pause-circle, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, play, pie-chart, play-circle, plus, plus-circle, plus-square, pocket, power, printer, radio, refresh-cw, refresh-ccw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, settings, share-2, shield, shield-off, shopping-bag, shopping-cart, shuffle, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, star, stop-circle, sun, sunrise, sunset, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, tool, trash, trash-2, triangle, truck, tv, twitch, twitter, type, umbrella, unlock, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume, volume-1, volume-2, volume-x, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */ + /*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, archive, at-sign, award, aperture, bar-chart, bar-chart-2, battery, battery-charging, bell, bell-off, bluetooth, book-open, book, bookmark, box, briefcase, calendar, camera, cast, chevron-down, chevron-up, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-rain, cloud-snow, cloud, codepen, codesandbox, code, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, dollar-sign, droplet, edit, edit-2, edit-3, eye, eye-off, external-link, facebook, fast-forward, figma, file-minus, file-plus, file-text, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, instagram, key, layers, layout, life-buoy, link, link-2, linkedin, list, lock, log-in, log-out, mail, map-pin, map, maximize, maximize-2, meh, menu, message-circle, message-square, mic-off, mic, minimize, minimize-2, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation, navigation-2, octagon, package, paperclip, pause, pause-circle, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, play, pie-chart, play-circle, plus, plus-circle, plus-square, pocket, power, printer, radio, refresh-cw, refresh-ccw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, settings, share-2, shield, shield-off, shopping-bag, shopping-cart, shuffle, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, star, stop-circle, sun, sunrise, sunset, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, tool, trash, trash-2, triangle, truck, tv, twitch, twitter, type, umbrella, unlock, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume, volume-1, volume-2, volume-x, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */ /***/ function(module3) { - module3.exports = { "activity": ["pulse", "health", "action", "motion"], "airplay": ["stream", "cast", "mirroring"], "alert-circle": ["warning", "alert", "danger"], "alert-octagon": ["warning", "alert", "danger"], "alert-triangle": ["warning", "alert", "danger"], "align-center": ["text alignment", "center"], "align-justify": ["text alignment", "justified"], "align-left": ["text alignment", "left"], "align-right": ["text alignment", "right"], "anchor": [], "archive": ["index", "box"], "at-sign": ["mention", "at", "email", "message"], "award": ["achievement", "badge"], "aperture": ["camera", "photo"], "bar-chart": ["statistics", "diagram", "graph"], "bar-chart-2": ["statistics", "diagram", "graph"], "battery": ["power", "electricity"], "battery-charging": ["power", "electricity"], "bell": ["alarm", "notification", "sound"], "bell-off": ["alarm", "notification", "silent"], "bluetooth": ["wireless"], "book-open": ["read", "library"], "book": ["read", "dictionary", "booklet", "magazine", "library"], "bookmark": ["read", "clip", "marker", "tag"], "box": ["cube"], "briefcase": ["work", "bag", "baggage", "folder"], "calendar": ["date"], "camera": ["photo"], "cast": ["chromecast", "airplay"], "chevron-down": ["expand"], "chevron-up": ["collapse"], "circle": ["off", "zero", "record"], "clipboard": ["copy"], "clock": ["time", "watch", "alarm"], "cloud-drizzle": ["weather", "shower"], "cloud-lightning": ["weather", "bolt"], "cloud-rain": ["weather"], "cloud-snow": ["weather", "blizzard"], "cloud": ["weather"], "codepen": ["logo"], "codesandbox": ["logo"], "code": ["source", "programming"], "coffee": ["drink", "cup", "mug", "tea", "cafe", "hot", "beverage"], "columns": ["layout"], "command": ["keyboard", "cmd", "terminal", "prompt"], "compass": ["navigation", "safari", "travel", "direction"], "copy": ["clone", "duplicate"], "corner-down-left": ["arrow", "return"], "corner-down-right": ["arrow"], "corner-left-down": ["arrow"], "corner-left-up": ["arrow"], "corner-right-down": ["arrow"], "corner-right-up": ["arrow"], "corner-up-left": ["arrow"], "corner-up-right": ["arrow"], "cpu": ["processor", "technology"], "credit-card": ["purchase", "payment", "cc"], "crop": ["photo", "image"], "crosshair": ["aim", "target"], "database": ["storage", "memory"], "delete": ["remove"], "disc": ["album", "cd", "dvd", "music"], "dollar-sign": ["currency", "money", "payment"], "droplet": ["water"], "edit": ["pencil", "change"], "edit-2": ["pencil", "change"], "edit-3": ["pencil", "change"], "eye": ["view", "watch"], "eye-off": ["view", "watch", "hide", "hidden"], "external-link": ["outbound"], "facebook": ["logo", "social"], "fast-forward": ["music"], "figma": ["logo", "design", "tool"], "file-minus": ["delete", "remove", "erase"], "file-plus": ["add", "create", "new"], "file-text": ["data", "txt", "pdf"], "film": ["movie", "video"], "filter": ["funnel", "hopper"], "flag": ["report"], "folder-minus": ["directory"], "folder-plus": ["directory"], "folder": ["directory"], "framer": ["logo", "design", "tool"], "frown": ["emoji", "face", "bad", "sad", "emotion"], "gift": ["present", "box", "birthday", "party"], "git-branch": ["code", "version control"], "git-commit": ["code", "version control"], "git-merge": ["code", "version control"], "git-pull-request": ["code", "version control"], "github": ["logo", "version control"], "gitlab": ["logo", "version control"], "globe": ["world", "browser", "language", "translate"], "hard-drive": ["computer", "server", "memory", "data"], "hash": ["hashtag", "number", "pound"], "headphones": ["music", "audio", "sound"], "heart": ["like", "love", "emotion"], "help-circle": ["question mark"], "hexagon": ["shape", "node.js", "logo"], "home": ["house", "living"], "image": ["picture"], "inbox": ["email"], "instagram": ["logo", "camera"], "key": ["password", "login", "authentication", "secure"], "layers": ["stack"], "layout": ["window", "webpage"], "life-bouy": ["help", "life ring", "support"], "link": ["chain", "url"], "link-2": ["chain", "url"], "linkedin": ["logo", "social media"], "list": ["options"], "lock": ["security", "password", "secure"], "log-in": ["sign in", "arrow", "enter"], "log-out": ["sign out", "arrow", "exit"], "mail": ["email", "message"], "map-pin": ["location", "navigation", "travel", "marker"], "map": ["location", "navigation", "travel"], "maximize": ["fullscreen"], "maximize-2": ["fullscreen", "arrows", "expand"], "meh": ["emoji", "face", "neutral", "emotion"], "menu": ["bars", "navigation", "hamburger"], "message-circle": ["comment", "chat"], "message-square": ["comment", "chat"], "mic-off": ["record", "sound", "mute"], "mic": ["record", "sound", "listen"], "minimize": ["exit fullscreen", "close"], "minimize-2": ["exit fullscreen", "arrows", "close"], "minus": ["subtract"], "monitor": ["tv", "screen", "display"], "moon": ["dark", "night"], "more-horizontal": ["ellipsis"], "more-vertical": ["ellipsis"], "mouse-pointer": ["arrow", "cursor"], "move": ["arrows"], "music": ["note"], "navigation": ["location", "travel"], "navigation-2": ["location", "travel"], "octagon": ["stop"], "package": ["box", "container"], "paperclip": ["attachment"], "pause": ["music", "stop"], "pause-circle": ["music", "audio", "stop"], "pen-tool": ["vector", "drawing"], "percent": ["discount"], "phone-call": ["ring"], "phone-forwarded": ["call"], "phone-incoming": ["call"], "phone-missed": ["call"], "phone-off": ["call", "mute"], "phone-outgoing": ["call"], "phone": ["call"], "play": ["music", "start"], "pie-chart": ["statistics", "diagram"], "play-circle": ["music", "start"], "plus": ["add", "new"], "plus-circle": ["add", "new"], "plus-square": ["add", "new"], "pocket": ["logo", "save"], "power": ["on", "off"], "printer": ["fax", "office", "device"], "radio": ["signal"], "refresh-cw": ["synchronise", "arrows"], "refresh-ccw": ["arrows"], "repeat": ["loop", "arrows"], "rewind": ["music"], "rotate-ccw": ["arrow"], "rotate-cw": ["arrow"], "rss": ["feed", "subscribe"], "save": ["floppy disk"], "scissors": ["cut"], "search": ["find", "magnifier", "magnifying glass"], "send": ["message", "mail", "email", "paper airplane", "paper aeroplane"], "settings": ["cog", "edit", "gear", "preferences"], "share-2": ["network", "connections"], "shield": ["security", "secure"], "shield-off": ["security", "insecure"], "shopping-bag": ["ecommerce", "cart", "purchase", "store"], "shopping-cart": ["ecommerce", "cart", "purchase", "store"], "shuffle": ["music"], "skip-back": ["music"], "skip-forward": ["music"], "slack": ["logo"], "slash": ["ban", "no"], "sliders": ["settings", "controls"], "smartphone": ["cellphone", "device"], "smile": ["emoji", "face", "happy", "good", "emotion"], "speaker": ["audio", "music"], "star": ["bookmark", "favorite", "like"], "stop-circle": ["media", "music"], "sun": ["brightness", "weather", "light"], "sunrise": ["weather", "time", "morning", "day"], "sunset": ["weather", "time", "evening", "night"], "tablet": ["device"], "tag": ["label"], "target": ["logo", "bullseye"], "terminal": ["code", "command line", "prompt"], "thermometer": ["temperature", "celsius", "fahrenheit", "weather"], "thumbs-down": ["dislike", "bad", "emotion"], "thumbs-up": ["like", "good", "emotion"], "toggle-left": ["on", "off", "switch"], "toggle-right": ["on", "off", "switch"], "tool": ["settings", "spanner"], "trash": ["garbage", "delete", "remove", "bin"], "trash-2": ["garbage", "delete", "remove", "bin"], "triangle": ["delta"], "truck": ["delivery", "van", "shipping", "transport", "lorry"], "tv": ["television", "stream"], "twitch": ["logo"], "twitter": ["logo", "social"], "type": ["text"], "umbrella": ["rain", "weather"], "unlock": ["security"], "user-check": ["followed", "subscribed"], "user-minus": ["delete", "remove", "unfollow", "unsubscribe"], "user-plus": ["new", "add", "create", "follow", "subscribe"], "user-x": ["delete", "remove", "unfollow", "unsubscribe", "unavailable"], "user": ["person", "account"], "users": ["group"], "video-off": ["camera", "movie", "film"], "video": ["camera", "movie", "film"], "voicemail": ["phone"], "volume": ["music", "sound", "mute"], "volume-1": ["music", "sound"], "volume-2": ["music", "sound"], "volume-x": ["music", "sound", "mute"], "watch": ["clock", "time"], "wifi-off": ["disabled"], "wifi": ["connection", "signal", "wireless"], "wind": ["weather", "air"], "x-circle": ["cancel", "close", "delete", "remove", "times", "clear"], "x-octagon": ["delete", "stop", "alert", "warning", "times", "clear"], "x-square": ["cancel", "close", "delete", "remove", "times", "clear"], "x": ["cancel", "close", "delete", "remove", "times", "clear"], "youtube": ["logo", "video", "play"], "zap-off": ["flash", "camera", "lightning"], "zap": ["flash", "camera", "lightning"], "zoom-in": ["magnifying glass"], "zoom-out": ["magnifying glass"] }; + module3.exports = { "activity": ["pulse", "health", "action", "motion"], "airplay": ["stream", "cast", "mirroring"], "alert-circle": ["warning", "alert", "danger"], "alert-octagon": ["warning", "alert", "danger"], "alert-triangle": ["warning", "alert", "danger"], "align-center": ["text alignment", "center"], "align-justify": ["text alignment", "justified"], "align-left": ["text alignment", "left"], "align-right": ["text alignment", "right"], "anchor": [], "archive": ["index", "box"], "at-sign": ["mention", "at", "email", "message"], "award": ["achievement", "badge"], "aperture": ["camera", "photo"], "bar-chart": ["statistics", "diagram", "graph"], "bar-chart-2": ["statistics", "diagram", "graph"], "battery": ["power", "electricity"], "battery-charging": ["power", "electricity"], "bell": ["alarm", "notification", "sound"], "bell-off": ["alarm", "notification", "silent"], "bluetooth": ["wireless"], "book-open": ["read", "library"], "book": ["read", "dictionary", "booklet", "magazine", "library"], "bookmark": ["read", "clip", "marker", "tag"], "box": ["cube"], "briefcase": ["work", "bag", "baggage", "folder"], "calendar": ["date"], "camera": ["photo"], "cast": ["chromecast", "airplay"], "chevron-down": ["expand"], "chevron-up": ["collapse"], "circle": ["off", "zero", "record"], "clipboard": ["copy"], "clock": ["time", "watch", "alarm"], "cloud-drizzle": ["weather", "shower"], "cloud-lightning": ["weather", "bolt"], "cloud-rain": ["weather"], "cloud-snow": ["weather", "blizzard"], "cloud": ["weather"], "codepen": ["logo"], "codesandbox": ["logo"], "code": ["source", "programming"], "coffee": ["drink", "cup", "mug", "tea", "cafe", "hot", "beverage"], "columns": ["layout"], "command": ["keyboard", "cmd", "terminal", "prompt"], "compass": ["navigation", "safari", "travel", "direction"], "copy": ["clone", "duplicate"], "corner-down-left": ["arrow", "return"], "corner-down-right": ["arrow"], "corner-left-down": ["arrow"], "corner-left-up": ["arrow"], "corner-right-down": ["arrow"], "corner-right-up": ["arrow"], "corner-up-left": ["arrow"], "corner-up-right": ["arrow"], "cpu": ["processor", "technology"], "credit-card": ["purchase", "payment", "cc"], "crop": ["photo", "image"], "crosshair": ["aim", "target"], "database": ["storage", "memory"], "delete": ["remove"], "disc": ["album", "cd", "dvd", "music"], "dollar-sign": ["currency", "money", "payment"], "droplet": ["water"], "edit": ["pencil", "change"], "edit-2": ["pencil", "change"], "edit-3": ["pencil", "change"], "eye": ["view", "watch"], "eye-off": ["view", "watch", "hide", "hidden"], "external-link": ["outbound"], "facebook": ["logo", "social"], "fast-forward": ["music"], "figma": ["logo", "design", "tool"], "file-minus": ["delete", "remove", "erase"], "file-plus": ["add", "create", "new"], "file-text": ["data", "txt", "pdf"], "film": ["movie", "video"], "filter": ["funnel", "hopper"], "flag": ["report"], "folder-minus": ["directory"], "folder-plus": ["directory"], "folder": ["directory"], "framer": ["logo", "design", "tool"], "frown": ["emoji", "face", "bad", "sad", "emotion"], "gift": ["present", "box", "birthday", "party"], "git-branch": ["code", "version control"], "git-commit": ["code", "version control"], "git-merge": ["code", "version control"], "git-pull-request": ["code", "version control"], "github": ["logo", "version control"], "gitlab": ["logo", "version control"], "globe": ["world", "browser", "language", "translate"], "hard-drive": ["computer", "server", "memory", "data"], "hash": ["hashtag", "number", "pound"], "headphones": ["music", "audio", "sound"], "heart": ["like", "love", "emotion"], "help-circle": ["question mark"], "hexagon": ["shape", "node.js", "logo"], "home": ["house", "living"], "image": ["picture"], "inbox": ["email"], "instagram": ["logo", "camera"], "key": ["password", "login", "authentication", "secure"], "layers": ["stack"], "layout": ["window", "webpage"], "life-buoy": ["help", "life ring", "support"], "link": ["chain", "url"], "link-2": ["chain", "url"], "linkedin": ["logo", "social media"], "list": ["options"], "lock": ["security", "password", "secure"], "log-in": ["sign in", "arrow", "enter"], "log-out": ["sign out", "arrow", "exit"], "mail": ["email", "message"], "map-pin": ["location", "navigation", "travel", "marker"], "map": ["location", "navigation", "travel"], "maximize": ["fullscreen"], "maximize-2": ["fullscreen", "arrows", "expand"], "meh": ["emoji", "face", "neutral", "emotion"], "menu": ["bars", "navigation", "hamburger"], "message-circle": ["comment", "chat"], "message-square": ["comment", "chat"], "mic-off": ["record", "sound", "mute"], "mic": ["record", "sound", "listen"], "minimize": ["exit fullscreen", "close"], "minimize-2": ["exit fullscreen", "arrows", "close"], "minus": ["subtract"], "monitor": ["tv", "screen", "display"], "moon": ["dark", "night"], "more-horizontal": ["ellipsis"], "more-vertical": ["ellipsis"], "mouse-pointer": ["arrow", "cursor"], "move": ["arrows"], "music": ["note"], "navigation": ["location", "travel"], "navigation-2": ["location", "travel"], "octagon": ["stop"], "package": ["box", "container"], "paperclip": ["attachment"], "pause": ["music", "stop"], "pause-circle": ["music", "audio", "stop"], "pen-tool": ["vector", "drawing"], "percent": ["discount"], "phone-call": ["ring"], "phone-forwarded": ["call"], "phone-incoming": ["call"], "phone-missed": ["call"], "phone-off": ["call", "mute"], "phone-outgoing": ["call"], "phone": ["call"], "play": ["music", "start"], "pie-chart": ["statistics", "diagram"], "play-circle": ["music", "start"], "plus": ["add", "new"], "plus-circle": ["add", "new"], "plus-square": ["add", "new"], "pocket": ["logo", "save"], "power": ["on", "off"], "printer": ["fax", "office", "device"], "radio": ["signal"], "refresh-cw": ["synchronise", "arrows"], "refresh-ccw": ["arrows"], "repeat": ["loop", "arrows"], "rewind": ["music"], "rotate-ccw": ["arrow"], "rotate-cw": ["arrow"], "rss": ["feed", "subscribe"], "save": ["floppy disk"], "scissors": ["cut"], "search": ["find", "magnifier", "magnifying glass"], "send": ["message", "mail", "email", "paper airplane", "paper aeroplane"], "settings": ["cog", "edit", "gear", "preferences"], "share-2": ["network", "connections"], "shield": ["security", "secure"], "shield-off": ["security", "insecure"], "shopping-bag": ["ecommerce", "cart", "purchase", "store"], "shopping-cart": ["ecommerce", "cart", "purchase", "store"], "shuffle": ["music"], "skip-back": ["music"], "skip-forward": ["music"], "slack": ["logo"], "slash": ["ban", "no"], "sliders": ["settings", "controls"], "smartphone": ["cellphone", "device"], "smile": ["emoji", "face", "happy", "good", "emotion"], "speaker": ["audio", "music"], "star": ["bookmark", "favorite", "like"], "stop-circle": ["media", "music"], "sun": ["brightness", "weather", "light"], "sunrise": ["weather", "time", "morning", "day"], "sunset": ["weather", "time", "evening", "night"], "tablet": ["device"], "tag": ["label"], "target": ["logo", "bullseye"], "terminal": ["code", "command line", "prompt"], "thermometer": ["temperature", "celsius", "fahrenheit", "weather"], "thumbs-down": ["dislike", "bad", "emotion"], "thumbs-up": ["like", "good", "emotion"], "toggle-left": ["on", "off", "switch"], "toggle-right": ["on", "off", "switch"], "tool": ["settings", "spanner"], "trash": ["garbage", "delete", "remove", "bin"], "trash-2": ["garbage", "delete", "remove", "bin"], "triangle": ["delta"], "truck": ["delivery", "van", "shipping", "transport", "lorry"], "tv": ["television", "stream"], "twitch": ["logo"], "twitter": ["logo", "social"], "type": ["text"], "umbrella": ["rain", "weather"], "unlock": ["security"], "user-check": ["followed", "subscribed"], "user-minus": ["delete", "remove", "unfollow", "unsubscribe"], "user-plus": ["new", "add", "create", "follow", "subscribe"], "user-x": ["delete", "remove", "unfollow", "unsubscribe", "unavailable"], "user": ["person", "account"], "users": ["group"], "video-off": ["camera", "movie", "film"], "video": ["camera", "movie", "film"], "voicemail": ["phone"], "volume": ["music", "sound", "mute"], "volume-1": ["music", "sound"], "volume-2": ["music", "sound"], "volume-x": ["music", "sound", "mute"], "watch": ["clock", "time"], "wifi-off": ["disabled"], "wifi": ["connection", "signal", "wireless"], "wind": ["weather", "air"], "x-circle": ["cancel", "close", "delete", "remove", "times", "clear"], "x-octagon": ["delete", "stop", "alert", "warning", "times", "clear"], "x-square": ["cancel", "close", "delete", "remove", "times", "clear"], "x": ["cancel", "close", "delete", "remove", "times", "clear"], "youtube": ["logo", "video", "play"], "zap-off": ["flash", "camera", "lightning"], "zap": ["flash", "camera", "lightning"], "zoom-in": ["magnifying glass"], "zoom-out": ["magnifying glass"] }; } ), /***/ @@ -15812,7 +15802,7 @@ __export(main_exports, { module.exports = __toCommonJS(main_exports); init_polyfill_buffer(); -// node_modules/.pnpm/isomorphic-git@1.24.2/node_modules/isomorphic-git/index.js +// node_modules/.pnpm/isomorphic-git@1.24.5/node_modules/isomorphic-git/index.js init_polyfill_buffer(); var import_async_lock = __toESM(require_async_lock(), 1); var import_sha1 = __toESM(require_sha1(), 1); @@ -19132,6 +19122,15 @@ async function rmRecursive(fs, filepath) { await fs.rmdir(filepath); } } +function isPromiseLike(obj) { + return isObject(obj) && isFunction(obj.then) && isFunction(obj.catch); +} +function isObject(obj) { + return obj && typeof obj === "object"; +} +function isFunction(obj) { + return typeof obj === "function"; +} function isPromiseFs(fs) { const test = (targetFs) => { try { @@ -19140,7 +19139,7 @@ function isPromiseFs(fs) { return e; } }; - return test(fs).constructor.name === "Promise"; + return isPromiseLike(test(fs)); } var commands = [ "readFile", @@ -21175,8 +21174,8 @@ function filterCapabilities(server, client) { } var pkg = { name: "isomorphic-git", - version: "1.24.2", - agent: "git/isomorphic-git@1.24.2" + version: "1.24.5", + agent: "git/isomorphic-git@1.24.5" }; var FIFO = class { constructor() { @@ -22076,15 +22075,19 @@ async function expandOidPacked({ } async function _expandOid({ fs, cache, gitdir, oid: short }) { const getExternalRefDelta = (oid) => _readObject({ fs, cache, gitdir, oid }); - const results1 = await expandOidLoose({ fs, gitdir, oid: short }); - const results2 = await expandOidPacked({ + const results = await expandOidLoose({ fs, gitdir, oid: short }); + const packedOids = await expandOidPacked({ fs, cache, gitdir, oid: short, getExternalRefDelta }); - const results = results1.concat(results2); + for (const packedOid of packedOids) { + if (results.indexOf(packedOid) === -1) { + results.push(packedOid); + } + } if (results.length === 1) { return results[0]; } @@ -24622,7 +24625,13 @@ async function _renameBranch({ }); await GitRefManager.writeRef({ fs, gitdir, ref: fullnewref, value }); await GitRefManager.deleteRef({ fs, gitdir, ref: fulloldref }); - if (checkout2) { + const fullCurrentBranchRef = await _currentBranch({ + fs, + gitdir, + fullname: true + }); + const isCurrentBranch = fullCurrentBranchRef === fulloldref; + if (checkout2 || isCurrentBranch) { await GitRefManager.writeSymbolicRef({ fs, gitdir, @@ -32171,8 +32180,8 @@ var ObsidianGitSettingsTab = class extends import_obsidian8.PluginSettingTab { }) ); if (!plugin.settings.setLastSaveToLastCommit) - new import_obsidian8.Setting(containerEl).setName(`Auto Backup after file change`).setDesc( - `If turned on, do auto ${commitOrBackup} every ${plugin.settings.autoSaveInterval} minutes after last change. This also prevents auto ${commitOrBackup} while editing a file. If turned off, it's independent from the last change.` + new import_obsidian8.Setting(containerEl).setName(`Auto Backup after stop editing any file`).setDesc( + `Requires the ${commitOrBackup} interval not to be 0. If turned on, do auto ${commitOrBackup} every ${plugin.settings.autoSaveInterval} minutes after stop editing any file. This also prevents auto ${commitOrBackup} while editing a file. If turned off, it's independent from the last change.` ).addToggle( (toggle) => toggle.setValue(plugin.settings.autoBackupAfterFileChange).onChange((value) => { plugin.settings.autoBackupAfterFileChange = value; @@ -34332,13 +34341,13 @@ var LocalStorageSettings = class { // src/ui/diff/diffView.ts init_polyfill_buffer(); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/diff2html.js init_polyfill_buffer(); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff-parser.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/diff-parser.js init_polyfill_buffer(); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/types.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/types.js init_polyfill_buffer(); var LineType; (function(LineType2) { @@ -34360,7 +34369,7 @@ var DiffStyleType = { CHAR: "char" }; -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/utils.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/utils.js init_polyfill_buffer(); var specials = [ "-", @@ -34388,8 +34397,8 @@ function unifyPath(path2) { return path2 ? path2.replace(/\\/g, "/") : path2; } function hashCode(text2) { - var i, chr, len; - var hash2 = 0; + let i, chr, len; + let hash2 = 0; for (i = 0, len = text2.length; i < len; i++) { chr = text2.charCodeAt(i); hash2 = (hash2 << 5) - hash2 + chr; @@ -34398,36 +34407,21 @@ function hashCode(text2) { return hash2; } -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff-parser.js -var __spreadArray = function(to, from, pack) { - if (pack || arguments.length === 2) - for (var i = 0, l = from.length, ar; i < l; i++) { - if (ar || !(i in from)) { - if (!ar) - ar = Array.prototype.slice.call(from, 0, i); - ar[i] = from[i]; - } - } - return to.concat(ar || Array.prototype.slice.call(from)); -}; +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/diff-parser.js function getExtension(filename, language) { - var filenameParts = filename.split("."); + const filenameParts = filename.split("."); return filenameParts.length > 1 ? filenameParts[filenameParts.length - 1] : language; } function startsWithAny(str, prefixes) { - return prefixes.reduce(function(startsWith, prefix) { - return startsWith || str.startsWith(prefix); - }, false); + return prefixes.reduce((startsWith, prefix) => startsWith || str.startsWith(prefix), false); } var baseDiffFilenamePrefixes = ["a/", "b/", "i/", "w/", "c/", "o/"]; function getFilename(line, linePrefix, extraPrefix) { - var prefixes = extraPrefix !== void 0 ? __spreadArray(__spreadArray([], baseDiffFilenamePrefixes, true), [extraPrefix], false) : baseDiffFilenamePrefixes; - var FilenameRegExp = linePrefix ? new RegExp("^".concat(escapeForRegExp(linePrefix), ' "?(.+?)"?$')) : new RegExp('^"?(.+?)"?$'); - var _a2 = FilenameRegExp.exec(line) || [], _b = _a2[1], filename = _b === void 0 ? "" : _b; - var matchingPrefix = prefixes.find(function(p) { - return filename.indexOf(p) === 0; - }); - var fnameWithoutPrefix = matchingPrefix ? filename.slice(matchingPrefix.length) : filename; + const prefixes = extraPrefix !== void 0 ? [...baseDiffFilenamePrefixes, extraPrefix] : baseDiffFilenamePrefixes; + const FilenameRegExp = linePrefix ? new RegExp(`^${escapeForRegExp(linePrefix)} "?(.+?)"?$`) : new RegExp('^"?(.+?)"?$'); + const [, filename = ""] = FilenameRegExp.exec(line) || []; + const matchingPrefix = prefixes.find((p) => filename.indexOf(p) === 0); + const fnameWithoutPrefix = matchingPrefix ? filename.slice(matchingPrefix.length) : filename; return fnameWithoutPrefix.replace(/\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}.*$/, ""); } function getSrcFilename(line, srcPrefix) { @@ -34436,39 +34430,36 @@ function getSrcFilename(line, srcPrefix) { function getDstFilename(line, dstPrefix) { return getFilename(line, "+++", dstPrefix); } -function parse(diffInput, config) { - if (config === void 0) { - config = {}; - } - var files = []; - var currentFile = null; - var currentBlock = null; - var oldLine = null; - var oldLine2 = null; - var newLine = null; - var possibleOldName = null; - var possibleNewName = null; - var oldFileNameHeader = "--- "; - var newFileNameHeader = "+++ "; - var hunkHeaderPrefix = "@@"; - var oldMode = /^old mode (\d{6})/; - var newMode = /^new mode (\d{6})/; - var deletedFileMode = /^deleted file mode (\d{6})/; - var newFileMode = /^new file mode (\d{6})/; - var copyFrom = /^copy from "?(.+)"?/; - var copyTo = /^copy to "?(.+)"?/; - var renameFrom = /^rename from "?(.+)"?/; - var renameTo = /^rename to "?(.+)"?/; - var similarityIndex = /^similarity index (\d+)%/; - var dissimilarityIndex = /^dissimilarity index (\d+)%/; - var index2 = /^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/; - var binaryFiles = /^Binary files (.*) and (.*) differ/; - var binaryDiff = /^GIT binary patch/; - var combinedIndex = /^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/; - var combinedMode = /^mode (\d{6}),(\d{6})\.\.(\d{6})/; - var combinedNewFile = /^new file mode (\d{6})/; - var combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/; - var diffLines2 = diffInput.replace(/\\ No newline at end of file/g, "").replace(/\r\n?/g, "\n").split("\n"); +function parse(diffInput, config = {}) { + const files = []; + let currentFile = null; + let currentBlock = null; + let oldLine = null; + let oldLine2 = null; + let newLine = null; + let possibleOldName = null; + let possibleNewName = null; + const oldFileNameHeader = "--- "; + const newFileNameHeader = "+++ "; + const hunkHeaderPrefix = "@@"; + const oldMode = /^old mode (\d{6})/; + const newMode = /^new mode (\d{6})/; + const deletedFileMode = /^deleted file mode (\d{6})/; + const newFileMode = /^new file mode (\d{6})/; + const copyFrom = /^copy from "?(.+)"?/; + const copyTo = /^copy to "?(.+)"?/; + const renameFrom = /^rename from "?(.+)"?/; + const renameTo = /^rename to "?(.+)"?/; + const similarityIndex = /^similarity index (\d+)%/; + const dissimilarityIndex = /^dissimilarity index (\d+)%/; + const index2 = /^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/; + const binaryFiles = /^Binary files (.*) and (.*) differ/; + const binaryDiff = /^GIT binary patch/; + const combinedIndex = /^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/; + const combinedMode = /^mode (\d{6}),(\d{6})\.\.(\d{6})/; + const combinedNewFile = /^new file mode (\d{6})/; + const combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/; + const diffLines2 = diffInput.replace(/\\ No newline at end of file/g, "").replace(/\r\n?/g, "\n").split("\n"); function saveBlock() { if (currentBlock !== null && currentFile !== null) { currentFile.blocks.push(currentBlock); @@ -34502,7 +34493,7 @@ function parse(diffInput, config) { } function startBlock(line) { saveBlock(); - var values; + let values; if (currentFile !== null) { if (values = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@.*/.exec(line)) { currentFile.isCombined = false; @@ -34533,11 +34524,11 @@ function parse(diffInput, config) { function createLine(line) { if (currentFile === null || currentBlock === null || oldLine === null || newLine === null) return; - var currentLine = { + const currentLine = { content: line }; - var addedPrefixes = currentFile.isCombined ? ["+ ", " +", "++"] : ["+"]; - var deletedPrefixes = currentFile.isCombined ? ["- ", " -", "--"] : ["-"]; + const addedPrefixes = currentFile.isCombined ? ["+ ", " +", "++"] : ["+"]; + const deletedPrefixes = currentFile.isCombined ? ["- ", " -", "--"] : ["-"]; if (startsWithAny(line, addedPrefixes)) { currentFile.addedLines++; currentLine.type = LineType.INSERT; @@ -34556,7 +34547,7 @@ function parse(diffInput, config) { currentBlock.lines.push(currentLine); } function existHunkHeader(line, lineIdx) { - var idx = lineIdx; + let idx = lineIdx; while (idx < diffLines2.length - 3) { if (line.startsWith("diff")) { return false; @@ -34568,17 +34559,17 @@ function parse(diffInput, config) { } return false; } - diffLines2.forEach(function(line, lineIndex) { + diffLines2.forEach((line, lineIndex) => { if (!line || line.startsWith("*")) { return; } - var values; - var prevLine = diffLines2[lineIndex - 1]; - var nxtLine = diffLines2[lineIndex + 1]; - var afterNxtLine = diffLines2[lineIndex + 2]; + let values; + const prevLine = diffLines2[lineIndex - 1]; + const nxtLine = diffLines2[lineIndex + 1]; + const afterNxtLine = diffLines2[lineIndex + 2]; if (line.startsWith("diff --git") || line.startsWith("diff --combined")) { startFile(); - var gitDiffStart = /^diff --git "?([a-ciow]\/.+)"? "?([a-ciow]\/.+)"?/; + const gitDiffStart = /^diff --git "?([a-ciow]\/.+)"? "?([a-ciow]\/.+)"?/; if (values = gitDiffStart.exec(line)) { possibleOldName = getFilename(values[1], void 0, config.dstPrefix); possibleNewName = getFilename(values[2], void 0, config.srcPrefix); @@ -34591,7 +34582,7 @@ function parse(diffInput, config) { } if (line.startsWith("Binary files") && !(currentFile === null || currentFile === void 0 ? void 0 : currentFile.isGitDiff)) { startFile(); - var unixDiffBinaryStart = /^Binary files "?([a-ciow]\/.+)"? and "?([a-ciow]\/.+)"? differ/; + const unixDiffBinaryStart = /^Binary files "?([a-ciow]\/.+)"? and "?([a-ciow]\/.+)"? differ/; if (values = unixDiffBinaryStart.exec(line)) { possibleOldName = getFilename(values[1], void 0, config.dstPrefix); possibleNewName = getFilename(values[2], void 0, config.srcPrefix); @@ -34614,7 +34605,7 @@ function parse(diffInput, config) { currentFile.deletedLines = 0; currentFile.blocks = []; currentBlock = null; - var message = typeof config.diffTooBigMessage === "function" ? config.diffTooBigMessage(files.length) : "Diff too big to be displayed"; + const message = typeof config.diffTooBigMessage === "function" ? config.diffTooBigMessage(files.length) : "Diff too big to be displayed"; startBlock(message); return; } @@ -34638,7 +34629,7 @@ function parse(diffInput, config) { createLine(line); return; } - var doesNotExistHunkHeader = !existHunkHeader(line, lineIndex); + const doesNotExistHunkHeader = !existHunkHeader(line, lineIndex); if (currentFile === null) { throw new Error("Where is my file !!!"); } @@ -34707,13 +34698,13 @@ function parse(diffInput, config) { return files; } -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/file-list-renderer.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/file-list-renderer.js init_polyfill_buffer(); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/render-utils.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/render-utils.js init_polyfill_buffer(); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/rematch.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/rematch.js init_polyfill_buffer(); function levenshtein(a, b) { if (a.length === 0) { @@ -34722,12 +34713,12 @@ function levenshtein(a, b) { if (b.length === 0) { return a.length; } - var matrix = []; - var i; + const matrix = []; + let i; for (i = 0; i <= b.length; i++) { matrix[i] = [i]; } - var j; + let j; for (j = 0; j <= a.length; j++) { matrix[0][j] = j; } @@ -34743,24 +34734,21 @@ function levenshtein(a, b) { return matrix[b.length][a.length]; } function newDistanceFn(str) { - return function(x, y) { - var xValue = str(x).trim(); - var yValue = str(y).trim(); - var lev = levenshtein(xValue, yValue); + return (x, y) => { + const xValue = str(x).trim(); + const yValue = str(y).trim(); + const lev = levenshtein(xValue, yValue); return lev / (xValue.length + yValue.length); }; } function newMatcherFn(distance2) { - function findBestMatch(a, b, cache) { - if (cache === void 0) { - cache = /* @__PURE__ */ new Map(); - } - var bestMatchDist = Infinity; - var bestMatch; - for (var i = 0; i < a.length; ++i) { - for (var j = 0; j < b.length; ++j) { - var cacheKey = JSON.stringify([a[i], b[j]]); - var md = void 0; + function findBestMatch(a, b, cache = /* @__PURE__ */ new Map()) { + let bestMatchDist = Infinity; + let bestMatch; + for (let i = 0; i < a.length; ++i) { + for (let j = 0; j < b.length; ++j) { + const cacheKey = JSON.stringify([a[i], b[j]]); + let md; if (!(cache.has(cacheKey) && (md = cache.get(cacheKey)))) { md = distance2(a[i], b[j]); cache.set(cacheKey, md); @@ -34773,29 +34761,23 @@ function newMatcherFn(distance2) { } return bestMatch; } - function group(a, b, level, cache) { - if (level === void 0) { - level = 0; - } - if (cache === void 0) { - cache = /* @__PURE__ */ new Map(); - } - var bm = findBestMatch(a, b, cache); + function group(a, b, level = 0, cache = /* @__PURE__ */ new Map()) { + const bm = findBestMatch(a, b, cache); if (!bm || a.length + b.length < 3) { return [[a, b]]; } - var a1 = a.slice(0, bm.indexA); - var b1 = b.slice(0, bm.indexB); - var aMatch = [a[bm.indexA]]; - var bMatch = [b[bm.indexB]]; - var tailA = bm.indexA + 1; - var tailB = bm.indexB + 1; - var a2 = a.slice(tailA); - var b2 = b.slice(tailB); - var group1 = group(a1, b1, level + 1, cache); - var groupMatch = group(aMatch, bMatch, level + 1, cache); - var group2 = group(a2, b2, level + 1, cache); - var result = groupMatch; + const a1 = a.slice(0, bm.indexA); + const b1 = b.slice(0, bm.indexB); + const aMatch = [a[bm.indexA]]; + const bMatch = [b[bm.indexB]]; + const tailA = bm.indexA + 1; + const tailB = bm.indexB + 1; + const a2 = a.slice(tailA); + const b2 = b.slice(tailB); + const group1 = group(a1, b1, level + 1, cache); + const groupMatch = group(aMatch, bMatch, level + 1, cache); + const group2 = group(a2, b2, level + 1, cache); + let result = groupMatch; if (bm.indexA > 0 || bm.indexB > 0) { result = group1.concat(result); } @@ -34807,19 +34789,7 @@ function newMatcherFn(distance2) { return group; } -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/render-utils.js -var __assign = function() { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) - if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/render-utils.js var CSSLineClass = { INSERTS: "d2h-ins", DELETES: "d2h-del", @@ -34835,9 +34805,7 @@ var defaultRenderConfig = { diffStyle: DiffStyleType.WORD }; var separator = "/"; -var distance = newDistanceFn(function(change) { - return change.value; -}); +var distance = newDistanceFn((change) => change.value); var matcher = newMatcherFn(distance); function isDevNullName(name) { return name.indexOf("dev/null") !== -1; @@ -34864,29 +34832,26 @@ function prefixLength(isCombined) { function escapeForHtml(str) { return str.slice(0).replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'").replace(/\//g, "/"); } -function deconstructLine(line, isCombined, escape) { - if (escape === void 0) { - escape = true; - } - var indexToSplit = prefixLength(isCombined); +function deconstructLine(line, isCombined, escape = true) { + const indexToSplit = prefixLength(isCombined); return { prefix: line.substring(0, indexToSplit), content: escape ? escapeForHtml(line.substring(indexToSplit)) : line.substring(indexToSplit) }; } function filenameDiff(file) { - var oldFilename = unifyPath(file.oldName); - var newFilename = unifyPath(file.newName); + const oldFilename = unifyPath(file.oldName); + const newFilename = unifyPath(file.newName); if (oldFilename !== newFilename && !isDevNullName(oldFilename) && !isDevNullName(newFilename)) { - var prefixPaths = []; - var suffixPaths = []; - var oldFilenameParts = oldFilename.split(separator); - var newFilenameParts = newFilename.split(separator); - var oldFilenamePartsSize = oldFilenameParts.length; - var newFilenamePartsSize = newFilenameParts.length; - var i = 0; - var j = oldFilenamePartsSize - 1; - var k = newFilenamePartsSize - 1; + const prefixPaths = []; + const suffixPaths = []; + const oldFilenameParts = oldFilename.split(separator); + const newFilenameParts = newFilename.split(separator); + const oldFilenamePartsSize = oldFilenameParts.length; + const newFilenamePartsSize = newFilenameParts.length; + let i = 0; + let j = oldFilenamePartsSize - 1; + let k = newFilenamePartsSize - 1; while (i < j && i < k) { if (oldFilenameParts[i] === newFilenameParts[i]) { prefixPaths.push(newFilenameParts[i]); @@ -34904,10 +34869,10 @@ function filenameDiff(file) { break; } } - var finalPrefix = prefixPaths.join(separator); - var finalSuffix = suffixPaths.join(separator); - var oldRemainingPath = oldFilenameParts.slice(i, j + 1).join(separator); - var newRemainingPath = newFilenameParts.slice(i, k + 1).join(separator); + const finalPrefix = prefixPaths.join(separator); + const finalSuffix = suffixPaths.join(separator); + const oldRemainingPath = oldFilenameParts.slice(i, j + 1).join(separator); + const newRemainingPath = newFilenameParts.slice(i, k + 1).join(separator); if (finalPrefix.length && finalSuffix.length) { return finalPrefix + separator + "{" + oldRemainingPath + " \u2192 " + newRemainingPath + "}" + separator + finalSuffix; } else if (finalPrefix.length) { @@ -34923,10 +34888,10 @@ function filenameDiff(file) { } } function getHtmlId(file) { - return "d2h-".concat(hashCode(filenameDiff(file)).toString().slice(-6)); + return `d2h-${hashCode(filenameDiff(file)).toString().slice(-6)}`; } function getFileIcon(file) { - var templateName = "file-changed"; + let templateName = "file-changed"; if (file.isRename) { templateName = "file-renamed"; } else if (file.isCopy) { @@ -34940,13 +34905,10 @@ function getFileIcon(file) { } return templateName; } -function diffHighlight(diffLine1, diffLine2, isCombined, config) { - if (config === void 0) { - config = {}; - } - var _a2 = __assign(__assign({}, defaultRenderConfig), config), matching = _a2.matching, maxLineLengthHighlight = _a2.maxLineLengthHighlight, matchWordsThreshold = _a2.matchWordsThreshold, diffStyle = _a2.diffStyle; - var line1 = deconstructLine(diffLine1, isCombined, false); - var line2 = deconstructLine(diffLine2, isCombined, false); +function diffHighlight(diffLine1, diffLine2, isCombined, config = {}) { + const { matching, maxLineLengthHighlight, matchWordsThreshold, diffStyle } = Object.assign(Object.assign({}, defaultRenderConfig), config); + const line1 = deconstructLine(diffLine1, isCombined, false); + const line2 = deconstructLine(diffLine2, isCombined, false); if (line1.content.length > maxLineLengthHighlight || line2.content.length > maxLineLengthHighlight) { return { oldLine: { @@ -34959,19 +34921,15 @@ function diffHighlight(diffLine1, diffLine2, isCombined, config) { } }; } - var diff2 = diffStyle === "char" ? diffChars(line1.content, line2.content) : diffWordsWithSpace(line1.content, line2.content); - var changedWords = []; + const diff2 = diffStyle === "char" ? diffChars(line1.content, line2.content) : diffWordsWithSpace(line1.content, line2.content); + const changedWords = []; if (diffStyle === "word" && matching === "words") { - var removed = diff2.filter(function(element2) { - return element2.removed; - }); - var added = diff2.filter(function(element2) { - return element2.added; - }); - var chunks = matcher(added, removed); - chunks.forEach(function(chunk) { + const removed = diff2.filter((element2) => element2.removed); + const added = diff2.filter((element2) => element2.added); + const chunks = matcher(added, removed); + chunks.forEach((chunk) => { if (chunk[0].length === 1 && chunk[1].length === 1) { - var dist = distance(chunk[0][0], chunk[1][0]); + const dist = distance(chunk[0][0], chunk[1][0]); if (dist < matchWordsThreshold) { changedWords.push(chunk[0][0]); changedWords.push(chunk[1][0]); @@ -34979,11 +34937,11 @@ function diffHighlight(diffLine1, diffLine2, isCombined, config) { } }); } - var highlightedLine = diff2.reduce(function(highlightedLine2, part) { - var elemType = part.added ? "ins" : part.removed ? "del" : null; - var addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : ""; - var escapedValue = escapeForHtml(part.value); - return elemType !== null ? "".concat(highlightedLine2, "<").concat(elemType).concat(addClass, ">").concat(escapedValue, "") : "".concat(highlightedLine2).concat(escapedValue); + const highlightedLine = diff2.reduce((highlightedLine2, part) => { + const elemType = part.added ? "ins" : part.removed ? "del" : null; + const addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : ""; + const escapedValue = escapeForHtml(part.value); + return elemType !== null ? `${highlightedLine2}<${elemType}${addClass}>${escapedValue}` : `${highlightedLine2}${escapedValue}`; }, ""); return { oldLine: { @@ -34997,75 +34955,57 @@ function diffHighlight(diffLine1, diffLine2, isCombined, config) { }; } -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/file-list-renderer.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/file-list-renderer.js var baseTemplatesPath = "file-summary"; var iconsBaseTemplatesPath = "icon"; function render(diffFiles, hoganUtils) { - var files = diffFiles.map(function(file) { - return hoganUtils.render(baseTemplatesPath, "line", { - fileHtmlId: getHtmlId(file), - oldName: file.oldName, - newName: file.newName, - fileName: filenameDiff(file), - deletedLines: "-" + file.deletedLines, - addedLines: "+" + file.addedLines - }, { - fileIcon: hoganUtils.template(iconsBaseTemplatesPath, getFileIcon(file)) - }); - }).join("\n"); + const files = diffFiles.map((file) => hoganUtils.render(baseTemplatesPath, "line", { + fileHtmlId: getHtmlId(file), + oldName: file.oldName, + newName: file.newName, + fileName: filenameDiff(file), + deletedLines: "-" + file.deletedLines, + addedLines: "+" + file.addedLines + }, { + fileIcon: hoganUtils.template(iconsBaseTemplatesPath, getFileIcon(file)) + })).join("\n"); return hoganUtils.render(baseTemplatesPath, "wrapper", { filesNumber: diffFiles.length, files }); } -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/line-by-line-renderer.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/line-by-line-renderer.js init_polyfill_buffer(); -var __assign2 = function() { - __assign2 = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) - if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign2.apply(this, arguments); -}; -var defaultLineByLineRendererConfig = __assign2(__assign2({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); +var defaultLineByLineRendererConfig = Object.assign(Object.assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); var genericTemplatesPath = "generic"; var baseTemplatesPath2 = "line-by-line"; var iconsBaseTemplatesPath2 = "icon"; var tagsBaseTemplatesPath = "tag"; -var LineByLineRenderer = function() { - function LineByLineRenderer2(hoganUtils, config) { - if (config === void 0) { - config = {}; - } +var LineByLineRenderer = class { + constructor(hoganUtils, config = {}) { this.hoganUtils = hoganUtils; - this.config = __assign2(__assign2({}, defaultLineByLineRendererConfig), config); + this.config = Object.assign(Object.assign({}, defaultLineByLineRendererConfig), config); } - LineByLineRenderer2.prototype.render = function(diffFiles) { - var _this = this; - var diffsHtml = diffFiles.map(function(file) { - var diffs; + render(diffFiles) { + const diffsHtml = diffFiles.map((file) => { + let diffs; if (file.blocks.length) { - diffs = _this.generateFileHtml(file); + diffs = this.generateFileHtml(file); } else { - diffs = _this.generateEmptyDiff(); + diffs = this.generateEmptyDiff(); } - return _this.makeFileDiffHtml(file, diffs); + return this.makeFileDiffHtml(file, diffs); }).join("\n"); return this.hoganUtils.render(genericTemplatesPath, "wrapper", { content: diffsHtml }); - }; - LineByLineRenderer2.prototype.makeFileDiffHtml = function(file, diffs) { + } + makeFileDiffHtml(file, diffs) { if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0) return ""; - var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath2, "file-diff"); - var filePathTemplate = this.hoganUtils.template(genericTemplatesPath, "file-path"); - var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath2, "file"); - var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath, getFileIcon(file)); + const fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath2, "file-diff"); + const filePathTemplate = this.hoganUtils.template(genericTemplatesPath, "file-path"); + const fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath2, "file"); + const fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath, getFileIcon(file)); return fileDiffTemplate.render({ file, fileHtmlId: getHtmlId(file), @@ -35077,38 +35017,33 @@ var LineByLineRenderer = function() { fileTag: fileTagTemplate }) }); - }; - LineByLineRenderer2.prototype.generateEmptyDiff = function() { + } + generateEmptyDiff() { return this.hoganUtils.render(genericTemplatesPath, "empty-diff", { contentClass: "d2h-code-line", CSSLineClass }); - }; - LineByLineRenderer2.prototype.generateFileHtml = function(file) { - var _this = this; - var matcher2 = newMatcherFn(newDistanceFn(function(e) { - return deconstructLine(e.content, file.isCombined).content; - })); - return file.blocks.map(function(block) { - var lines = _this.hoganUtils.render(genericTemplatesPath, "block-header", { + } + generateFileHtml(file) { + const matcher2 = newMatcherFn(newDistanceFn((e) => deconstructLine(e.content, file.isCombined).content)); + return file.blocks.map((block) => { + let lines = this.hoganUtils.render(genericTemplatesPath, "block-header", { CSSLineClass, blockHeader: file.isTooBig ? block.header : escapeForHtml(block.header), lineClass: "d2h-code-linenumber", contentClass: "d2h-code-line" }); - _this.applyLineGroupping(block).forEach(function(_a2) { - var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2]; + this.applyLineGroupping(block).forEach(([contextLines, oldLines, newLines]) => { if (oldLines.length && newLines.length && !contextLines.length) { - _this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) { - var oldLines2 = _a3[0], newLines2 = _a3[1]; - var _b2 = _this.processChangedLines(file, file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right; - lines += left2; - lines += right2; + this.applyRematchMatching(oldLines, newLines, matcher2).map(([oldLines2, newLines2]) => { + const { left, right } = this.processChangedLines(file, file.isCombined, oldLines2, newLines2); + lines += left; + lines += right; }); } else if (contextLines.length) { - contextLines.forEach(function(line) { - var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content; - lines += _this.generateSingleLineHtml(file, { + contextLines.forEach((line) => { + const { prefix, content } = deconstructLine(line.content, file.isCombined); + lines += this.generateSingleLineHtml(file, { type: CSSLineClass.CONTEXT, prefix, content, @@ -35117,7 +35052,7 @@ var LineByLineRenderer = function() { }); }); } else if (oldLines.length || newLines.length) { - var _b = _this.processChangedLines(file, file.isCombined, oldLines, newLines), left = _b.left, right = _b.right; + const { left, right } = this.processChangedLines(file, file.isCombined, oldLines, newLines); lines += left; lines += right; } else { @@ -35126,13 +35061,13 @@ var LineByLineRenderer = function() { }); return lines; }).join("\n"); - }; - LineByLineRenderer2.prototype.applyLineGroupping = function(block) { - var blockLinesGroups = []; - var oldLines = []; - var newLines = []; - for (var i = 0; i < block.lines.length; i++) { - var diffLine = block.lines[i]; + } + applyLineGroupping(block) { + const blockLinesGroups = []; + let oldLines = []; + let newLines = []; + for (let i = 0; i < block.lines.length; i++) { + const diffLine = block.lines[i]; if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) { blockLinesGroups.push([[], oldLines, newLines]); oldLines = []; @@ -35154,51 +35089,49 @@ var LineByLineRenderer = function() { newLines = []; } return blockLinesGroups; - }; - LineByLineRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) { - var comparisons = oldLines.length * newLines.length; - var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) { - return elem.content.length; - }))); - var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); + } + applyRematchMatching(oldLines, newLines, matcher2) { + const comparisons = oldLines.length * newLines.length; + const maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map((elem) => elem.content.length))); + const doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]]; - }; - LineByLineRenderer2.prototype.processChangedLines = function(file, isCombined, oldLines, newLines) { - var fileHtml = { + } + processChangedLines(file, isCombined, oldLines, newLines) { + const fileHtml = { right: "", left: "" }; - var maxLinesNumber = Math.max(oldLines.length, newLines.length); - for (var i = 0; i < maxLinesNumber; i++) { - var oldLine = oldLines[i]; - var newLine = newLines[i]; - var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; - var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? { + const maxLinesNumber = Math.max(oldLines.length, newLines.length); + for (let i = 0; i < maxLinesNumber; i++) { + const oldLine = oldLines[i]; + const newLine = newLines[i]; + const diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; + const preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? Object.assign(Object.assign({}, diff2 !== void 0 ? { prefix: diff2.oldLine.prefix, content: diff2.oldLine.content, type: CSSLineClass.DELETE_CHANGES - } : __assign2(__assign2({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { oldNumber: oldLine.oldNumber, newNumber: oldLine.newNumber }) : void 0; - var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign2(__assign2({}, diff2 !== void 0 ? { + } : Object.assign(Object.assign({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { oldNumber: oldLine.oldNumber, newNumber: oldLine.newNumber }) : void 0; + const preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? Object.assign(Object.assign({}, diff2 !== void 0 ? { prefix: diff2.newLine.prefix, content: diff2.newLine.content, type: CSSLineClass.INSERT_CHANGES - } : __assign2(__assign2({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { oldNumber: newLine.oldNumber, newNumber: newLine.newNumber }) : void 0; - var _a2 = this.generateLineHtml(file, preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right; + } : Object.assign(Object.assign({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { oldNumber: newLine.oldNumber, newNumber: newLine.newNumber }) : void 0; + const { left, right } = this.generateLineHtml(file, preparedOldLine, preparedNewLine); fileHtml.left += left; fileHtml.right += right; } return fileHtml; - }; - LineByLineRenderer2.prototype.generateLineHtml = function(file, oldLine, newLine) { + } + generateLineHtml(file, oldLine, newLine) { return { left: this.generateSingleLineHtml(file, oldLine), right: this.generateSingleLineHtml(file, newLine) }; - }; - LineByLineRenderer2.prototype.generateSingleLineHtml = function(file, line) { + } + generateSingleLineHtml(file, line) { if (line === void 0) return ""; - var lineNumberHtml = this.hoganUtils.render(baseTemplatesPath2, "numbers", { + const lineNumberHtml = this.hoganUtils.render(baseTemplatesPath2, "numbers", { oldNumber: line.oldNumber || "", newNumber: line.newNumber || "" }); @@ -35212,58 +35145,40 @@ var LineByLineRenderer = function() { line, file }); - }; - return LineByLineRenderer2; -}(); -var line_by_line_renderer_default = LineByLineRenderer; - -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/side-by-side-renderer.js -init_polyfill_buffer(); -var __assign3 = function() { - __assign3 = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) - if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign3.apply(this, arguments); + } }; -var defaultSideBySideRendererConfig = __assign3(__assign3({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); + +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/side-by-side-renderer.js +init_polyfill_buffer(); +var defaultSideBySideRendererConfig = Object.assign(Object.assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 }); var genericTemplatesPath2 = "generic"; var baseTemplatesPath3 = "side-by-side"; var iconsBaseTemplatesPath3 = "icon"; var tagsBaseTemplatesPath2 = "tag"; -var SideBySideRenderer = function() { - function SideBySideRenderer2(hoganUtils, config) { - if (config === void 0) { - config = {}; - } +var SideBySideRenderer = class { + constructor(hoganUtils, config = {}) { this.hoganUtils = hoganUtils; - this.config = __assign3(__assign3({}, defaultSideBySideRendererConfig), config); + this.config = Object.assign(Object.assign({}, defaultSideBySideRendererConfig), config); } - SideBySideRenderer2.prototype.render = function(diffFiles) { - var _this = this; - var diffsHtml = diffFiles.map(function(file) { - var diffs; + render(diffFiles) { + const diffsHtml = diffFiles.map((file) => { + let diffs; if (file.blocks.length) { - diffs = _this.generateFileHtml(file); + diffs = this.generateFileHtml(file); } else { - diffs = _this.generateEmptyDiff(); + diffs = this.generateEmptyDiff(); } - return _this.makeFileDiffHtml(file, diffs); + return this.makeFileDiffHtml(file, diffs); }).join("\n"); return this.hoganUtils.render(genericTemplatesPath2, "wrapper", { content: diffsHtml }); - }; - SideBySideRenderer2.prototype.makeFileDiffHtml = function(file, diffs) { + } + makeFileDiffHtml(file, diffs) { if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0) return ""; - var fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath3, "file-diff"); - var filePathTemplate = this.hoganUtils.template(genericTemplatesPath2, "file-path"); - var fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath3, "file"); - var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath2, getFileIcon(file)); + const fileDiffTemplate = this.hoganUtils.template(baseTemplatesPath3, "file-diff"); + const filePathTemplate = this.hoganUtils.template(genericTemplatesPath2, "file-path"); + const fileIconTemplate = this.hoganUtils.template(iconsBaseTemplatesPath3, "file"); + const fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath2, getFileIcon(file)); return fileDiffTemplate.render({ file, fileHtmlId: getHtmlId(file), @@ -35275,8 +35190,8 @@ var SideBySideRenderer = function() { fileTag: fileTagTemplate }) }); - }; - SideBySideRenderer2.prototype.generateEmptyDiff = function() { + } + generateEmptyDiff() { return { right: "", left: this.hoganUtils.render(genericTemplatesPath2, "empty-diff", { @@ -35284,30 +35199,25 @@ var SideBySideRenderer = function() { CSSLineClass }) }; - }; - SideBySideRenderer2.prototype.generateFileHtml = function(file) { - var _this = this; - var matcher2 = newMatcherFn(newDistanceFn(function(e) { - return deconstructLine(e.content, file.isCombined).content; - })); - return file.blocks.map(function(block) { - var fileHtml = { - left: _this.makeHeaderHtml(block.header, file), - right: _this.makeHeaderHtml("") + } + generateFileHtml(file) { + const matcher2 = newMatcherFn(newDistanceFn((e) => deconstructLine(e.content, file.isCombined).content)); + return file.blocks.map((block) => { + const fileHtml = { + left: this.makeHeaderHtml(block.header, file), + right: this.makeHeaderHtml("") }; - _this.applyLineGroupping(block).forEach(function(_a2) { - var contextLines = _a2[0], oldLines = _a2[1], newLines = _a2[2]; + this.applyLineGroupping(block).forEach(([contextLines, oldLines, newLines]) => { if (oldLines.length && newLines.length && !contextLines.length) { - _this.applyRematchMatching(oldLines, newLines, matcher2).map(function(_a3) { - var oldLines2 = _a3[0], newLines2 = _a3[1]; - var _b2 = _this.processChangedLines(file.isCombined, oldLines2, newLines2), left2 = _b2.left, right2 = _b2.right; - fileHtml.left += left2; - fileHtml.right += right2; + this.applyRematchMatching(oldLines, newLines, matcher2).map(([oldLines2, newLines2]) => { + const { left, right } = this.processChangedLines(file.isCombined, oldLines2, newLines2); + fileHtml.left += left; + fileHtml.right += right; }); } else if (contextLines.length) { - contextLines.forEach(function(line) { - var _a3 = deconstructLine(line.content, file.isCombined), prefix = _a3.prefix, content = _a3.content; - var _b2 = _this.generateLineHtml({ + contextLines.forEach((line) => { + const { prefix, content } = deconstructLine(line.content, file.isCombined); + const { left, right } = this.generateLineHtml({ type: CSSLineClass.CONTEXT, prefix, content, @@ -35317,12 +35227,12 @@ var SideBySideRenderer = function() { prefix, content, number: line.newNumber - }), left2 = _b2.left, right2 = _b2.right; - fileHtml.left += left2; - fileHtml.right += right2; + }); + fileHtml.left += left; + fileHtml.right += right; }); } else if (oldLines.length || newLines.length) { - var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right; + const { left, right } = this.processChangedLines(file.isCombined, oldLines, newLines); fileHtml.left += left; fileHtml.right += right; } else { @@ -35330,16 +35240,16 @@ var SideBySideRenderer = function() { } }); return fileHtml; - }).reduce(function(accomulated, html2) { + }).reduce((accomulated, html2) => { return { left: accomulated.left + html2.left, right: accomulated.right + html2.right }; }, { left: "", right: "" }); - }; - SideBySideRenderer2.prototype.applyLineGroupping = function(block) { - var blockLinesGroups = []; - var oldLines = []; - var newLines = []; - for (var i = 0; i < block.lines.length; i++) { - var diffLine = block.lines[i]; + } + applyLineGroupping(block) { + const blockLinesGroups = []; + let oldLines = []; + let newLines = []; + for (let i = 0; i < block.lines.length; i++) { + const diffLine = block.lines[i]; if (diffLine.type !== LineType.INSERT && newLines.length || diffLine.type === LineType.CONTEXT && oldLines.length > 0) { blockLinesGroups.push([[], oldLines, newLines]); oldLines = []; @@ -35361,76 +35271,72 @@ var SideBySideRenderer = function() { newLines = []; } return blockLinesGroups; - }; - SideBySideRenderer2.prototype.applyRematchMatching = function(oldLines, newLines, matcher2) { - var comparisons = oldLines.length * newLines.length; - var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function(elem) { - return elem.content.length; - }))); - var doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); + } + applyRematchMatching(oldLines, newLines, matcher2) { + const comparisons = oldLines.length * newLines.length; + const maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map((elem) => elem.content.length))); + const doMatching = comparisons < this.config.matchingMaxComparisons && maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison && (this.config.matching === "lines" || this.config.matching === "words"); return doMatching ? matcher2(oldLines, newLines) : [[oldLines, newLines]]; - }; - SideBySideRenderer2.prototype.makeHeaderHtml = function(blockHeader, file) { + } + makeHeaderHtml(blockHeader, file) { return this.hoganUtils.render(genericTemplatesPath2, "block-header", { CSSLineClass, blockHeader: (file === null || file === void 0 ? void 0 : file.isTooBig) ? blockHeader : escapeForHtml(blockHeader), lineClass: "d2h-code-side-linenumber", contentClass: "d2h-code-side-line" }); - }; - SideBySideRenderer2.prototype.processChangedLines = function(isCombined, oldLines, newLines) { - var fileHtml = { + } + processChangedLines(isCombined, oldLines, newLines) { + const fileHtml = { right: "", left: "" }; - var maxLinesNumber = Math.max(oldLines.length, newLines.length); - for (var i = 0; i < maxLinesNumber; i++) { - var oldLine = oldLines[i]; - var newLine = newLines[i]; - var diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; - var preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? { + const maxLinesNumber = Math.max(oldLines.length, newLines.length); + for (let i = 0; i < maxLinesNumber; i++) { + const oldLine = oldLines[i]; + const newLine = newLines[i]; + const diff2 = oldLine !== void 0 && newLine !== void 0 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config) : void 0; + const preparedOldLine = oldLine !== void 0 && oldLine.oldNumber !== void 0 ? Object.assign(Object.assign({}, diff2 !== void 0 ? { prefix: diff2.oldLine.prefix, content: diff2.oldLine.content, type: CSSLineClass.DELETE_CHANGES - } : __assign3(__assign3({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { number: oldLine.oldNumber }) : void 0; - var preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? __assign3(__assign3({}, diff2 !== void 0 ? { + } : Object.assign(Object.assign({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) })), { number: oldLine.oldNumber }) : void 0; + const preparedNewLine = newLine !== void 0 && newLine.newNumber !== void 0 ? Object.assign(Object.assign({}, diff2 !== void 0 ? { prefix: diff2.newLine.prefix, content: diff2.newLine.content, type: CSSLineClass.INSERT_CHANGES - } : __assign3(__assign3({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { number: newLine.newNumber }) : void 0; - var _a2 = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a2.left, right = _a2.right; + } : Object.assign(Object.assign({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) })), { number: newLine.newNumber }) : void 0; + const { left, right } = this.generateLineHtml(preparedOldLine, preparedNewLine); fileHtml.left += left; fileHtml.right += right; } return fileHtml; - }; - SideBySideRenderer2.prototype.generateLineHtml = function(oldLine, newLine) { + } + generateLineHtml(oldLine, newLine) { return { left: this.generateSingleHtml(oldLine), right: this.generateSingleHtml(newLine) }; - }; - SideBySideRenderer2.prototype.generateSingleHtml = function(line) { - var lineClass = "d2h-code-side-linenumber"; - var contentClass = "d2h-code-side-line"; + } + generateSingleHtml(line) { + const lineClass = "d2h-code-side-linenumber"; + const contentClass = "d2h-code-side-line"; return this.hoganUtils.render(genericTemplatesPath2, "line", { - type: (line === null || line === void 0 ? void 0 : line.type) || "".concat(CSSLineClass.CONTEXT, " d2h-emptyplaceholder"), - lineClass: line !== void 0 ? lineClass : "".concat(lineClass, " d2h-code-side-emptyplaceholder"), - contentClass: line !== void 0 ? contentClass : "".concat(contentClass, " d2h-code-side-emptyplaceholder"), + type: (line === null || line === void 0 ? void 0 : line.type) || `${CSSLineClass.CONTEXT} d2h-emptyplaceholder`, + lineClass: line !== void 0 ? lineClass : `${lineClass} d2h-code-side-emptyplaceholder`, + contentClass: line !== void 0 ? contentClass : `${contentClass} d2h-code-side-emptyplaceholder`, prefix: (line === null || line === void 0 ? void 0 : line.prefix) === " " ? " " : line === null || line === void 0 ? void 0 : line.prefix, content: line === null || line === void 0 ? void 0 : line.content, lineNumber: line === null || line === void 0 ? void 0 : line.number }); - }; - return SideBySideRenderer2; -}(); -var side_by_side_renderer_default = SideBySideRenderer; + } +}; -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/hoganjs-utils.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/hoganjs-utils.js init_polyfill_buffer(); var Hogan3 = __toESM(require_hogan()); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html-templates.js +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/diff2html-templates.js init_polyfill_buffer(); var Hogan2 = __toESM(require_hogan()); var defaultTemplates = {}; @@ -35835,75 +35741,43 @@ defaultTemplates["tag-file-renamed"] = new Hogan2.Template({ code: function(c, p return t.fl(); }, partials: {}, subs: {} }); -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/hoganjs-utils.js -var __assign4 = function() { - __assign4 = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) - if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign4.apply(this, arguments); -}; -var HoganJsUtils = function() { - function HoganJsUtils2(_a2) { - var _b = _a2.compiledTemplates, compiledTemplates = _b === void 0 ? {} : _b, _c = _a2.rawTemplates, rawTemplates = _c === void 0 ? {} : _c; - var compiledRawTemplates = Object.entries(rawTemplates).reduce(function(previousTemplates, _a3) { - var _b2; - var name = _a3[0], templateString = _a3[1]; - var compiledTemplate = Hogan3.compile(templateString, { asString: false }); - return __assign4(__assign4({}, previousTemplates), (_b2 = {}, _b2[name] = compiledTemplate, _b2)); +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/hoganjs-utils.js +var HoganJsUtils = class { + constructor({ compiledTemplates = {}, rawTemplates = {} }) { + const compiledRawTemplates = Object.entries(rawTemplates).reduce((previousTemplates, [name, templateString]) => { + const compiledTemplate = Hogan3.compile(templateString, { asString: false }); + return Object.assign(Object.assign({}, previousTemplates), { [name]: compiledTemplate }); }, {}); - this.preCompiledTemplates = __assign4(__assign4(__assign4({}, defaultTemplates), compiledTemplates), compiledRawTemplates); + this.preCompiledTemplates = Object.assign(Object.assign(Object.assign({}, defaultTemplates), compiledTemplates), compiledRawTemplates); } - HoganJsUtils2.compile = function(templateString) { + static compile(templateString) { return Hogan3.compile(templateString, { asString: false }); - }; - HoganJsUtils2.prototype.render = function(namespace, view, params, partials, indent2) { - var templateKey = this.templateKey(namespace, view); + } + render(namespace, view, params, partials, indent2) { + const templateKey = this.templateKey(namespace, view); try { - var template = this.preCompiledTemplates[templateKey]; + const template = this.preCompiledTemplates[templateKey]; return template.render(params, partials, indent2); } catch (e) { - throw new Error("Could not find template to render '".concat(templateKey, "'")); + throw new Error(`Could not find template to render '${templateKey}'`); } - }; - HoganJsUtils2.prototype.template = function(namespace, view) { - return this.preCompiledTemplates[this.templateKey(namespace, view)]; - }; - HoganJsUtils2.prototype.templateKey = function(namespace, view) { - return "".concat(namespace, "-").concat(view); - }; - return HoganJsUtils2; -}(); -var hoganjs_utils_default = HoganJsUtils; - -// node_modules/.pnpm/diff2html@3.4.35/node_modules/diff2html/lib-esm/diff2html.js -var __assign5 = function() { - __assign5 = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) - if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign5.apply(this, arguments); -}; -var defaultDiff2HtmlConfig = __assign5(__assign5(__assign5({}, defaultLineByLineRendererConfig), defaultSideBySideRendererConfig), { outputFormat: OutputFormatType.LINE_BY_LINE, drawFileList: true }); -function html(diffInput, configuration) { - if (configuration === void 0) { - configuration = {}; } - var config = __assign5(__assign5({}, defaultDiff2HtmlConfig), configuration); - var diffJson = typeof diffInput === "string" ? parse(diffInput, config) : diffInput; - var hoganUtils = new hoganjs_utils_default(config); - var fileList = config.drawFileList ? render(diffJson, hoganUtils) : ""; - var diffOutput = config.outputFormat === "side-by-side" ? new side_by_side_renderer_default(hoganUtils, config).render(diffJson) : new line_by_line_renderer_default(hoganUtils, config).render(diffJson); + template(namespace, view) { + return this.preCompiledTemplates[this.templateKey(namespace, view)]; + } + templateKey(namespace, view) { + return `${namespace}-${view}`; + } +}; + +// node_modules/.pnpm/diff2html@3.4.41/node_modules/diff2html/lib-esm/diff2html.js +var defaultDiff2HtmlConfig = Object.assign(Object.assign(Object.assign({}, defaultLineByLineRendererConfig), defaultSideBySideRendererConfig), { outputFormat: OutputFormatType.LINE_BY_LINE, drawFileList: true }); +function html(diffInput, configuration = {}) { + const config = Object.assign(Object.assign({}, defaultDiff2HtmlConfig), configuration); + const diffJson = typeof diffInput === "string" ? parse(diffInput, config) : diffInput; + const hoganUtils = new HoganJsUtils(config); + const fileList = config.drawFileList ? render(diffJson, hoganUtils) : ""; + const diffOutput = config.outputFormat === "side-by-side" ? new SideBySideRenderer(hoganUtils, config).render(diffJson) : new LineByLineRenderer(hoganUtils, config).render(diffJson); return fileList + diffOutput; } @@ -35939,8 +35813,10 @@ var DiffView = class extends import_obsidian17.ItemView { } async setState(state, result) { this.state = state; + if (import_obsidian17.Platform.isMobile) { + this.leaf.view.titleEl.textContent = this.getDisplayText(); + } await this.refresh(); - return; } getState() { return this.state; @@ -36003,13 +35879,13 @@ var import_obsidian20 = require("obsidian"); // src/ui/history/historyView.svelte init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/index.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/animations.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/animations.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/utils.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/utils.js init_polyfill_buffer(); function noop() { } @@ -36033,13 +35909,13 @@ function is_empty(obj) { return Object.keys(obj).length === 0; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/environment.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/environment.js init_polyfill_buffer(); var is_client = typeof window !== "undefined"; var now = is_client ? () => window.performance.now() : () => Date.now(); var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop; -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/loop.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/loop.js init_polyfill_buffer(); var tasks = /* @__PURE__ */ new Set(); function run_tasks(now2) { @@ -36066,23 +35942,23 @@ function loop(callback) { }; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/style_manager.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/style_manager.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dom.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/dom.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/globals.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/globals.js init_polyfill_buffer(); var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : ( // @ts-ignore Node typings have this global ); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/ResizeObserverSingleton.js var ResizeObserverSingleton = class _ResizeObserverSingleton { /** @param {ResizeObserverOptions} options */ constructor(options) { @@ -36130,7 +36006,7 @@ var ResizeObserverSingleton = class _ResizeObserverSingleton { }; ResizeObserverSingleton.entries = "WeakMap" in globals ? /* @__PURE__ */ new WeakMap() : void 0; -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dom.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/dom.js var is_hydrating = false; function start_hydrating() { is_hydrating = true; @@ -36256,7 +36132,7 @@ function get_custom_elements_slots(element2) { return result; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/style_manager.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/style_manager.js var managed_styles = /* @__PURE__ */ new Map(); var active = 0; function hash(str) { @@ -36320,16 +36196,16 @@ function clear_rules() { }); } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/await_block.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/await_block.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/transitions.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/transitions.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/scheduler.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/scheduler.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/lifecycle.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/lifecycle.js init_polyfill_buffer(); var current_component; function set_current_component(component) { @@ -36350,7 +36226,7 @@ function bubble(component, event) { } } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/scheduler.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/scheduler.js var dirty_components = []; var binding_callbacks = []; var render_callbacks = []; @@ -36425,7 +36301,7 @@ function flush_render_callbacks(fns) { render_callbacks = filtered; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/transitions.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/transitions.js var promise; function wait() { if (!promise) { @@ -36606,19 +36482,19 @@ function create_bidirectional_transition(node, fn, params, intro) { }; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/each.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/each.js init_polyfill_buffer(); function ensure_array_like(array_like_or_iterator) { return (array_like_or_iterator == null ? void 0 : array_like_or_iterator.length) !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator); } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/spread.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/spread.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/ssr.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/ssr.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/boolean_attributes.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/shared/boolean_attributes.js init_polyfill_buffer(); var _boolean_attributes = ( /** @type {const} */ @@ -36652,10 +36528,10 @@ var _boolean_attributes = ( ); var boolean_attributes = /* @__PURE__ */ new Set([..._boolean_attributes]); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/utils/names.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/shared/utils/names.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/Component.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/Component.js init_polyfill_buffer(); function create_component(block) { block && block.c(); @@ -36754,54 +36630,60 @@ if (typeof HTMLElement === "function") { SvelteElement = class extends HTMLElement { constructor($$componentCtor, $$slots, use_shadow_dom) { super(); - __publicField(this, "$$componentCtor"); - __publicField(this, "$$slots"); - __publicField(this, "$$component"); - __publicField(this, "$$connected", false); - __publicField(this, "$$data", {}); - __publicField(this, "$$reflecting", false); - /** @type {Record} */ - __publicField(this, "$$props_definition", {}); - /** @type {Record} */ - __publicField(this, "$$listeners", {}); - /** @type {Map} */ - __publicField(this, "$$listener_unsubscribe_fns", /* @__PURE__ */ new Map()); - this.$$componentCtor = $$componentCtor; - this.$$slots = $$slots; + /** The Svelte component constructor */ + __publicField(this, "$$ctor"); + /** Slots */ + __publicField(this, "$$s"); + /** The Svelte component instance */ + __publicField(this, "$$c"); + /** Whether or not the custom element is connected */ + __publicField(this, "$$cn", false); + /** Component props data */ + __publicField(this, "$$d", {}); + /** `true` if currently in the process of reflecting component props back to attributes */ + __publicField(this, "$$r", false); + /** @type {Record} Props definition (name, reflected, type etc) */ + __publicField(this, "$$p_d", {}); + /** @type {Record} Event listeners */ + __publicField(this, "$$l", {}); + /** @type {Map} Event listener unsubscribe functions */ + __publicField(this, "$$l_u", /* @__PURE__ */ new Map()); + this.$$ctor = $$componentCtor; + this.$$s = $$slots; if (use_shadow_dom) { this.attachShadow({ mode: "open" }); } } addEventListener(type, listener, options) { - this.$$listeners[type] = this.$$listeners[type] || []; - this.$$listeners[type].push(listener); - if (this.$$component) { - const unsub = this.$$component.$on(type, listener); - this.$$listener_unsubscribe_fns.set(listener, unsub); + this.$$l[type] = this.$$l[type] || []; + this.$$l[type].push(listener); + if (this.$$c) { + const unsub = this.$$c.$on(type, listener); + this.$$l_u.set(listener, unsub); } super.addEventListener(type, listener, options); } removeEventListener(type, listener, options) { super.removeEventListener(type, listener, options); - if (this.$$component) { - const unsub = this.$$listener_unsubscribe_fns.get(listener); + if (this.$$c) { + const unsub = this.$$l_u.get(listener); if (unsub) { unsub(); - this.$$listener_unsubscribe_fns.delete(listener); + this.$$l_u.delete(listener); } } } async connectedCallback() { - this.$$connected = true; - if (!this.$$component) { + this.$$cn = true; + if (!this.$$c) { let create_slot = function(name) { return () => { let node; const obj = { c: function create() { - node = document.createElement("slot"); + node = element("slot"); if (name !== "default") { - node.setAttribute("name", name); + attr(node, "name", name); } }, /** @@ -36821,73 +36703,85 @@ if (typeof HTMLElement === "function") { }; }; await Promise.resolve(); - if (!this.$$connected) { + if (!this.$$cn) { return; } const $$slots = {}; const existing_slots = get_custom_elements_slots(this); - for (const name of this.$$slots) { + for (const name of this.$$s) { if (name in existing_slots) { $$slots[name] = [create_slot(name)]; } } for (const attribute of this.attributes) { - const name = this.$$get_prop_name(attribute.name); - if (!(name in this.$$data)) { - this.$$data[name] = get_custom_element_value( - name, - attribute.value, - this.$$props_definition, - "toProp" - ); + const name = this.$$g_p(attribute.name); + if (!(name in this.$$d)) { + this.$$d[name] = get_custom_element_value(name, attribute.value, this.$$p_d, "toProp"); } } - this.$$component = new this.$$componentCtor({ + this.$$c = new this.$$ctor({ target: this.shadowRoot || this, props: { - ...this.$$data, + ...this.$$d, $$slots, $$scope: { ctx: [] } } }); - for (const type in this.$$listeners) { - for (const listener of this.$$listeners[type]) { - const unsub = this.$$component.$on(type, listener); - this.$$listener_unsubscribe_fns.set(listener, unsub); + const reflect_attributes = () => { + this.$$r = true; + for (const key2 in this.$$p_d) { + this.$$d[key2] = this.$$c.$$.ctx[this.$$c.$$.props[key2]]; + if (this.$$p_d[key2].reflect) { + const attribute_value = get_custom_element_value( + key2, + this.$$d[key2], + this.$$p_d, + "toAttribute" + ); + if (attribute_value == null) { + this.removeAttribute(key2); + } else { + this.setAttribute(this.$$p_d[key2].attribute || key2, attribute_value); + } + } + } + this.$$r = false; + }; + this.$$c.$$.after_update.push(reflect_attributes); + reflect_attributes(); + for (const type in this.$$l) { + for (const listener of this.$$l[type]) { + const unsub = this.$$c.$on(type, listener); + this.$$l_u.set(listener, unsub); } } - this.$$listeners = {}; + this.$$l = {}; } } // We don't need this when working within Svelte code, but for compatibility of people using this outside of Svelte // and setting attributes through setAttribute etc, this is helpful attributeChangedCallback(attr2, _oldValue, newValue) { var _a2; - if (this.$$reflecting) + if (this.$$r) return; - attr2 = this.$$get_prop_name(attr2); - this.$$data[attr2] = get_custom_element_value( - attr2, - newValue, - this.$$props_definition, - "toProp" - ); - (_a2 = this.$$component) == null ? void 0 : _a2.$set({ [attr2]: this.$$data[attr2] }); + attr2 = this.$$g_p(attr2); + this.$$d[attr2] = get_custom_element_value(attr2, newValue, this.$$p_d, "toProp"); + (_a2 = this.$$c) == null ? void 0 : _a2.$set({ [attr2]: this.$$d[attr2] }); } disconnectedCallback() { - this.$$connected = false; + this.$$cn = false; Promise.resolve().then(() => { - if (!this.$$connected) { - this.$$component.$destroy(); - this.$$component = void 0; + if (!this.$$cn) { + this.$$c.$destroy(); + this.$$c = void 0; } }); } - $$get_prop_name(attribute_name) { - return Object.keys(this.$$props_definition).find( - (key2) => this.$$props_definition[key2].attribute === attribute_name || !this.$$props_definition[key2].attribute && key2.toLowerCase() === attribute_name + $$g_p(attribute_name) { + return Object.keys(this.$$p_d).find( + (key2) => this.$$p_d[key2].attribute === attribute_name || !this.$$p_d[key2].attribute && key2.toLowerCase() === attribute_name ) || attribute_name; } }; @@ -36979,19 +36873,19 @@ var SvelteComponent = class { } }; -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/dev.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/dev.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/shared/version.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/shared/version.js init_polyfill_buffer(); var PUBLIC_VERSION = "4"; -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/internal/disclose-version/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/internal/disclose-version/index.js init_polyfill_buffer(); if (typeof window !== "undefined") (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(PUBLIC_VERSION); -// node_modules/.pnpm/tslib@2.6.0/node_modules/tslib/tslib.es6.mjs +// node_modules/.pnpm/tslib@2.6.2/node_modules/tslib/tslib.es6.mjs init_polyfill_buffer(); function __awaiter(thisArg, _arguments, P, generator) { function adopt(value) { @@ -37024,23 +36918,23 @@ function __awaiter(thisArg, _arguments, P, generator) { // src/ui/history/historyView.svelte var import_obsidian19 = require("obsidian"); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/index.js init_polyfill_buffer(); // src/ui/history/components/logComponent.svelte init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/transition/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/transition/index.js init_polyfill_buffer(); -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/easing/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/easing/index.js init_polyfill_buffer(); function cubicOut(t) { const f = t - 1; return f * f * f + 1; } -// node_modules/.pnpm/svelte@4.0.0/node_modules/svelte/src/runtime/transition/index.js +// node_modules/.pnpm/svelte@4.2.0/node_modules/svelte/src/runtime/transition/index.js function slide(node, { delay: delay2 = 0, duration = 400, easing = cubicOut, axis = "y" } = {}) { const style = getComputedStyle(node); const opacity = +style.opacity; @@ -37072,7 +36966,7 @@ function slide(node, { delay: delay2 = 0, duration = 400, easing = cubicOut, axi init_polyfill_buffer(); var import_obsidian18 = require("obsidian"); function add_css(target) { - append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); + append_styles(target, "svelte-1wbh8tp", "main.svelte-1wbh8tp .nav-file-title.svelte-1wbh8tp{align-items:center}"); } function create_if_block(ctx) { let div; @@ -37140,12 +37034,14 @@ function create_fragment(ctx) { ); let t3; let span_data_type_value; + let div3_data_path_value; let div3_aria_label_value; let mounted; let dispose; let if_block = show_if && create_if_block(ctx); return { c() { + var _a2, _b; main = element("main"); div3 = element("div"); div0 = element("div"); @@ -37158,13 +37054,15 @@ function create_fragment(ctx) { t2 = space(); span = element("span"); t3 = text(t3_value); - attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div0, "class", "tree-item-inner nav-file-title-content"); attr(div1, "class", "buttons"); attr(span, "class", "type"); attr(span, "data-type", span_data_type_value = /*diff*/ ctx[0].status); attr(div2, "class", "git-tools"); - attr(div3, "class", "tree-item-self is-clickable nav-file-title"); + attr(div3, "class", "tree-item-self is-clickable nav-file-title svelte-1wbh8tp"); + attr(div3, "data-path", div3_data_path_value = /*diff*/ + ctx[0].vault_path); attr( div3, "aria-label-position", @@ -37173,7 +37071,15 @@ function create_fragment(ctx) { ); attr(div3, "aria-label", div3_aria_label_value = /*diff*/ ctx[0].vault_path); - attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + toggle_class( + div3, + "is-active", + /*view*/ + ((_a2 = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*diff*/ + ctx[0].vault_path && /*view*/ + ((_b = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) + ); + attr(main, "class", "tree-item nav-file svelte-1wbh8tp"); }, m(target, anchor) { insert(target, main, anchor); @@ -37209,6 +37115,7 @@ function create_fragment(ctx) { } }, p(ctx2, [dirty]) { + var _a2, _b; if (dirty & /*diff*/ 1 && t0_value !== (t0_value = getDisplayPath( /*diff*/ @@ -37243,6 +37150,11 @@ function create_fragment(ctx) { ctx2[0].status)) { attr(span, "data-type", span_data_type_value); } + if (dirty & /*diff*/ + 1 && div3_data_path_value !== (div3_data_path_value = /*diff*/ + ctx2[0].vault_path)) { + attr(div3, "data-path", div3_data_path_value); + } if (dirty & /*side*/ 8) { attr( @@ -37257,6 +37169,17 @@ function create_fragment(ctx) { ctx2[0].vault_path)) { attr(div3, "aria-label", div3_aria_label_value); } + if (dirty & /*view, diff*/ + 3) { + toggle_class( + div3, + "is-active", + /*view*/ + ((_a2 = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*diff*/ + ctx2[0].vault_path && /*view*/ + ((_b = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) + ); + } }, i: noop, o: noop, @@ -38978,10 +38901,10 @@ var DiscardModal = class extends import_obsidian23.Modal { init_polyfill_buffer(); var import_obsidian25 = require("obsidian"); -// node_modules/.pnpm/obsidian-community-lib@2.0.2_@codemirror+state@6.2.1_@codemirror+view@6.14.0/node_modules/obsidian-community-lib/dist/index.js +// node_modules/.pnpm/github.com+Vinzent03+obsidian-community-lib@e663de4f95c879b40613090da78ea599ff621d24_@codemir_kbfcpig3uak7df3ohthcqq53p4/node_modules/obsidian-community-lib/dist/index.js init_polyfill_buffer(); -// node_modules/.pnpm/obsidian-community-lib@2.0.2_@codemirror+state@6.2.1_@codemirror+view@6.14.0/node_modules/obsidian-community-lib/dist/utils.js +// node_modules/.pnpm/github.com+Vinzent03+obsidian-community-lib@e663de4f95c879b40613090da78ea599ff621d24_@codemir_kbfcpig3uak7df3ohthcqq53p4/node_modules/obsidian-community-lib/dist/utils.js init_polyfill_buffer(); var feather = __toESM(require_feather()); var import_obsidian24 = require("obsidian"); @@ -38998,7 +38921,7 @@ function hoverPreview(event, view, to) { // src/ui/sourceControl/components/fileComponent.svelte function add_css4(target) { - append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); + append_styles(target, "svelte-1wbh8tp", "main.svelte-1wbh8tp .nav-file-title.svelte-1wbh8tp{align-items:center}"); } function create_if_block5(ctx) { let div; @@ -39070,12 +38993,14 @@ function create_fragment5(ctx) { ); let t5; let div4_data_type_value; + let div6_data_path_value; let div6_aria_label_value; let mounted; let dispose; let if_block = show_if && create_if_block5(ctx); return { c() { + var _a2, _b, _c; main = element("main"); div6 = element("div"); div0 = element("div"); @@ -39092,7 +39017,7 @@ function create_fragment5(ctx) { t4 = space(); div4 = element("div"); t5 = text(t5_value); - attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div0, "class", "tree-item-inner nav-file-title-content"); attr(div1, "data-icon", "undo"); attr(div1, "aria-label", "Discard"); attr(div1, "class", "clickable-icon"); @@ -39104,7 +39029,9 @@ function create_fragment5(ctx) { attr(div4, "data-type", div4_data_type_value = /*change*/ ctx[0].working_dir); attr(div5, "class", "git-tools"); - attr(div6, "class", "tree-item-self is-clickable nav-file-title"); + attr(div6, "class", "tree-item-self is-clickable nav-file-title svelte-1wbh8tp"); + attr(div6, "data-path", div6_data_path_value = /*change*/ + ctx[0].vault_path); attr( div6, "aria-label-position", @@ -39113,7 +39040,16 @@ function create_fragment5(ctx) { ); attr(div6, "aria-label", div6_aria_label_value = /*change*/ ctx[0].vault_path); - attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + toggle_class( + div6, + "is-active", + /*view*/ + ((_a2 = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*change*/ + ctx[0].vault_path && !/*view*/ + ((_b = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) && !/*view*/ + ((_c = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _c.staged) + ); + attr(main, "class", "tree-item nav-file svelte-1wbh8tp"); }, m(target, anchor) { insert(target, main, anchor); @@ -39169,6 +39105,7 @@ function create_fragment5(ctx) { } }, p(ctx2, [dirty]) { + var _a2, _b, _c; if (dirty & /*change*/ 1 && t0_value !== (t0_value = getDisplayPath( /*change*/ @@ -39203,6 +39140,11 @@ function create_fragment5(ctx) { ctx2[0].working_dir)) { attr(div4, "data-type", div4_data_type_value); } + if (dirty & /*change*/ + 1 && div6_data_path_value !== (div6_data_path_value = /*change*/ + ctx2[0].vault_path)) { + attr(div6, "data-path", div6_data_path_value); + } if (dirty & /*side*/ 8) { attr( @@ -39217,6 +39159,18 @@ function create_fragment5(ctx) { ctx2[0].vault_path)) { attr(div6, "aria-label", div6_aria_label_value); } + if (dirty & /*view, change*/ + 3) { + toggle_class( + div6, + "is-active", + /*view*/ + ((_a2 = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*change*/ + ctx2[0].vault_path && !/*view*/ + ((_b = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) && !/*view*/ + ((_c = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _c.staged) + ); + } }, i: noop, o: noop, @@ -39347,7 +39301,7 @@ var fileComponent_default = FileComponent; init_polyfill_buffer(); var import_obsidian26 = require("obsidian"); function add_css5(target) { - append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); + append_styles(target, "svelte-1wbh8tp", "main.svelte-1wbh8tp .nav-file-title.svelte-1wbh8tp{align-items:center}"); } function create_fragment6(ctx) { let main; @@ -39367,6 +39321,7 @@ function create_fragment6(ctx) { ); let t2; let span_data_type_value; + let div2_data_path_value; let div2_aria_label_value; let mounted; let dispose; @@ -39380,12 +39335,14 @@ function create_fragment6(ctx) { div1 = element("div"); span = element("span"); t2 = text(t2_value); - attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div0, "class", "tree-item-inner nav-file-title-content"); attr(span, "class", "type"); attr(span, "data-type", span_data_type_value = /*change*/ ctx[0].working_dir); attr(div1, "class", "git-tools"); - attr(div2, "class", "tree-item-self is-clickable nav-file-title"); + attr(div2, "class", "tree-item-self is-clickable nav-file-title svelte-1wbh8tp"); + attr(div2, "data-path", div2_data_path_value = /*change*/ + ctx[0].vault_path); attr( div2, "aria-label-position", @@ -39394,7 +39351,7 @@ function create_fragment6(ctx) { ); attr(div2, "aria-label", div2_aria_label_value = /*change*/ ctx[0].vault_path); - attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + attr(main, "class", "tree-item nav-file svelte-1wbh8tp"); }, m(target, anchor) { insert(target, main, anchor); @@ -39447,6 +39404,11 @@ function create_fragment6(ctx) { ctx2[0].working_dir)) { attr(span, "data-type", span_data_type_value); } + if (dirty & /*change*/ + 1 && div2_data_path_value !== (div2_data_path_value = /*change*/ + ctx2[0].vault_path)) { + attr(div2, "data-path", div2_data_path_value); + } if (dirty & /*side*/ 2) { attr( @@ -39519,7 +39481,7 @@ var pulledFileComponent_default = PulledFileComponent; init_polyfill_buffer(); var import_obsidian27 = require("obsidian"); function add_css6(target) { - append_styles(target, "svelte-pmbo0n", "main.svelte-pmbo0n .nav-file-title-content.svelte-pmbo0n{display:flex;align-items:center}"); + append_styles(target, "svelte-1wbh8tp", "main.svelte-1wbh8tp .nav-file-title.svelte-1wbh8tp{align-items:center}"); } function create_if_block6(ctx) { let div; @@ -39583,12 +39545,14 @@ function create_fragment7(ctx) { ); let t4; let div3_data_type_value; + let div5_data_path_value; let div5_aria_label_value; let mounted; let dispose; let if_block = show_if && create_if_block6(ctx); return { c() { + var _a2, _b, _c; main = element("main"); div5 = element("div"); div0 = element("div"); @@ -39603,7 +39567,7 @@ function create_fragment7(ctx) { t3 = space(); div3 = element("div"); t4 = text(t4_value); - attr(div0, "class", "tree-item-inner nav-file-title-content svelte-pmbo0n"); + attr(div0, "class", "tree-item-inner nav-file-title-content"); attr(div1, "data-icon", "minus"); attr(div1, "aria-label", "Unstage"); attr(div1, "class", "clickable-icon"); @@ -39612,7 +39576,9 @@ function create_fragment7(ctx) { attr(div3, "data-type", div3_data_type_value = /*change*/ ctx[0].index); attr(div4, "class", "git-tools"); - attr(div5, "class", "tree-item-self is-clickable nav-file-title"); + attr(div5, "class", "tree-item-self is-clickable nav-file-title svelte-1wbh8tp"); + attr(div5, "data-path", div5_data_path_value = /*change*/ + ctx[0].vault_path); attr( div5, "aria-label-position", @@ -39621,7 +39587,16 @@ function create_fragment7(ctx) { ); attr(div5, "aria-label", div5_aria_label_value = /*change*/ ctx[0].vault_path); - attr(main, "class", "tree-item nav-file svelte-pmbo0n"); + toggle_class( + div5, + "is-active", + /*view*/ + ((_a2 = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*change*/ + ctx[0].vault_path && !/*view*/ + ((_b = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) && /*view*/ + ((_c = ctx[1].plugin.lastDiffViewState) == null ? void 0 : _c.staged) + ); + attr(main, "class", "tree-item nav-file svelte-1wbh8tp"); }, m(target, anchor) { insert(target, main, anchor); @@ -39670,6 +39645,7 @@ function create_fragment7(ctx) { } }, p(ctx2, [dirty]) { + var _a2, _b, _c; if (dirty & /*change*/ 1 && t0_value !== (t0_value = getDisplayPath( /*change*/ @@ -39704,6 +39680,11 @@ function create_fragment7(ctx) { ctx2[0].index)) { attr(div3, "data-type", div3_data_type_value); } + if (dirty & /*change*/ + 1 && div5_data_path_value !== (div5_data_path_value = /*change*/ + ctx2[0].vault_path)) { + attr(div5, "data-path", div5_data_path_value); + } if (dirty & /*side*/ 8) { attr( @@ -39718,6 +39699,18 @@ function create_fragment7(ctx) { ctx2[0].vault_path)) { attr(div5, "aria-label", div5_aria_label_value); } + if (dirty & /*view, change*/ + 3) { + toggle_class( + div5, + "is-active", + /*view*/ + ((_a2 = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _a2.file) == /*change*/ + ctx2[0].vault_path && !/*view*/ + ((_b = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _b.hash) && /*view*/ + ((_c = ctx2[1].plugin.lastDiffViewState) == null ? void 0 : _c.staged) + ); + } }, i: noop, o: noop, @@ -39827,7 +39820,7 @@ var stagedFileComponent_default = StagedFileComponent; // src/ui/sourceControl/components/treeComponent.svelte init_polyfill_buffer(); function add_css7(target) { - append_styles(target, "svelte-1lnl15d", "main.svelte-1lnl15d .nav-folder-title-content.svelte-1lnl15d{display:flex;align-items:center}"); + append_styles(target, "svelte-hup5mn", "main.svelte-hup5mn .nav-folder-title.svelte-hup5mn{align-items:center}"); } function get_each_context4(ctx, list, i) { const child_ctx = ctx.slice(); @@ -39916,11 +39909,11 @@ function create_else_block3(ctx) { ctx[15].title ] ); - attr(div2, "class", "tree-item-inner nav-folder-title-content svelte-1lnl15d"); + attr(div2, "class", "tree-item-inner nav-folder-title-content"); set_style(div3, "width", "11px"); attr(div4, "class", "buttons"); attr(div5, "class", "git-tools"); - attr(div6, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div6, "class", "tree-item-self is-clickable nav-folder-title svelte-hup5mn"); attr( div6, "aria-label-position", @@ -40607,7 +40600,7 @@ function create_fragment8(ctx) { for (let i = 0; i < each_blocks.length; i += 1) { each_blocks[i].c(); } - attr(main, "class", "svelte-1lnl15d"); + attr(main, "class", "svelte-hup5mn"); toggle_class( main, "topLevel", @@ -40625,7 +40618,7 @@ function create_fragment8(ctx) { current = true; }, p(ctx2, [dirty]) { - if (dirty & /*hierarchy, plugin, view, fileType, FileType, closed, fold, side, unstage, stage, discard*/ + if (dirty & /*hierarchy, plugin, view, fileType, closed, fold, side, unstage, stage, discard*/ 2031) { each_value = ensure_array_like( /*hierarchy*/ @@ -40781,7 +40774,7 @@ var treeComponent_default = TreeComponent; // src/ui/sourceControl/sourceControl.svelte function add_css8(target) { - append_styles(target, "svelte-48bivb", `.commit-msg-input.svelte-48bivb.svelte-48bivb{width:100%;overflow:hidden;resize:none;padding:7px 5px;background-color:var(--background-modifier-form-field)}.git-commit-msg.svelte-48bivb.svelte-48bivb{position:relative;padding:0;width:calc(100% - var(--size-4-8));margin:4px auto}main.svelte-48bivb .git-tools .files-count.svelte-48bivb{padding-left:var(--size-2-1);width:11px;display:flex;align-items:center;justify-content:center}.git-commit-msg-clear-button.svelte-48bivb.svelte-48bivb{position:absolute;background:transparent;border-radius:50%;color:var(--search-clear-button-color);cursor:var(--cursor);top:-4px;right:2px;bottom:0px;line-height:0;height:var(--input-height);width:28px;margin:auto;padding:0 0;text-align:center;display:flex;justify-content:center;align-items:center;transition:color 0.15s ease-in-out}.git-commit-msg-clear-button.svelte-48bivb.svelte-48bivb:after{content:"";height:var(--search-clear-button-size);width:var(--search-clear-button-size);display:block;background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml,");-webkit-mask-repeat:no-repeat}`); + append_styles(target, "svelte-1bvmxec", `.commit-msg-input.svelte-1bvmxec.svelte-1bvmxec{width:100%;overflow:hidden;resize:none;padding:7px 5px;background-color:var(--background-modifier-form-field)}.git-commit-msg.svelte-1bvmxec.svelte-1bvmxec{position:relative;padding:0;width:calc(100% - var(--size-4-8));margin:4px auto}main.svelte-1bvmxec .git-tools .files-count.svelte-1bvmxec{padding-left:var(--size-2-1);width:11px;display:flex;align-items:center;justify-content:center}.nav-folder-title.svelte-1bvmxec.svelte-1bvmxec{align-items:center}.git-commit-msg-clear-button.svelte-1bvmxec.svelte-1bvmxec{position:absolute;background:transparent;border-radius:50%;color:var(--search-clear-button-color);cursor:var(--cursor);top:-4px;right:2px;bottom:0px;line-height:0;height:var(--input-height);width:28px;margin:auto;padding:0 0;text-align:center;display:flex;justify-content:center;align-items:center;transition:color 0.15s ease-in-out}.git-commit-msg-clear-button.svelte-1bvmxec.svelte-1bvmxec:after{content:"";height:var(--search-clear-button-size);width:var(--search-clear-button-size);display:block;background-color:currentColor;-webkit-mask-image:url("data:image/svg+xml,");-webkit-mask-repeat:no-repeat}`); } function get_each_context5(ctx, list, i) { const child_ctx = ctx.slice(); @@ -40806,7 +40799,7 @@ function create_if_block_8(ctx) { return { c() { div = element("div"); - attr(div, "class", "git-commit-msg-clear-button svelte-48bivb"); + attr(div, "class", "git-commit-msg-clear-button svelte-1bvmxec"); attr(div, "aria-label", div_aria_label_value = "Clear"); }, m(target, anchor) { @@ -40942,9 +40935,9 @@ function create_if_block8(ctx) { attr(div2, "aria-label", "Unstage"); attr(div2, "class", "clickable-icon"); attr(div3, "class", "buttons"); - attr(div4, "class", "files-count svelte-48bivb"); + attr(div4, "class", "files-count svelte-1bvmxec"); attr(div5, "class", "git-tools"); - attr(div6, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div6, "class", "tree-item-self is-clickable nav-folder-title svelte-1bvmxec"); attr(div7, "class", "staged tree-item nav-folder"); toggle_class(div7, "is-collapsed", !/*stagedOpen*/ ctx[13]); @@ -40959,10 +40952,10 @@ function create_if_block8(ctx) { attr(div11, "aria-label", "Stage"); attr(div11, "class", "clickable-icon"); attr(div12, "class", "buttons"); - attr(div13, "class", "files-count svelte-48bivb"); + attr(div13, "class", "files-count svelte-1bvmxec"); attr(div14, "class", "git-tools"); - attr(div15, "class", "tree-item-self is-clickable nav-folder-title"); - attr(div16, "class", "changes nav-folder"); + attr(div15, "class", "tree-item-self is-clickable nav-folder-title svelte-1bvmxec"); + attr(div16, "class", "changes tree-item nav-folder"); toggle_class(div16, "is-collapsed", !/*changesOpen*/ ctx[12]); attr(div17, "class", "tree-item-children nav-folder-children"); @@ -41776,7 +41769,7 @@ function create_if_block_14(ctx) { attr(div0, "class", "tree-item-icon nav-folder-collapse-indicator collapse-icon"); attr(div1, "class", "tree-item-inner nav-folder-title-content"); attr(span, "class", "tree-item-flair"); - attr(div2, "class", "tree-item-self is-clickable nav-folder-title"); + attr(div2, "class", "tree-item-self is-clickable nav-folder-title svelte-1bvmxec"); attr(div3, "class", "pulled nav-folder"); toggle_class(div3, "is-collapsed", !/*lastPulledFilesOpen*/ ctx[14]); @@ -42160,6 +42153,7 @@ function create_fragment9(ctx) { let t8; let t9; let div11; + let main_data_type_value; let current; let mounted; let dispose; @@ -42249,13 +42243,14 @@ function create_fragment9(ctx) { /*rows*/ ctx[15] ); - attr(textarea, "class", "commit-msg-input svelte-48bivb"); + attr(textarea, "class", "commit-msg-input svelte-1bvmxec"); attr(textarea, "spellcheck", "true"); attr(textarea, "placeholder", "Commit Message"); - attr(div10, "class", "git-commit-msg svelte-48bivb"); + attr(div10, "class", "git-commit-msg svelte-1bvmxec"); attr(div11, "class", "nav-files-container"); set_style(div11, "position", "relative"); - attr(main, "class", "svelte-48bivb"); + attr(main, "data-type", main_data_type_value = SOURCE_CONTROL_VIEW_CONFIG.type); + attr(main, "class", "svelte-1bvmxec"); }, m(target, anchor) { insert(target, main, anchor); @@ -42478,8 +42473,8 @@ function instance9($$self, $$props, $$invalidate) { plugin.app.workspace.onLayoutReady(() => { window.setTimeout( () => { - buttons.forEach((btn) => (0, import_obsidian28.setIcon)(btn, btn.getAttr("data-icon"), 16)); - (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + buttons.forEach((btn) => (0, import_obsidian28.setIcon)(btn, btn.getAttr("data-icon"))); + (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder"); }, 0 ); @@ -42522,6 +42517,21 @@ function instance9($$self, $$props, $$invalidate) { $$invalidate(6, status2 = void 0); return; } + const unPushedCommits = yield plugin.gitManager.getUnpushedCommits(); + buttons.forEach((btn) => { + var _a2, _b; + if (import_obsidian28.Platform.isMobile) { + btn.removeClass("button-border"); + if (btn.id == "push" && unPushedCommits > 0) { + btn.addClass("button-border"); + } + } else { + (_a2 = btn.firstElementChild) === null || _a2 === void 0 ? void 0 : _a2.removeAttribute("color"); + if (btn.id == "push" && unPushedCommits > 0) { + (_b = btn.firstElementChild) === null || _b === void 0 ? void 0 : _b.setAttr("color", "var(--text-accent)"); + } + } + }); $$invalidate(6, status2 = plugin.cachedStatus); if (plugin.lastPulledFiles && plugin.lastPulledFiles != lastPulledFiles) { $$invalidate(7, lastPulledFiles = plugin.lastPulledFiles); @@ -42674,7 +42684,7 @@ function instance9($$self, $$props, $$invalidate) { $: { if (layoutBtn) { layoutBtn.empty(); - (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder", 16); + (0, import_obsidian28.setIcon)(layoutBtn, showTree ? "list" : "folder"); } } } @@ -42963,6 +42973,11 @@ var ObsidianGit = class extends import_obsidian30.Plugin { name: "Pull", callback: () => this.promiseQueue.addTask(() => this.pullChangesFromRemote()) }); + this.addCommand({ + id: "fetch", + name: "fetch", + callback: () => this.promiseQueue.addTask(() => this.fetch()) + }); this.addCommand({ id: "switch-to-remote-branch", name: "Switch to remote branch", @@ -43323,6 +43338,7 @@ var ObsidianGit = class extends import_obsidian30.Plugin { "git-head-update", this.refreshUpdatedHead.bind(this) ); + this.app.workspace.offref(this.openEvent); this.app.metadataCache.offref(this.modifyEvent); this.app.metadataCache.offref(this.deleteEvent); this.app.metadataCache.offref(this.createEvent); @@ -43392,6 +43408,10 @@ var ObsidianGit = class extends import_obsidian30.Plugin { case "valid": this.gitReady = true; this.setState(0 /* idle */); + this.openEvent = this.app.workspace.on( + "active-leaf-change", + (leaf) => this.handleViewActiveState(leaf) + ); this.modifyEvent = this.app.vault.on("modify", () => { this.debRefresh(); }); @@ -43751,6 +43771,15 @@ var ObsidianGit = class extends import_obsidian30.Plugin { } return pulledFiles.length != 0; } + async fetch() { + if (!await this.remotesAreSet()) { + return; + } + await this.gitManager.fetch(); + this.displayMessage(`Fetched from remote`); + this.offlineMode = false; + dispatchEvent(new CustomEvent("git-refresh")); + } async mayDeleteConflictFile() { const file = this.app.vault.getAbstractFileByPath( this.conflictOutputFile @@ -44124,6 +44153,36 @@ I strongly recommend to use "Source mode" for viewing the conflicted files. For this.app.workspace.openLinkText(this.conflictOutputFile, "/", true); } } + handleViewActiveState(leaf) { + var _a2, _b; + if (!(leaf == null ? void 0 : leaf.view.getState().file)) + return; + const sourceControlLeaf = this.app.workspace.getLeavesOfType(SOURCE_CONTROL_VIEW_CONFIG.type).first(); + const historyLeaf = this.app.workspace.getLeavesOfType(HISTORY_VIEW_CONFIG.type).first(); + (_a2 = sourceControlLeaf == null ? void 0 : sourceControlLeaf.view.containerEl.querySelector(`div.nav-file-title.is-active`)) == null ? void 0 : _a2.removeClass("is-active"); + (_b = historyLeaf == null ? void 0 : historyLeaf.view.containerEl.querySelector(`div.nav-file-title.is-active`)) == null ? void 0 : _b.removeClass("is-active"); + if ((leaf == null ? void 0 : leaf.view) instanceof DiffView) { + const path2 = leaf.view.state.file; + this.lastDiffViewState = leaf.view.getState(); + let el; + if (sourceControlLeaf && leaf.view.state.staged) { + el = sourceControlLeaf.view.containerEl.querySelector( + `div.staged div.nav-file-title[data-path='${path2}']` + ); + } else if (sourceControlLeaf && leaf.view.state.staged === false && !leaf.view.state.hash) { + el = sourceControlLeaf.view.containerEl.querySelector( + `div.changes div.nav-file-title[data-path='${path2}']` + ); + } else if (historyLeaf && leaf.view.state.hash) { + el = historyLeaf.view.containerEl.querySelector( + `div.nav-file-title[data-path='${path2}']` + ); + } + el == null ? void 0 : el.addClass("is-active"); + } else { + this.lastDiffViewState = void 0; + } + } // region: displaying / formatting messages displayMessage(message, timeout = 4 * 1e3) { var _a2; diff --git a/.obsidian/plugins/obsidian-git/manifest.json b/.obsidian/plugins/obsidian-git/manifest.json index edb53f6..a771a54 100644 --- a/.obsidian/plugins/obsidian-git/manifest.json +++ b/.obsidian/plugins/obsidian-git/manifest.json @@ -5,5 +5,5 @@ "isDesktopOnly": false, "fundingUrl": "https://ko-fi.com/vinzent", "js": "main.js", - "version": "2.20.7" + "version": "2.22.0" } diff --git a/.obsidian/plugins/obsidian-git/styles.css b/.obsidian/plugins/obsidian-git/styles.css index 39cdb13..c1d5065 100644 --- a/.obsidian/plugins/obsidian-git/styles.css +++ b/.obsidian/plugins/obsidian-git/styles.css @@ -8,6 +8,11 @@ } } +.workspace-leaf-content[data-type='git-view'] .button-border { + border: 2px solid var(--interactive-accent); + border-radius: var(--radius-s); +} + .workspace-leaf-content[data-type='git-view'] .view-content { padding: 0; } diff --git a/.obsidian/plugins/obsidian-hider/main.js b/.obsidian/plugins/obsidian-hider/main.js index 3edafa0..19e0569 100644 --- a/.obsidian/plugins/obsidian-hider/main.js +++ b/.obsidian/plugins/obsidian-hider/main.js @@ -47,7 +47,7 @@ class Hider extends obsidian.Plugin { document.body.classList.toggle('hider-file-nav-header', this.settings.hideFileNavButtons); document.body.classList.toggle('hider-search-counts', this.settings.hideSearchCounts); document.body.classList.toggle('hider-instructions', this.settings.hideInstructions); - document.body.classList.toggle('hider-meta', this.settings.hideMeta); + document.body.classList.toggle('hider-meta', this.settings.hidePropertiesReading); document.body.classList.toggle('hider-vault', this.settings.hideVault); }; } @@ -113,7 +113,7 @@ const DEFAULT_SETTINGS = { hideSearchSuggestions: false, hideSearchCounts: false, hideInstructions: false, - hideMeta: false, + hidePropertiesReading: false, hideVault: false }; class HiderSettingTab extends obsidian.PluginSettingTab { @@ -224,11 +224,11 @@ class HiderSettingTab extends obsidian.PluginSettingTab { this.plugin.refresh(); })); new obsidian.Setting(containerEl) - .setName('Hide metadata block in Reading view') - .setDesc('When front matter is turned off in your Editor settings this hides the metadata block') - .addToggle(toggle => toggle.setValue(this.plugin.settings.hideMeta) + .setName('Hide properties in Reading view') + .setDesc('Hides the properties section in Reading view') + .addToggle(toggle => toggle.setValue(this.plugin.settings.hidePropertiesReading) .onChange((value) => { - this.plugin.settings.hideMeta = value; + this.plugin.settings.hidePropertiesReading = value; this.plugin.saveData(this.plugin.settings); this.plugin.refresh(); })); @@ -236,4 +236,4 @@ class HiderSettingTab extends obsidian.PluginSettingTab { } module.exports = Hider; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","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    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\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\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 __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, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { App, Modal, Notice, Plugin, PluginSettingTab, Setting } from 'obsidian';\r\n\r\nexport default class Hider extends Plugin {\r\n  settings: HiderSettings;\r\n\r\n  async onload() {\r\n    // load settings\r\n    await this.loadSettings();\r\n\r\n    // add the settings tab\r\n    this.addSettingTab(new HiderSettingTab(this.app, this));\r\n    // add the toggle on/off command\r\n\r\n    this.addCommand({\r\n      id: 'toggle-tab-containers',\r\n      name: 'Toggle tab bar',\r\n      callback: () => {\r\n        this.settings.hideTabs = !this.settings.hideTabs;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.addCommand({\r\n      id: 'toggle-app-ribbon',\r\n      name: 'Toggle app ribbon',\r\n      callback: () => {\r\n        this.settings.hideRibbon = !this.settings.hideRibbon;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.addCommand({\r\n      id: 'toggle-hider-status',\r\n      name: 'Toggle status bar',\r\n      callback: () => {\r\n        this.settings.hideStatus = !this.settings.hideStatus;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.refresh()\r\n  }\r\n\r\n  onunload() {\r\n    console.log('Unloading Hider plugin');\r\n  }\r\n\r\n  async loadSettings() {\r\n    this.settings = Object.assign(DEFAULT_SETTINGS, await this.loadData());\r\n  }\r\n\r\n  async saveSettings() {\r\n    await this.saveData(this.settings);\r\n  }\r\n\r\n  // refresh function for when we change settings\r\n  refresh = () => {\r\n    // re-load the style\r\n    this.updateStyle()\r\n  }\r\n\r\n  // update the styles (at the start, or as the result of a settings change)\r\n  updateStyle = () => {\r\n    document.body.classList.toggle('hider-ribbon', this.settings.hideRibbon);\r\n    document.body.classList.toggle('hider-status', this.settings.hideStatus);\r\n    document.body.classList.toggle('hider-tabs', this.settings.hideTabs);\r\n    document.body.classList.toggle('hider-scroll', this.settings.hideScroll);\r\n    document.body.classList.toggle('hider-sidebar-buttons', this.settings.hideSidebarButtons);\r\n    document.body.classList.toggle('hider-tooltips', this.settings.hideTooltips);\r\n    document.body.classList.toggle('hider-search-suggestions', this.settings.hideSearchSuggestions);\r\n    document.body.classList.toggle('hider-file-nav-header', this.settings.hideFileNavButtons);\r\n    document.body.classList.toggle('hider-search-counts', this.settings.hideSearchCounts);\r\n    document.body.classList.toggle('hider-instructions', this.settings.hideInstructions);\r\n    document.body.classList.toggle('hider-meta', this.settings.hideMeta);\r\n    document.body.classList.toggle('hider-vault', this.settings.hideVault);\r\n  }\r\n\r\n}\r\n\r\ninterface HiderSettings {\r\n  hideRibbon: boolean;\r\n  hideStatus: boolean;\r\n  hideTabs: boolean;\r\n  hideScroll: boolean;\r\n  hideSidebarButtons: boolean;\r\n  hideTooltips: boolean;\r\n  hideFileNavButtons: boolean;\r\n  hideSearchSuggestions: boolean;\r\n  hideSearchCounts: boolean;\r\n  hideInstructions: boolean;\r\n  hideMeta: boolean;\r\n  hideVault: boolean;\r\n}\r\nconst DEFAULT_SETTINGS: HiderSettings = {\r\n  hideRibbon: false,\r\n  hideStatus: false,\r\n  hideTabs: false,\r\n  hideScroll: false,\r\n  hideSidebarButtons: false,\r\n  hideTooltips: false,\r\n  hideFileNavButtons: false,\r\n  hideSearchSuggestions: false,\r\n  hideSearchCounts: false,\r\n  hideInstructions: false,\r\n  hideMeta: false,\r\n  hideVault: false\r\n}\r\n\r\nclass HiderSettingTab extends PluginSettingTab {\r\n\r\n\r\n  plugin: Hider;\r\n  constructor(app: App, plugin: Hider) {\r\n    super(app, plugin);\r\n    this.plugin = plugin;\r\n  }\r\n\r\n  display(): void {\r\n    let {containerEl} = this;\r\n\r\n    containerEl.empty();\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide app ribbon')\r\n      .setDesc('Hides the Obsidian menu. Warning: to open Settings you will need use the hotkey (default is CMD + ,)')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideRibbon)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideRibbon = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide tab bar')\r\n      .setDesc('Hides the tab container at the top of the window')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideTabs)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideTabs = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide status bar')\r\n      .setDesc('Hides word count, character count and backlink count')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideStatus)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideStatus = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide vault name')\r\n      .setDesc('Hides the root folder name')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideVault)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideVault = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide scroll bars')\r\n      .setDesc('Hides all scroll bars')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideScroll)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideScroll = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide sidebar toggle buttons')\r\n      .setDesc('Hides both sidebar buttons')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSidebarButtons)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSidebarButtons = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide tooltips')\r\n      .setDesc('Hides all tooltips')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideTooltips)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideTooltips = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide file explorer buttons')\r\n      .setDesc('Hides buttons at the top of file explorer (new file, new folder, etc)')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideFileNavButtons)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideFileNavButtons = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide instructions')\r\n      .setDesc('Hides instructional tips in modals')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideInstructions)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideInstructions = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide search suggestions')\r\n      .setDesc('Hides suggestions in search pane')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSearchSuggestions)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSearchSuggestions = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide count of search term matches')\r\n      .setDesc('Hides the number of matches within each search result')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSearchCounts)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSearchCounts = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide metadata block in Reading view')\r\n      .setDesc('When front matter is turned off in your Editor settings this hides the metadata block')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideMeta)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideMeta = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n\r\n\r\n  }\r\n}\r\n"],"names":["Plugin","PluginSettingTab","Setting"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","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    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\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\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 __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, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { App, Modal, Notice, Plugin, PluginSettingTab, Setting } from 'obsidian';\r\n\r\nexport default class Hider extends Plugin {\r\n  settings: HiderSettings;\r\n\r\n  async onload() {\r\n    // load settings\r\n    await this.loadSettings();\r\n\r\n    // add the settings tab\r\n    this.addSettingTab(new HiderSettingTab(this.app, this));\r\n    // add the toggle on/off command\r\n\r\n    this.addCommand({\r\n      id: 'toggle-tab-containers',\r\n      name: 'Toggle tab bar',\r\n      callback: () => {\r\n        this.settings.hideTabs = !this.settings.hideTabs;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.addCommand({\r\n      id: 'toggle-app-ribbon',\r\n      name: 'Toggle app ribbon',\r\n      callback: () => {\r\n        this.settings.hideRibbon = !this.settings.hideRibbon;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.addCommand({\r\n      id: 'toggle-hider-status',\r\n      name: 'Toggle status bar',\r\n      callback: () => {\r\n        this.settings.hideStatus = !this.settings.hideStatus;\r\n        this.saveData(this.settings);\r\n        this.refresh();\r\n      }\r\n    });\r\n    this.refresh()\r\n  }\r\n\r\n  onunload() {\r\n    console.log('Unloading Hider plugin');\r\n  }\r\n\r\n  async loadSettings() {\r\n    this.settings = Object.assign(DEFAULT_SETTINGS, await this.loadData());\r\n  }\r\n\r\n  async saveSettings() {\r\n    await this.saveData(this.settings);\r\n  }\r\n\r\n  // refresh function for when we change settings\r\n  refresh = () => {\r\n    // re-load the style\r\n    this.updateStyle()\r\n  }\r\n\r\n  // update the styles (at the start, or as the result of a settings change)\r\n  updateStyle = () => {\r\n    document.body.classList.toggle('hider-ribbon', this.settings.hideRibbon);\r\n    document.body.classList.toggle('hider-status', this.settings.hideStatus);\r\n    document.body.classList.toggle('hider-tabs', this.settings.hideTabs);\r\n    document.body.classList.toggle('hider-scroll', this.settings.hideScroll);\r\n    document.body.classList.toggle('hider-sidebar-buttons', this.settings.hideSidebarButtons);\r\n    document.body.classList.toggle('hider-tooltips', this.settings.hideTooltips);\r\n    document.body.classList.toggle('hider-search-suggestions', this.settings.hideSearchSuggestions);\r\n    document.body.classList.toggle('hider-file-nav-header', this.settings.hideFileNavButtons);\r\n    document.body.classList.toggle('hider-search-counts', this.settings.hideSearchCounts);\r\n    document.body.classList.toggle('hider-instructions', this.settings.hideInstructions);\r\n    document.body.classList.toggle('hider-meta', this.settings.hidePropertiesReading);\r\n    document.body.classList.toggle('hider-vault', this.settings.hideVault);\r\n  }\r\n\r\n}\r\n\r\ninterface HiderSettings {\r\n  hideRibbon: boolean;\r\n  hideStatus: boolean;\r\n  hideTabs: boolean;\r\n  hideScroll: boolean;\r\n  hideSidebarButtons: boolean;\r\n  hideTooltips: boolean;\r\n  hideFileNavButtons: boolean;\r\n  hideSearchSuggestions: boolean;\r\n  hideSearchCounts: boolean;\r\n  hideInstructions: boolean;\r\n  hidePropertiesReading: boolean;\r\n  hideVault: boolean;\r\n}\r\nconst DEFAULT_SETTINGS: HiderSettings = {\r\n  hideRibbon: false,\r\n  hideStatus: false,\r\n  hideTabs: false,\r\n  hideScroll: false,\r\n  hideSidebarButtons: false,\r\n  hideTooltips: false,\r\n  hideFileNavButtons: false,\r\n  hideSearchSuggestions: false,\r\n  hideSearchCounts: false,\r\n  hideInstructions: false,\r\n  hidePropertiesReading: false,\r\n  hideVault: false\r\n}\r\n\r\nclass HiderSettingTab extends PluginSettingTab {\r\n\r\n\r\n  plugin: Hider;\r\n  constructor(app: App, plugin: Hider) {\r\n    super(app, plugin);\r\n    this.plugin = plugin;\r\n  }\r\n\r\n  display(): void {\r\n    let {containerEl} = this;\r\n\r\n    containerEl.empty();\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide app ribbon')\r\n      .setDesc('Hides the Obsidian menu. Warning: to open Settings you will need use the hotkey (default is CMD + ,)')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideRibbon)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideRibbon = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide tab bar')\r\n      .setDesc('Hides the tab container at the top of the window')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideTabs)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideTabs = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide status bar')\r\n      .setDesc('Hides word count, character count and backlink count')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideStatus)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideStatus = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide vault name')\r\n      .setDesc('Hides the root folder name')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideVault)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideVault = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide scroll bars')\r\n      .setDesc('Hides all scroll bars')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideScroll)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideScroll = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide sidebar toggle buttons')\r\n      .setDesc('Hides both sidebar buttons')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSidebarButtons)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSidebarButtons = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide tooltips')\r\n      .setDesc('Hides all tooltips')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideTooltips)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideTooltips = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide file explorer buttons')\r\n      .setDesc('Hides buttons at the top of file explorer (new file, new folder, etc)')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideFileNavButtons)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideFileNavButtons = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide instructions')\r\n      .setDesc('Hides instructional tips in modals')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideInstructions)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideInstructions = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide search suggestions')\r\n      .setDesc('Hides suggestions in search pane')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSearchSuggestions)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSearchSuggestions = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide count of search term matches')\r\n      .setDesc('Hides the number of matches within each search result')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hideSearchCounts)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hideSearchCounts = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n    new Setting(containerEl)\r\n      .setName('Hide properties in Reading view')\r\n      .setDesc('Hides the properties section in Reading view')\r\n      .addToggle(toggle => toggle.setValue(this.plugin.settings.hidePropertiesReading)\r\n          .onChange((value) => {\r\n            this.plugin.settings.hidePropertiesReading = value;\r\n            this.plugin.saveData(this.plugin.settings);\r\n            this.plugin.refresh();\r\n            })\r\n          );\r\n\r\n\r\n\r\n  }\r\n}\r\n"],"names":["Plugin","PluginSettingTab","Setting"],"mappings":"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"} diff --git a/.obsidian/plugins/obsidian-hider/manifest.json b/.obsidian/plugins/obsidian-hider/manifest.json index 13983eb..583c60e 100644 --- a/.obsidian/plugins/obsidian-hider/manifest.json +++ b/.obsidian/plugins/obsidian-hider/manifest.json @@ -1,8 +1,8 @@ { "id": "obsidian-hider", "name": "Hider", - "version": "1.2.5", - "minAppVersion": "0.16.0", + "version": "1.3.1", + "minAppVersion": "1.4.0", "description": "Hide UI elements such as tooltips, status, titlebar and more", "author": "@kepano", "authorUrl": "https://www.twitter.com/kepano", diff --git a/.obsidian/plugins/obsidian-hider/styles.css b/.obsidian/plugins/obsidian-hider/styles.css index 094973e..1f79815 100644 --- a/.obsidian/plugins/obsidian-hider/styles.css +++ b/.obsidian/plugins/obsidian-hider/styles.css @@ -37,7 +37,7 @@ } /* Hide meta */ -.hider-meta .frontmatter-container { +.hider-meta .markdown-reading-view .metadata-container { display:none; } diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 927c4e3..bc9ed46 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -25,13 +25,14 @@ "state": { "type": "markdown", "state": { - "file": "Hab.2-3.md", + "file": "Hab.2.20-3.19.md", "mode": "source", "source": false } } } - ] + ], + "currentTab": 1 } ], "direction": "vertical" @@ -105,7 +106,7 @@ "state": { "type": "outline", "state": { - "file": "README.md" + "file": "Hab.2.20-3.19.md" } } }, @@ -126,7 +127,7 @@ "state": { "type": "backlink", "state": { - "file": "README.md", + "file": "Hab.2.20-3.19.md", "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical", @@ -143,7 +144,7 @@ "state": { "type": "outgoing-link", "state": { - "file": "README.md", + "file": "Hab.2.20-3.19.md", "linksCollapsed": false, "unlinkedCollapsed": true } @@ -178,10 +179,10 @@ "workspaces:Manage workspace layouts": false } }, - "active": "1525ca662bf8f78d", + "active": "d3f4b06a3b98097f", "lastOpenFiles": [ - "Hab.2-3.md", "README.md", + "Hab.2.20-3.19.md", "Mat.25.31-46.md", "Eze.34.1-24.md", "images/2023-11-26 Eze.34.1-24.png", diff --git a/Hab.2-3.md b/Hab.2.20-3.19.md similarity index 90% rename from Hab.2-3.md rename to Hab.2.20-3.19.md index 93a9ff2..e6eac8c 100644 --- a/Hab.2-3.md +++ b/Hab.2.20-3.19.md @@ -1,4 +1,4 @@ -經文:哈巴谷書2-3章 +經文:哈巴谷書2:20; 3:16-19 題目:耶和華在祂殿中 日期:2023-12-31 教會:竹圍信友堂 diff --git a/README.md b/README.md index 72a5506..2aa8c5d 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ | 2023-07-23 | 台北衛理堂 | 羅馬書 8:12-25 | 榮耀的盼望 (二) | [羅 8:12-25](Rom.8.12-25.md) | | 2023-09-03 | 大直真理堂 | 哥林多後書 3:1-6 | 蒙福之人 | [林後 3:1-6](2Co.3.1-6.md) | | 2023-11-26 | 台北衛理堂 (兩堂證道) | 以西結書 34:1-24 | 耶穌親自牧養:我們要認識祂、回應祂 | [結 34:1-16, 20-24](Eze.34.1-24.md) | -| 2023-12-31 | 竹圍信友堂 | 哈巴谷書2-3章 | 耶和華在祂殿中 | [哈 2-3 ](Hab.2-3.md) | +| 2023-12-31 | 竹圍信友堂 | 哈巴谷書2-3章 | 耶和華在祂殿中 | [哈 2:20; 3:16-19 ](Hab.2.20-3.19.md) |