From 9f152a8bb372dfa9baae724691780e5287ed8051 Mon Sep 17 00:00:00 2001 From: Awin Huang Date: Tue, 20 Feb 2024 21:31:52 +0800 Subject: [PATCH] vault backup: 2024-02-20 21:31:52 --- .../community-plugins-AWIN-DESKMEET.json | 14 + .obsidian/plugins/hk-code-block/data.json | 22 + .obsidian/plugins/hk-code-block/main.js | 627 ++++++++++++++++++ .obsidian/plugins/hk-code-block/manifest.json | 11 + .obsidian/plugins/hk-code-block/styles.css | 241 +++++++ .obsidian/workspace-AWIN-DESKMEET.json | 236 +++++++ 6 files changed, 1151 insertions(+) create mode 100644 .obsidian/community-plugins-AWIN-DESKMEET.json create mode 100644 .obsidian/plugins/hk-code-block/data.json create mode 100644 .obsidian/plugins/hk-code-block/main.js create mode 100644 .obsidian/plugins/hk-code-block/manifest.json create mode 100644 .obsidian/plugins/hk-code-block/styles.css create mode 100644 .obsidian/workspace-AWIN-DESKMEET.json diff --git a/.obsidian/community-plugins-AWIN-DESKMEET.json b/.obsidian/community-plugins-AWIN-DESKMEET.json new file mode 100644 index 0000000..4cdd5c2 --- /dev/null +++ b/.obsidian/community-plugins-AWIN-DESKMEET.json @@ -0,0 +1,14 @@ +[ + "table-editor-obsidian", + "dataview", + "obsidian-rollover-daily-todos", + "todoist-sync-plugin", + "obsidian-columns", + "obsidian-tasks-plugin", + "oz-image-plugin", + "periodic-notes", + "obsidian-git", + "obsidian-quiet-outline", + "obsidian-tracker", + "hk-code-block" +] \ No newline at end of file diff --git a/.obsidian/plugins/hk-code-block/data.json b/.obsidian/plugins/hk-code-block/data.json new file mode 100644 index 0000000..c7775d3 --- /dev/null +++ b/.obsidian/plugins/hk-code-block/data.json @@ -0,0 +1,22 @@ +{ + "useTitleGlobal": "default off, but on when specified", + "useCollapsibleGlobal": "default on, but off when specified", + "defaultCollapse": "expand", + "showCollapseBtn": true, + "useLinenosGlobal": "default on, but off when specified", + "defaultLinenosStart": 1, + "showLinenosSplitter": true, + "useHighlightGlobal": "default off, but on when specified", + "highlightColor": "#ff0000", + "useLanguageGlobal": "default on, but off when specified", + "defaultLanguage": "plain text", + "useCopyBtnGlobal": "default on, but off when specified", + "usePromptGlobal": "default on, but off when specified", + "promptingLanguages": [ + "bash" + ], + "defaultPrompt": "$", + "useResultGlobal": true, + "defaultResultPrompt": "Result", + "debugMode": false +} \ No newline at end of file diff --git a/.obsidian/plugins/hk-code-block/main.js b/.obsidian/plugins/hk-code-block/main.js new file mode 100644 index 0000000..b4b139a --- /dev/null +++ b/.obsidian/plugins/hk-code-block/main.js @@ -0,0 +1,627 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => HKCodeBlockPlugin +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian3 = require("obsidian"); + +// src/settings.ts +var DEFAULT_SETTINGS = { + useTitleGlobal: "default off, but on when specified", + useCollapsibleGlobal: "default on, but off when specified", + defaultCollapse: "expand", + showCollapseBtn: true, + useLinenosGlobal: "default off, but on when specified", + defaultLinenosStart: 1, + showLinenosSplitter: true, + useHighlightGlobal: "default off, but on when specified", + highlightColor: "#ff0000", + useLanguageGlobal: "default on, but off when specified", + defaultLanguage: "plain text", + useCopyBtnGlobal: "default on, but off when specified", + usePromptGlobal: "default on, but off when specified", + promptingLanguages: ["bash"], + defaultPrompt: "$", + useResultGlobal: true, + defaultResultPrompt: "Result", + debugMode: false +}; + +// src/settingTab.ts +var import_obsidian = require("obsidian"); +var fragWithHTML = (text) => { + return createFragment((frag) => { + frag.createDiv().innerHTML = text.split("\n").map((line) => line.trim()).join("
"); + }); +}; +var HKCodeBlockSettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app2, plugin) { + super(app2, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Title" }); + new import_obsidian.Setting(containerEl).setName("Use Title").setDesc(fragWithHTML(`- default off, but on when specified : the title will only be shown if the title statement is specified + - always off : the title will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useTitleGlobal).onChange(async (value) => { + this.plugin.settings.useTitleGlobal = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Collapse" }); + new import_obsidian.Setting(containerEl).setName("Use Collapse").setDesc(fragWithHTML(`- always on : the code block will always be collapsible + - default on, but off when specified : the code block will always be collapsible, but will not be collapsed if collapse statement is specified as false + - default off, but on when specified : the code block will only be collapsible if the collapse statement is specified as true + - always off : the code block will never be collapsible`)).addDropdown( + (tc) => tc.addOptions({ + "always on": "always on", + "default on, but off when specified": "default on, but off when specified", + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useCollapsibleGlobal).onChange(async (value) => { + this.plugin.settings.useCollapsibleGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Default Collapse State").setDesc("The default collapse state of the code block.").addDropdown( + (tc) => tc.addOptions({ + "collapse": "collapse", + "expand": "expand" + }).setValue(this.plugin.settings.defaultCollapse).onChange(async (value) => { + this.plugin.settings.defaultCollapse = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Line Numbers" }); + new import_obsidian.Setting(containerEl).setName("Use Line Numbers").setDesc(fragWithHTML(`- always on : line numbers will always be shown + - default on, but off when specified : line numbers will always be shown, but will not be shown if linenos statement is specified as false + - default off, but on when specified : line numbers will only be shown if the linenos statement is specified as true + - always off : line numbers will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "always on": "always on", + "default on, but off when specified": "default on, but off when specified", + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useLinenosGlobal).onChange(async (value) => { + this.plugin.settings.useLinenosGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Default Line Number Start").setDesc("The default line number start of the code block.").addText( + (tc) => tc.setValue(this.plugin.settings.defaultLinenosStart.toString()).onChange(async (value) => { + const num = parseInt(value); + if (isNaN(num)) + return; + this.plugin.settings.defaultLinenosStart = num; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Show Line Number Splitter").addToggle( + (tc) => tc.setValue(this.plugin.settings.showLinenosSplitter).onChange(async (value) => { + this.plugin.settings.showLinenosSplitter = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Line Highlight" }); + new import_obsidian.Setting(containerEl).setName("Use Line Highlight").setDesc(fragWithHTML(`- default off, but on when specified : line highlight will only be shown if the line highlight statement is specified + - always off : line highlight will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useHighlightGlobal).onChange(async (value) => { + this.plugin.settings.useHighlightGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Line Highlight Color").setDesc("The background color of the highlighted line. Note that the given color will be applied with 0.2 opacity.").addText( + (tc) => tc.setValue(this.plugin.settings.highlightColor).onChange(async (value) => { + this.plugin.settings.highlightColor = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Language Indicator" }); + new import_obsidian.Setting(containerEl).setName("Use Language Indicator").setDesc(fragWithHTML(`- always on : language indicator will always be shown + - default on, but off when specified : language indicator will always be shown, but will not be shown if the language indicator statement is specified as false + - default off, but on when specified : language indicator will only be shown if the language indicator statement is specified as true + - always off : language indicator will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "always on": "always on", + "default on, but off when specified": "default on, but off when specified", + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useLanguageGlobal).onChange(async (value) => { + this.plugin.settings.useLanguageGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Default Language").setDesc("The default language name of the code block if the language is not specified.").addText( + (tc) => tc.setValue(this.plugin.settings.defaultLanguage).onChange(async (value) => { + this.plugin.settings.defaultLanguage = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Copy Button" }); + new import_obsidian.Setting(containerEl).setName("Use Copy Button").setDesc(fragWithHTML(`- always on : copy button will always be shown + - default on, but off when specified : copy button will always be shown, but will not be shown if the copy button statement is specified as false + - default off, but on when specified : copy button will only be shown if the copy button statement is specified as true + - always off : copy button will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "always on": "always on", + "default on, but off when specified": "default on, but off when specified", + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.useCopyBtnGlobal).onChange(async (value) => { + this.plugin.settings.useCopyBtnGlobal = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Prompt" }); + new import_obsidian.Setting(containerEl).setName("Use Prompt").setDesc(fragWithHTML(`- always on : prompt will always be shown + - default on, but off when specified : prompt will always be shown, but will not be shown if the prompt statement is specified as false + - default off, but on when specified : prompt will only be shown if the prompt statement is specified as true + - always off : prompt will never be shown`)).addDropdown( + (tc) => tc.addOptions({ + "always on": "always on", + "default on, but off when specified": "default on, but off when specified", + "default off, but on when specified": "default off, but on when specified", + "always off": "always off" + }).setValue(this.plugin.settings.usePromptGlobal).onChange(async (value) => { + this.plugin.settings.usePromptGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Prompting Languages").setDesc("The languages that will be prompted by default. You can specify multiple languages by separating them with enters.").addTextArea( + (tc) => tc.setValue(this.plugin.settings.promptingLanguages.join("\n")).onChange(async (value) => { + const lines = value.split("\n").filter((line) => line.trim() !== ""); + this.plugin.settings.promptingLanguages = lines; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Default Prompt").setDesc("The default prompt of the bash code block.").addText( + (tc) => tc.setValue(this.plugin.settings.defaultPrompt).onChange(async (value) => { + this.plugin.settings.defaultPrompt = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Result" }); + new import_obsidian.Setting(containerEl).setName("Use Result").setDesc(fragWithHTML(`- enable : treat the code block starts like \`\`\`\`result\` as the result of the adjacent previous code block + - disable : treat the code block with \`result\` as its language name as a normal code block`)).addToggle( + (tc) => tc.setValue(this.plugin.settings.useResultGlobal).onChange(async (value) => { + this.plugin.settings.useResultGlobal = value; + await this.plugin.saveSettings(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Default Result Prompt").setDesc("The default prompt of the result code block.").addText( + (tc) => tc.setValue(this.plugin.settings.defaultResultPrompt).onChange(async (value) => { + this.plugin.settings.defaultResultPrompt = value; + await this.plugin.saveSettings(); + }) + ); + containerEl.createEl("h2", { text: "Developers" }); + new import_obsidian.Setting(containerEl).setName("Debug Mode").setDesc("Show logs in the console.").addToggle( + (tc) => tc.setValue(this.plugin.settings.debugMode).onChange(async (value) => { + this.plugin.settings.debugMode = value; + await this.plugin.saveSettings(); + }) + ); + } +}; + +// src/processor.ts +var import_obsidian2 = require("obsidian"); +var REGEX = { + TITLE: /\stitle:(?:'(.*?)'|"(.*?)")\s/, + COLLAPSIBLE_SIMPLE: /\scollapsible\s/, + COLLAPSIBLE_COMPLICATE: /\scollapsible:(true|false)\s/, + LINENOS_SIMPLE: /\slinenos\s/, + LINENOS_COMPLICATE: /\slinenos:(true|false|(-{0,1}\d+))\s/, + HIGHLIGHT: /\shighlight:(?:'(.*?)'|"(.*?)")\s/, + LANGUAGE_FROM_CLASS: /^language-(\w+)$/, + LANGUAGE_SIMPLE: /\slanguage\s/, + LANGUAGE_COMPLICATE: /\slanguage:(true|false|'(.*?)'|"(.*?)")\s/, + COPYBTN_SIMPLE: /\scopybtn\s/, + COPYBTN_COMPLICATE: /\scopybtn:(true|false)\s/, + RESULT: /^```result\s/, + PROMPT_SIMPLE: /\sprompt\s/, + PROMPT_COMPLICATE: /\sprompt:(true|false|'(.*?)'|"(.*?)")\s/, + NUMBER: /^-{0,1}\d+$/ +}; +function getMeta(view, elem_code, elem_code_idx, section_code, settings) { + const return_value = { + isError: false, + lineStartInSection: -1, + lineEndInSection: -1, + showTitle: void 0, + title: "", + isCollapsible: void 0, + showLinenos: void 0, + linenosStart: settings.defaultLinenosStart, + linenosNum: 0, + showHighlight: void 0, + highlightLines: [], + showLanguage: void 0, + language: settings.defaultLanguage, + showCopyBtn: void 0, + isResult: false, + resultPrompt: settings.defaultResultPrompt, + showPrompt: void 0, + prompt: settings.defaultPrompt + }; + let marker_count = 0; + for (let i = section_code.lineStart; i <= section_code.lineEnd; i++) { + const line = view.editor.getLine(i); + if (line.trim().startsWith("```")) + marker_count++; + if (return_value.lineStartInSection === -1 && marker_count === elem_code_idx * 2 + 1) { + return_value.lineStartInSection = i; + } + if (return_value.lineEndInSection === -1 && marker_count === elem_code_idx * 2 + 2) { + return_value.lineEndInSection = i; + break; + } + } + if (return_value.lineStartInSection < 0 || return_value.lineEndInSection < 0 || return_value.lineStartInSection >= return_value.lineEndInSection) { + return_value.isError = true; + return return_value; + } + const firstline = view.editor.getLine(return_value.lineStartInSection).trim() + " "; + const regexResult_title = REGEX.TITLE.exec(firstline); + if (regexResult_title) { + return_value.showTitle = true; + return_value.title = regexResult_title[1] || regexResult_title[2]; + } + const regexResult_collapsibleSimple = REGEX.COLLAPSIBLE_SIMPLE.exec(firstline); + const regexResult_collapsibleComplicate = REGEX.COLLAPSIBLE_COMPLICATE.exec(firstline); + if (regexResult_collapsibleSimple) { + return_value.isCollapsible = true; + } else if (regexResult_collapsibleComplicate) { + if (regexResult_collapsibleComplicate[1] === "true") { + return_value.isCollapsible = true; + } else if (regexResult_collapsibleComplicate[1] === "false") { + return_value.isCollapsible = false; + } + } + return_value.linenosNum = return_value.lineEndInSection - return_value.lineStartInSection - 1; + const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline); + const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline); + if (regexResult_linenosSimple) { + return_value.showLinenos = true; + } else if (regexResult_linenosComplicate) { + if (regexResult_linenosComplicate[1] === "true") { + return_value.showLinenos = true; + } else if (regexResult_linenosComplicate[1] === "false") { + return_value.showLinenos = false; + } else { + return_value.showLinenos = true; + return_value.linenosStart = parseInt(regexResult_linenosComplicate[2]) || 1; + } + } + const regexResult_highlight = REGEX.HIGHLIGHT.exec(firstline); + if (regexResult_highlight) { + return_value.showHighlight = true; + const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2]; + let highlightLines = highlightLines_str.split(",").map((item) => { + item = item.trim(); + if (REGEX.NUMBER.test(item)) + return parseInt(item); + const multiple_lines = item.split("-"); + if (multiple_lines.length === 2) { + const start = parseInt(multiple_lines[0].trim()); + const end = parseInt(multiple_lines[1].trim()); + if (!isNaN(start) && !isNaN(end)) { + return Array.from({ length: end - start + 1 }, (_, i) => i + start); + } + } + return NaN; + }).flat().filter((item) => !isNaN(item)); + if (highlightLines.some((line) => isNaN(line))) { + return_value.showHighlight = void 0; + return_value.highlightLines = []; + } else { + return_value.highlightLines = highlightLines.filter( + (line) => line >= return_value.linenosStart && line < return_value.linenosStart + return_value.linenosNum + ); + } + } + elem_code.classList.forEach((className) => { + const regexResult_languageFromClass = REGEX.LANGUAGE_FROM_CLASS.exec(className.trim()); + if (regexResult_languageFromClass) { + return_value.language = regexResult_languageFromClass[1]; + } + }); + const regexResult_languageSimple = REGEX.LANGUAGE_SIMPLE.exec(firstline); + const regexResult_languageComplicate = REGEX.LANGUAGE_COMPLICATE.exec(firstline); + if (regexResult_languageSimple) { + return_value.showLanguage = true; + } else if (regexResult_languageComplicate) { + if (regexResult_languageComplicate[1] === "true") { + return_value.showLanguage = true; + } else if (regexResult_languageComplicate[1] === "false") { + return_value.showLanguage = false; + } else { + return_value.showLanguage = true; + return_value.language = regexResult_languageComplicate[2] || regexResult_languageComplicate[3]; + } + } + const regexResult_copyBtnSimple = REGEX.COPYBTN_SIMPLE.exec(firstline); + const regexResult_copyBtnComplicate = REGEX.COPYBTN_COMPLICATE.exec(firstline); + if (regexResult_copyBtnSimple) { + return_value.showCopyBtn = true; + } else if (regexResult_copyBtnComplicate) { + if (regexResult_copyBtnComplicate[1] === "true") { + return_value.showCopyBtn = true; + } else if (regexResult_copyBtnComplicate[1] === "false") { + return_value.showCopyBtn = false; + } + } + const regexResult_promptSimple = REGEX.PROMPT_SIMPLE.exec(firstline); + const regexResult_promptComplicate = REGEX.PROMPT_COMPLICATE.exec(firstline); + if (regexResult_promptSimple) { + return_value.showPrompt = true; + } else if (regexResult_promptComplicate) { + if (regexResult_promptComplicate[1] === "true") { + return_value.showPrompt = true; + } else if (regexResult_promptComplicate[1] === "false") { + return_value.showPrompt = false; + } else { + return_value.showPrompt = true; + return_value.prompt = regexResult_promptComplicate[2] || regexResult_promptComplicate[3]; + } + } + const regexResult_result = REGEX.RESULT.exec(firstline); + const regexResultPrompt_result = REGEX.PROMPT_COMPLICATE.exec(firstline); + if (regexResult_result) { + return_value.isResult = true; + return_value.showTitle = false; + return_value.showLanguage = false; + return_value.showCopyBtn = false; + return_value.showPrompt = false; + if (regexResultPrompt_result) { + return_value.resultPrompt = regexResultPrompt_result[2] || regexResultPrompt_result[3]; + } + } + return return_value; +} +function HKCodeBlockProcessor(el, context, plugin) { + const settings = plugin.settings; + const view = app.workspace.getActiveViewOfType(import_obsidian2.MarkdownView); + if (!view) + return; + const elem_codes = el.querySelectorAll("pre:not(.frontmatter) > code"); + if (elem_codes.length === 0) + return; + elem_codes.forEach((elem_code, elem_code_idx) => { + const elem_pre = elem_code.parentElement; + if (!elem_pre) + return; + const elem_pre_parent = elem_pre.parentElement; + if (!elem_pre_parent) + return; + const elem_copyBtn = elem_pre.querySelector(".copy-code-button"); + if (!elem_copyBtn) + return; + const section_code = context.getSectionInfo(elem_code); + if (!section_code) + return; + const { + isError, + lineStartInSection, + lineEndInSection, + showTitle, + title, + isCollapsible, + showLinenos, + linenosStart, + linenosNum, + showHighlight, + highlightLines, + showLanguage, + language, + showCopyBtn, + isResult, + resultPrompt, + showPrompt, + prompt + } = getMeta(view, elem_code, elem_code_idx, section_code, settings); + if (isError) + return; + if (settings.debugMode) { + console.log({ + isError, + lineStartInSection, + lineEndInSection, + showTitle, + title, + isCollapsible, + showLinenos, + linenosStart, + linenosNum, + showHighlight, + highlightLines, + showLanguage, + language, + showCopyBtn, + isResult, + resultPrompt, + showPrompt, + prompt + }); + } + const elem_div = document.createElement("div"); + elem_pre_parent.replaceChild(elem_div, elem_pre); + elem_div.appendChild(elem_pre); + elem_div.classList.add("hk-codeblock"); + elem_code.classList.add("hk-codeblock-code"); + elem_copyBtn.remove(); + let elem_title = void 0; + if (settings.useTitleGlobal === "default off, but on when specified" && showTitle === true) { + elem_div.classList.add("hk-codeblock-show-title"); + elem_title = document.createElement("div"); + elem_title.classList.add("hk-codeblock-title"); + elem_title.innerHTML = title; + elem_div.insertBefore(elem_title, elem_pre); + } + if (settings.useCollapsibleGlobal === "always on" || settings.useCollapsibleGlobal === "default on, but off when specified" && (isCollapsible === void 0 || isCollapsible === true) || settings.useCollapsibleGlobal === "default off, but on when specified" && isCollapsible === true) { + if (elem_title) { + elem_div.classList.add("hk-codeblock-collapsible"); + if (settings.defaultCollapse === "collapse") { + elem_div.classList.add("hk-codeblock-collapsed"); + } + elem_title.addEventListener("click", (ev) => { + ev.stopPropagation(); + ev.preventDefault(); + elem_div.classList.toggle("hk-codeblock-collapsed"); + }); + const elem_collapseBtns = document.createElement("div"); + elem_collapseBtns.classList.add("hk-codeblock-collapse-btns"); + const elem_collapseBtn = document.createElement("div"); + elem_collapseBtn.classList.add("hk-codeblock-collapse-btn", "hk-codeblock-collapsed-btn"); + elem_collapseBtn.innerHTML = ` + + `; + elem_collapseBtns.appendChild(elem_collapseBtn); + const elem_expandBtn = document.createElement("div"); + elem_expandBtn.classList.add("hk-codeblock-collapse-btn", "hk-codeblock-expanded-btn"); + elem_expandBtn.innerHTML = ` + + `; + elem_collapseBtns.appendChild(elem_expandBtn); + elem_title.prepend(elem_collapseBtns); + } + } + if (settings.useLinenosGlobal === "always on" || settings.useLinenosGlobal === "default on, but off when specified" && (showLinenos === void 0 || showLinenos === true) || settings.useLinenosGlobal === "default off, but on when specified" && showLinenos === true) { + elem_div.classList.add("hk-codeblock-show-linenos"); + const elem_linenos = document.createElement("div"); + elem_linenos.classList.add("hk-codeblock-linenos"); + elem_linenos.innerText = Array(linenosNum).fill(0).map((_, idx) => idx + linenosStart).join("\n"); + elem_pre.insertBefore(elem_linenos, elem_code); + if (settings.showLinenosSplitter) { + elem_linenos.classList.add("show-splitter"); + } + } + if (settings.useHighlightGlobal === "default off, but on when specified" && showHighlight === true) { + elem_div.classList.add("hk-codeblock-show-highlight"); + elem_div.style.setProperty("--hk-codeblock-highlight-background-color", settings.highlightColor); + const elem_highlight = document.createElement("div"); + elem_highlight.classList.add("hk-codeblock-highlight"); + elem_highlight.innerHTML = Array(linenosNum).fill(0).map((_, idx) => { + const classNames = []; + if (highlightLines.includes(idx + linenosStart)) + classNames.push("highlight"); + return ` `; + }).join("\n"); + elem_pre.insertBefore(elem_highlight, elem_code); + } + if (settings.useLanguageGlobal === "always on" || settings.useLanguageGlobal === "default on, but off when specified" && (showLanguage === void 0 || showLanguage === true) || settings.useLanguageGlobal === "default off, but on when specified" && showLanguage === true) { + elem_div.classList.add("hk-codeblock-show-language"); + const elem_language = document.createElement("div"); + elem_language.classList.add("hk-codeblock-language"); + elem_language.innerText = language; + elem_pre.prepend(elem_language); + } + if (settings.useCopyBtnGlobal === "always on" || settings.useCopyBtnGlobal === "default on, but off when specified" && (showCopyBtn === void 0 || showCopyBtn === true) || settings.useCopyBtnGlobal === "default off, but on when specified" && showCopyBtn === true) { + elem_div.classList.add("hk-codeblock-show-copybtn"); + elem_pre.appendChild(elem_copyBtn); + } + if (settings.usePromptGlobal === "always on" && settings.promptingLanguages.includes(language) || settings.usePromptGlobal === "default on, but off when specified" && settings.promptingLanguages.includes(language) && (showPrompt === void 0 || showPrompt === true) || settings.usePromptGlobal === "default off, but on when specified" && showPrompt === true) { + elem_div.classList.add("hk-codeblock-show-prompt"); + const elem_prompt = document.createElement("div"); + elem_prompt.classList.add("hk-codeblock-prompt"); + const lines = elem_code.innerText.split("\n"); + elem_prompt.innerText = Array(linenosNum).fill(0).map((_, idx) => { + if (idx < 0 || idx >= lines.length) + return null; + const line = lines[idx].trim(); + const prevLine = idx > 0 ? lines[idx - 1].trim() : ""; + if (line === "" || // check if the line is empty + line.startsWith("#") || // check if the line is a comment + prevLine.endsWith("\\")) { + return " ".repeat(prompt.length); + } + return prompt; + }).filter((line) => line !== null).join("\n"); + elem_pre.insertBefore(elem_prompt, elem_code); + } + if (settings.useResultGlobal === true && isResult === true) { + const isCodeBlockAdjacent = (() => { + let line_idx = lineStartInSection - 1; + while (line_idx >= 0) { + const line = view.editor.getLine(line_idx).trim(); + if (line.length === 0) { + line_idx--; + continue; + } else if (line === "```") { + return true; + } else { + return false; + } + } + return false; + })(); + if (isCodeBlockAdjacent) { + elem_div.classList.add("hk-codeblock-result"); + elem_code.classList.add("hk-codeblock-result-code"); + const elem_result_prompt = document.createElement("div"); + elem_result_prompt.classList.add("hk-codeblock-result-prompt"); + elem_result_prompt.innerText = resultPrompt; + elem_div.insertBefore(elem_result_prompt, elem_pre); + } + } + }); +} + +// src/main.ts +var HKCodeBlockPlugin = class extends import_obsidian3.Plugin { + async onload() { + await this.loadSettings(); + if (this.settings.debugMode) { + console.log("loading HK Code Block plugin"); + } + this.addSettingTab(new HKCodeBlockSettingTab(this.app, this)); + const processor = this.registerMarkdownPostProcessor((el, ctx) => { + HKCodeBlockProcessor(el, ctx, this); + }); + processor.sortOrder = 100; + } + onunload() { + if (this.settings.debugMode) { + console.log("unloading HKCodeBlock plugin"); + } + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/main.ts", "../src/settings.ts", "../src/settingTab.ts", "../src/processor.ts"],
  "sourcesContent": ["import { Plugin } from 'obsidian';\n\nimport type { HKCodeBlockSettings as HKCodeBlockSettings } from './settings';\nimport { DEFAULT_SETTINGS } from './settings';\nimport { HKCodeBlockSettingTab } from './settingTab';\nimport { HKCodeBlockProcessor } from './processor';\n\nexport default class HKCodeBlockPlugin extends Plugin {\n\tsettings: HKCodeBlockSettings;\n\n\tasync onload() {\n\t\tawait this.loadSettings();\n\t\tif (this.settings.debugMode) {\n\t\t\tconsole.log(\"loading HK Code Block plugin\");\n\t\t}\n\n\t\t// register settings tab\n\t\tthis.addSettingTab(new HKCodeBlockSettingTab(this.app, this));\n\n\t\t// register markdown post processor\n\t\tconst processor = this.registerMarkdownPostProcessor((el, ctx) => {\n\t\t\tHKCodeBlockProcessor(el, ctx, this);\n\t\t});\n\n\t\tprocessor.sortOrder = 100; // run after the default code block processor\n\t}\n\n\tonunload() {\n\t\tif (this.settings.debugMode) {\n\t\t\tconsole.log(\"unloading HKCodeBlock plugin\");\n\t\t}\n\t}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}", "export interface HKCodeBlockSettings {\n\tuseTitleGlobal: (\"default off, but on when specified\" | \"always off\");\n\n\tuseCollapsibleGlobal: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\n\tdefaultCollapse: (\"collapse\" | \"expand\");\n\tshowCollapseBtn: boolean;\n\n\tuseLinenosGlobal: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\n\tdefaultLinenosStart: number;\n\tshowLinenosSplitter: boolean;\n\n\tuseHighlightGlobal: (\"default off, but on when specified\" | \"always off\");\n\thighlightColor: string;\n\n\tuseLanguageGlobal: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\n\tdefaultLanguage: string;\n\t\n\tuseCopyBtnGlobal: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\n\t\n\tusePromptGlobal: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\n\tdefaultPrompt: string;\n\t\n\tuseResultGlobal: boolean;\n\tpromptingLanguages: string[];\n\tdefaultResultPrompt: string;\n\n\tdebugMode: boolean;\n}\n\nexport const DEFAULT_SETTINGS: HKCodeBlockSettings = {\n\tuseTitleGlobal: \"default off, but on when specified\",\n\n\tuseCollapsibleGlobal: \"default on, but off when specified\",\n\tdefaultCollapse: \"expand\",\n\tshowCollapseBtn: true,\n\n\tuseLinenosGlobal: \"default off, but on when specified\",\n\tdefaultLinenosStart: 1,\n\tshowLinenosSplitter: true,\n\n\tuseHighlightGlobal: \"default off, but on when specified\",\n\thighlightColor: \"#ff0000\",\n\n\tuseLanguageGlobal: \"default on, but off when specified\",\n\tdefaultLanguage: \"plain text\",\n\n\tuseCopyBtnGlobal: \"default on, but off when specified\",\n\n\tusePromptGlobal: \"default on, but off when specified\",\n\tpromptingLanguages: [\"bash\"],\n\tdefaultPrompt: \"$\",\n\n\tuseResultGlobal: true,\n\tdefaultResultPrompt: \"Result\",\n\n\tdebugMode: false,\n}", "import { App, PluginSettingTab, Setting } from 'obsidian';\n\nimport HKCodeBlockPlugin from './main';\n\nexport const fragWithHTML = (text: string) => {\n\treturn createFragment((frag) => {\n\t\tfrag.createDiv().innerHTML = text.split(\"\\n\").map((line) => line.trim()).join(\"<br>\");\n\t});\n}\n\nexport class HKCodeBlockSettingTab extends PluginSettingTab {\n\tplugin: HKCodeBlockPlugin;\n\n\tconstructor(app: App, plugin: HKCodeBlockPlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\t\tcontainerEl.empty();\n\n\t\t// title\n\t\tcontainerEl.createEl('h2', { text: 'Title' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Title')\n\t\t\t.setDesc(fragWithHTML(`- <b>default off, but on when specified</b> : the title will only be shown if the title statement is specified\n\t\t\t\t- <b>always off</b> : the title will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useTitleGlobal)\n\t\t\t\t\t.onChange(async (value: (\"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useTitleGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// collapse\n\t\tcontainerEl.createEl('h2', { text: 'Collapse' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Collapse')\n\t\t\t.setDesc(fragWithHTML(`- <b>always on</b> : the code block will always be collapsible\n\t\t\t\t- <b>default on, but off when specified</b> : the code block will always be collapsible, but will not be collapsed if collapse statement is specified as false\n\t\t\t\t- <b>default off, but on when specified</b> : the code block will only be collapsible if the collapse statement is specified as true\n\t\t\t\t- <b>always off</b> : the code block will never be collapsible`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"always on\": \"always on\",\n\t\t\t\t\t\"default on, but off when specified\": \"default on, but off when specified\",\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useCollapsibleGlobal)\n\t\t\t\t\t.onChange(async (value: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useCollapsibleGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Default Collapse State')\n\t\t\t.setDesc('The default collapse state of the code block.')\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"collapse\": \"collapse\",\n\t\t\t\t\t\"expand\": \"expand\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.defaultCollapse)\n\t\t\t\t\t.onChange(async (value: (\"collapse\" | \"expand\")) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultCollapse = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// line numbers\n\t\tcontainerEl.createEl('h2', { text: 'Line Numbers' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Line Numbers')\n\t\t\t.setDesc(fragWithHTML(`- <b>always on</b> : line numbers will always be shown\n\t\t\t\t- <b>default on, but off when specified</b> : line numbers will always be shown, but will not be shown if linenos statement is specified as false\n\t\t\t\t- <b>default off, but on when specified</b> : line numbers will only be shown if the linenos statement is specified as true\n\t\t\t\t- <b>always off</b> : line numbers will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"always on\": \"always on\",\n\t\t\t\t\t\"default on, but off when specified\": \"default on, but off when specified\",\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useLinenosGlobal)\n\t\t\t\t\t.onChange(async (value: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useLinenosGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Default Line Number Start')\n\t\t\t.setDesc('The default line number start of the code block.')\n\t\t\t.addText(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.defaultLinenosStart.toString())\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tconst num = parseInt(value);\n\t\t\t\t\t\tif (isNaN(num)) return;\n\n\t\t\t\t\t\tthis.plugin.settings.defaultLinenosStart = num;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Show Line Number Splitter')\n\t\t\t.addToggle(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.showLinenosSplitter)\n\t\t\t\t\t.onChange(async (value: boolean) => {\n\t\t\t\t\t\tthis.plugin.settings.showLinenosSplitter = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// line highlight\n\t\tcontainerEl.createEl('h2', { text: 'Line Highlight' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Line Highlight')\n\t\t\t.setDesc(fragWithHTML(`- <b>default off, but on when specified</b> : line highlight will only be shown if the line highlight statement is specified\n\t\t\t\t- <b>always off</b> : line highlight will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useHighlightGlobal)\n\t\t\t\t\t.onChange(async (value: (\"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useHighlightGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Line Highlight Color')\n\t\t\t.setDesc('The background color of the highlighted line. Note that the given color will be applied with 0.2 opacity.')\n\t\t\t.addText(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.highlightColor)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.highlightColor = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// language\n\t\tcontainerEl.createEl('h2', { text: 'Language Indicator' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Language Indicator')\n\t\t\t.setDesc(fragWithHTML(`- <b>always on</b> : language indicator will always be shown\n\t\t\t\t- <b>default on, but off when specified</b> : language indicator will always be shown, but will not be shown if the language indicator statement is specified as false\n\t\t\t\t- <b>default off, but on when specified</b> : language indicator will only be shown if the language indicator statement is specified as true\n\t\t\t\t- <b>always off</b> : language indicator will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"always on\": \"always on\",\n\t\t\t\t\t\"default on, but off when specified\": \"default on, but off when specified\",\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useLanguageGlobal)\n\t\t\t\t\t.onChange(async (value: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useLanguageGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Default Language')\n\t\t\t.setDesc('The default language name of the code block if the language is not specified.')\n\t\t\t.addText(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.defaultLanguage)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultLanguage = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\t\t\n\t\t// copy button\n\t\tcontainerEl.createEl('h2', { text: 'Copy Button' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Copy Button')\n\t\t\t.setDesc(fragWithHTML(`- <b>always on</b> : copy button will always be shown\n\t\t\t\t- <b>default on, but off when specified</b> : copy button will always be shown, but will not be shown if the copy button statement is specified as false\n\t\t\t\t- <b>default off, but on when specified</b> : copy button will only be shown if the copy button statement is specified as true\n\t\t\t\t- <b>always off</b> : copy button will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"always on\": \"always on\",\n\t\t\t\t\t\"default on, but off when specified\": \"default on, but off when specified\",\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useCopyBtnGlobal)\n\t\t\t\t\t.onChange(async (value: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.useCopyBtnGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// prompt\n\t\tcontainerEl.createEl('h2', { text: 'Prompt' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Prompt')\n\t\t\t.setDesc(fragWithHTML(`- <b>always on</b> : prompt will always be shown\n\t\t\t\t- <b>default on, but off when specified</b> : prompt will always be shown, but will not be shown if the prompt statement is specified as false\n\t\t\t\t- <b>default off, but on when specified</b> : prompt will only be shown if the prompt statement is specified as true\n\t\t\t\t- <b>always off</b> : prompt will never be shown`))\n\t\t\t.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"always on\": \"always on\",\n\t\t\t\t\t\"default on, but off when specified\": \"default on, but off when specified\",\n\t\t\t\t\t\"default off, but on when specified\": \"default off, but on when specified\",\n\t\t\t\t\t\"always off\": \"always off\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.usePromptGlobal)\n\t\t\t\t\t.onChange(async (value: (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\")) => {\n\t\t\t\t\t\tthis.plugin.settings.usePromptGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Prompting Languages')\n\t\t\t.setDesc('The languages that will be prompted by default. You can specify multiple languages by separating them with enters.')\n\t\t\t.addTextArea(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.promptingLanguages.join(\"\\n\"))\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tconst lines = value.split(\"\\n\").filter(line => line.trim() !== \"\");\n\t\t\t\t\t\tthis.plugin.settings.promptingLanguages = lines;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"Default Prompt\")\n\t\t\t.setDesc(\"The default prompt of the bash code block.\")\n\t\t\t.addText(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.defaultPrompt)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultPrompt = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// result\n\t\tcontainerEl.createEl('h2', { text: 'Result' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Use Result')\n\t\t\t.setDesc(fragWithHTML(`- <b>enable</b> : treat the code block starts like \\`\\`\\`\\`result\\` as the result of the adjacent previous code block\n\t\t\t\t- <b>disable</b> : treat the code block with \\`result\\` as its language name as a normal code block`))\n\t\t\t.addToggle(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.useResultGlobal)\n\t\t\t\t\t.onChange(async (value: boolean) => {\n\t\t\t\t\t\tthis.plugin.settings.useResultGlobal = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"Default Result Prompt\")\n\t\t\t.setDesc(\"The default prompt of the result code block.\")\n\t\t\t.addText(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.defaultResultPrompt)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultResultPrompt = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// for developers\n\t\tcontainerEl.createEl('h2', { text: 'Developers' });\n\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Debug Mode')\n\t\t\t.setDesc('Show logs in the console.')\n\t\t\t.addToggle(tc =>\n\t\t\t\ttc.setValue(this.plugin.settings.debugMode)\n\t\t\t\t\t.onChange(async (value: boolean) => {\n\t\t\t\t\t\tthis.plugin.settings.debugMode = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\t}\n}", "import { MarkdownView } from \"obsidian\";\nimport type { MarkdownPostProcessorContext, MarkdownSectionInformation } from \"obsidian\";\n\nimport HKCodeBlockPlugin from \"./main\";\nimport type { HKCodeBlockSettings } from \"./settings\";\n\nconst REGEX = {\n  TITLE: /\\stitle:(?:'(.*?)'|\"(.*?)\")\\s/,\n  COLLAPSIBLE_SIMPLE: /\\scollapsible\\s/,\n  COLLAPSIBLE_COMPLICATE: /\\scollapsible:(true|false)\\s/,\n  LINENOS_SIMPLE: /\\slinenos\\s/,\n  LINENOS_COMPLICATE: /\\slinenos:(true|false|(-{0,1}\\d+))\\s/,\n  HIGHLIGHT: /\\shighlight:(?:'(.*?)'|\"(.*?)\")\\s/,\n  LANGUAGE_FROM_CLASS: /^language-(\\w+)$/,\n  LANGUAGE_SIMPLE: /\\slanguage\\s/,\n  LANGUAGE_COMPLICATE: /\\slanguage:(true|false|'(.*?)'|\"(.*?)\")\\s/,\n  COPYBTN_SIMPLE: /\\scopybtn\\s/,\n  COPYBTN_COMPLICATE: /\\scopybtn:(true|false)\\s/,\n  RESULT: /^```result\\s/,\n  PROMPT_SIMPLE: /\\sprompt\\s/,\n  PROMPT_COMPLICATE: /\\sprompt:(true|false|'(.*?)'|\"(.*?)\")\\s/,\n  NUMBER: /^-{0,1}\\d+$/,\n}\n\nfunction getMeta(\n  view: MarkdownView,\n  elem_code: HTMLElement,\n  elem_code_idx: number,\n  section_code: MarkdownSectionInformation,\n  settings: HKCodeBlockSettings\n): {\n  isError: boolean,\n  lineStartInSection: number,\n  lineEndInSection: number,\n  showTitle: (boolean | undefined),\n  title: string,\n  isCollapsible: (boolean | undefined),\n  showLinenos: (boolean | undefined),\n  linenosStart: number,\n  linenosNum: number,\n  showHighlight: (boolean | undefined),\n  highlightLines: number[],\n  showLanguage: (boolean | undefined),\n  language: string,\n  showCopyBtn: (boolean | undefined),\n  isResult: boolean,\n  resultPrompt: string,\n  showPrompt: (boolean | undefined),\n  prompt: string\n} {\n  const return_value: {\n    isError: boolean,\n    lineStartInSection: number,\n    lineEndInSection: number,\n    showTitle: (boolean | undefined),\n    title: string,\n    isCollapsible: (boolean | undefined),\n    showLinenos: (boolean | undefined),\n    linenosStart: number,\n    linenosNum: number,\n    showHighlight: (boolean | undefined),\n    highlightLines: number[],\n    showLanguage: (boolean | undefined),\n    language: string,\n    showCopyBtn: (boolean | undefined),\n    isResult: boolean,\n    resultPrompt: string,\n    showPrompt: (boolean | undefined),\n    prompt: string\n  } = {\n    isError: false,\n    lineStartInSection: -1,\n    lineEndInSection: -1,\n    showTitle: undefined,\n    title: \"\",\n    isCollapsible: undefined,\n    showLinenos: undefined,\n    linenosStart: settings.defaultLinenosStart,\n    linenosNum: 0,\n    showHighlight: undefined,\n    highlightLines: [],\n    showLanguage: undefined,\n    language: settings.defaultLanguage,\n    showCopyBtn: undefined,\n    isResult: false,\n    resultPrompt: settings.defaultResultPrompt,\n    showPrompt: undefined,\n    prompt: settings.defaultPrompt\n  }\n\n  let marker_count = 0;\n  for (let i = section_code.lineStart; i <= section_code.lineEnd; i++) {\n    const line = view.editor.getLine(i);\n    if (line.trim().startsWith(\"```\")) marker_count++;\n\n    if (return_value.lineStartInSection === -1 && marker_count === elem_code_idx * 2 + 1) {\n      return_value.lineStartInSection = i;\n    }\n\n    if (return_value.lineEndInSection === -1 && marker_count === elem_code_idx * 2 + 2) {\n      return_value.lineEndInSection = i;\n      break;\n    }\n  }\n\n  if (return_value.lineStartInSection < 0 || return_value.lineEndInSection < 0 || return_value.lineStartInSection >= return_value.lineEndInSection) {\n    return_value.isError = true;\n    return return_value;\n  }\n\n  const firstline = view.editor.getLine(return_value.lineStartInSection).trim() + \" \"; // add a space to the end of the line to make sure the regex works\n\n  // title\n  const regexResult_title = REGEX.TITLE.exec(firstline);\n  if (regexResult_title) {\n    return_value.showTitle = true;\n    return_value.title = regexResult_title[1] || regexResult_title[2];\n  }\n\n  // collapsible\n  const regexResult_collapsibleSimple = REGEX.COLLAPSIBLE_SIMPLE.exec(firstline);\n  const regexResult_collapsibleComplicate = REGEX.COLLAPSIBLE_COMPLICATE.exec(firstline);\n  if (regexResult_collapsibleSimple) {\n    return_value.isCollapsible = true;\n  } else if (regexResult_collapsibleComplicate) {\n    if (regexResult_collapsibleComplicate[1] === \"true\") {\n      return_value.isCollapsible = true;\n    } else if (regexResult_collapsibleComplicate[1] === \"false\") {\n      return_value.isCollapsible = false;\n    }\n  }\n\n  // linenos\n  return_value.linenosNum = return_value.lineEndInSection - return_value.lineStartInSection - 1;\n  const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline);\n  const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline);\n  if (regexResult_linenosSimple) {\n    return_value.showLinenos = true;\n  } else if (regexResult_linenosComplicate) {\n    if (regexResult_linenosComplicate[1] === \"true\") {\n      return_value.showLinenos = true;\n    } else if (regexResult_linenosComplicate[1] === \"false\") {\n      return_value.showLinenos = false;\n    } else {\n      return_value.showLinenos = true;\n      return_value.linenosStart = parseInt(regexResult_linenosComplicate[2]) || 1;\n    }\n  }\n\n  // highlight\n  const regexResult_highlight = REGEX.HIGHLIGHT.exec(firstline);\n  if (regexResult_highlight) {\n    return_value.showHighlight = true;\n    const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2];\n    let highlightLines = highlightLines_str.split(\",\").map((item) => {\n      item = item.trim();\n\n      if (REGEX.NUMBER.test(item)) return parseInt(item);\n\n      const multiple_lines = item.split(\"-\");\n      if (multiple_lines.length === 2) {\n        const start = parseInt(multiple_lines[0].trim());\n        const end = parseInt(multiple_lines[1].trim());\n\n        if (!isNaN(start) && !isNaN(end)) {\n          return Array.from({ length: end - start + 1 }, (_, i) => i + start);\n        }\n      }\n\n      return NaN;\n    }).flat().filter((item) => !isNaN(item));\n\n    if (highlightLines.some((line) => isNaN(line))) {\n      // if any element is nan, then set showHighlight to false\n      return_value.showHighlight = undefined;\n      return_value.highlightLines = [];\n    } else {\n      // use only valid line numbers\n      return_value.highlightLines = highlightLines.filter(\n        (line) => line >= return_value.linenosStart && line < return_value.linenosStart + return_value.linenosNum\n      );\n    }\n  }\n\n  // language\n  elem_code.classList.forEach((className) => {\n    const regexResult_languageFromClass = REGEX.LANGUAGE_FROM_CLASS.exec(className.trim());\n    if (regexResult_languageFromClass) {\n      return_value.language = regexResult_languageFromClass[1];\n    }\n  });\n  const regexResult_languageSimple = REGEX.LANGUAGE_SIMPLE.exec(firstline);\n  const regexResult_languageComplicate = REGEX.LANGUAGE_COMPLICATE.exec(firstline);\n  if (regexResult_languageSimple) {\n    return_value.showLanguage = true;\n  } else if (regexResult_languageComplicate) {\n    if (regexResult_languageComplicate[1] === \"true\") {\n      return_value.showLanguage = true;\n    } else if (regexResult_languageComplicate[1] === \"false\") {\n      return_value.showLanguage = false;\n    } else {\n      return_value.showLanguage = true;\n      return_value.language = regexResult_languageComplicate[2] || regexResult_languageComplicate[3];\n    }\n  }\n\n  // copy button\n  const regexResult_copyBtnSimple = REGEX.COPYBTN_SIMPLE.exec(firstline);\n  const regexResult_copyBtnComplicate = REGEX.COPYBTN_COMPLICATE.exec(firstline);\n  if (regexResult_copyBtnSimple) {\n    return_value.showCopyBtn = true;\n  } else if (regexResult_copyBtnComplicate) {\n    if (regexResult_copyBtnComplicate[1] === \"true\") {\n      return_value.showCopyBtn = true;\n    } else if (regexResult_copyBtnComplicate[1] === \"false\") {\n      return_value.showCopyBtn = false;\n    }\n  }\n\n  // prompt\n  const regexResult_promptSimple = REGEX.PROMPT_SIMPLE.exec(firstline);\n  const regexResult_promptComplicate = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_promptSimple) {\n    return_value.showPrompt = true;\n  } else if (regexResult_promptComplicate) {\n    if (regexResult_promptComplicate[1] === \"true\") {\n      return_value.showPrompt = true;\n    } else if (regexResult_promptComplicate[1] === \"false\") {\n      return_value.showPrompt = false;\n    } else {\n      return_value.showPrompt = true;\n      return_value.prompt = regexResult_promptComplicate[2] || regexResult_promptComplicate[3];\n    }\n  }\n\n  // result\n  const regexResult_result = REGEX.RESULT.exec(firstline);\n  const regexResultPrompt_result = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_result) {\n    return_value.isResult = true;\n\n    // override other meta data : only linenos, highlight are available\n    return_value.showTitle = false;\n    return_value.showLanguage = false;\n    return_value.showCopyBtn = false;\n    return_value.showPrompt = false;\n\n    if (regexResultPrompt_result) {\n      return_value.resultPrompt = regexResultPrompt_result[2] || regexResultPrompt_result[3];\n    }\n  }\n\n  return return_value;\n}\n\nexport function HKCodeBlockProcessor(\n  el: HTMLElement,\n  context: MarkdownPostProcessorContext,\n  plugin: HKCodeBlockPlugin\n) {\n  const settings = plugin.settings;\n\n  const view = app.workspace.getActiveViewOfType(MarkdownView);\n  if (!view) return;\n\n  /* Note:\n  // - get all code blocks : obsidian markdown parser sometimes pass multiple code blocks\n  // - skip front matter\n  */\n  const elem_codes: NodeListOf<Element> = el.querySelectorAll(\"pre:not(.frontmatter) > code\");\n  if (elem_codes.length === 0) return;\n\n  elem_codes.forEach((elem_code: HTMLElement, elem_code_idx: number) => {\n    const elem_pre: (HTMLElement | null) = elem_code.parentElement;\n    if (!elem_pre) return;\n\n    const elem_pre_parent: (HTMLElement | null) = elem_pre.parentElement;\n    if (!elem_pre_parent) return;\n\n    const elem_copyBtn: (HTMLElement | null) = elem_pre.querySelector(\".copy-code-button\");\n    if (!elem_copyBtn) return;\n\n    const section_code: (MarkdownSectionInformation | null) = context.getSectionInfo(elem_code);\n    if (!section_code) return;\n\n    // get metadata\n    const {\n      isError,\n      lineStartInSection,\n      lineEndInSection,\n      showTitle,\n      title,\n      isCollapsible,\n      showLinenos,\n      linenosStart,\n      linenosNum,\n      showHighlight,\n      highlightLines,\n      showLanguage,\n      language,\n      showCopyBtn,\n      isResult,\n      resultPrompt,\n      showPrompt,\n      prompt,\n    }: {\n      isError: boolean,\n      lineStartInSection: number,\n      lineEndInSection: number,\n      showTitle: (boolean | undefined),\n      title: string,\n      isCollapsible: (boolean | undefined),\n      showLinenos: (boolean | undefined),\n      linenosStart: number,\n      linenosNum: number,\n      showHighlight: (boolean | undefined),\n      highlightLines: number[],\n      showLanguage: (boolean | undefined),\n      language: string,\n      showCopyBtn: (boolean | undefined),\n      isResult: boolean,\n      resultPrompt: string,\n      showPrompt: (boolean | undefined),\n      prompt: string\n    } = getMeta(view, elem_code, elem_code_idx, section_code, settings);\n    if (isError) return;\n    if (settings.debugMode) {\n      console.log({\n        isError: isError,\n        lineStartInSection: lineStartInSection,\n        lineEndInSection: lineEndInSection,\n        showTitle: showTitle,\n        title: title,\n        isCollapsible: isCollapsible,\n        showLinenos: showLinenos,\n        linenosStart: linenosStart,\n        linenosNum: linenosNum,\n        showHighlight: showHighlight,\n        highlightLines: highlightLines,\n        showLanguage: showLanguage,\n        language: language,\n        showCopyBtn: showCopyBtn,\n        isResult: isResult,\n        resultPrompt: resultPrompt,\n        showPrompt: showPrompt,\n        prompt: prompt,\n      })\n    }\n\n    // create HTML elements\n    const elem_div: HTMLElement = document.createElement(\"div\");\n    elem_pre_parent.replaceChild(elem_div, elem_pre);\n    elem_div.appendChild(elem_pre);\n\n    elem_div.classList.add(\"hk-codeblock\");\n    elem_code.classList.add(\"hk-codeblock-code\");\n    elem_copyBtn.remove(); // remove the original copy button as default\n\n    let elem_title: (HTMLElement | undefined) = undefined;\n    if (settings.useTitleGlobal === \"default off, but on when specified\" && (showTitle === true)) {\n      elem_div.classList.add(\"hk-codeblock-show-title\");\n\n      elem_title = document.createElement(\"div\");\n      elem_title.classList.add(\"hk-codeblock-title\");\n      elem_title.innerHTML = title;\n      elem_div.insertBefore(elem_title, elem_pre);\n    }\n\n    if (\n      (settings.useCollapsibleGlobal === \"always on\") ||\n      (settings.useCollapsibleGlobal === \"default on, but off when specified\" && (isCollapsible === undefined || isCollapsible === true)) ||\n      (settings.useCollapsibleGlobal === \"default off, but on when specified\" && (isCollapsible === true))\n    ) {\n      if (elem_title) {\n        elem_div.classList.add(\"hk-codeblock-collapsible\");\n\n        if (settings.defaultCollapse === \"collapse\") {\n          elem_div.classList.add(\"hk-codeblock-collapsed\");\n        }\n\n        elem_title.addEventListener(\"click\", (ev) => {\n          ev.stopPropagation();\n          ev.preventDefault();\n          elem_div.classList.toggle(\"hk-codeblock-collapsed\");\n        });\n\n        const elem_collapseBtns = document.createElement(\"div\");\n        elem_collapseBtns.classList.add(\"hk-codeblock-collapse-btns\");\n\n        const elem_collapseBtn = document.createElement(\"div\");\n        elem_collapseBtn.classList.add(\"hk-codeblock-collapse-btn\", \"hk-codeblock-collapsed-btn\");\n        elem_collapseBtn.innerHTML = `<svg viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\">\n        <path d=\"M10 19a1 1 0 0 1-.64-.23 1 1 0 0 1-.13-1.41L13.71 12 9.39 6.63a1 1 0 0 1 .15-1.41 1 1 0 0 1 1.46.15l4.83 6a1 1 0 0 1 0 1.27l-5 6A1 1 0 0 1 10 19z\"/>\n      </svg>`;\n        elem_collapseBtns.appendChild(elem_collapseBtn);\n\n        const elem_expandBtn = document.createElement(\"div\");\n        elem_expandBtn.classList.add(\"hk-codeblock-collapse-btn\", \"hk-codeblock-expanded-btn\");\n        elem_expandBtn.innerHTML = `<svg viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\">\n        <path d=\"M12 16a1 1 0 0 1-.64-.23l-6-5a1 1 0 1 1 1.28-1.54L12 13.71l5.36-4.32a1 1 0 0 1 1.41.15 1 1 0 0 1-.14 1.46l-6 4.83A1 1 0 0 1 12 16z\"/>\n      </svg>`;\n        elem_collapseBtns.appendChild(elem_expandBtn);\n\n        elem_title.prepend(elem_collapseBtns);\n      }\n    }\n\n\n    if (\n      (settings.useLinenosGlobal === \"always on\") ||\n      (settings.useLinenosGlobal === \"default on, but off when specified\" && (showLinenos === undefined || showLinenos === true)) ||\n      (settings.useLinenosGlobal === \"default off, but on when specified\" && (showLinenos === true))\n    ) {\n      elem_div.classList.add(\"hk-codeblock-show-linenos\");\n\n      const elem_linenos = document.createElement(\"div\");\n      elem_linenos.classList.add(\"hk-codeblock-linenos\");\n      elem_linenos.innerText = Array(linenosNum).fill(0).map((_, idx) => idx + linenosStart).join(\"\\n\");\n      elem_pre.insertBefore(elem_linenos, elem_code);\n\n      if (settings.showLinenosSplitter) {\n        elem_linenos.classList.add(\"show-splitter\");\n      }\n    }\n\n    if (settings.useHighlightGlobal === \"default off, but on when specified\" && (showHighlight === true)) {\n      elem_div.classList.add(\"hk-codeblock-show-highlight\");\n\n      elem_div.style.setProperty(\"--hk-codeblock-highlight-background-color\", settings.highlightColor);\n\n      const elem_highlight = document.createElement(\"div\");\n      elem_highlight.classList.add(\"hk-codeblock-highlight\");\n      elem_highlight.innerHTML = Array(linenosNum).fill(0).map((_, idx) => {\n        const classNames: string[] = [];\n        if (highlightLines.includes(idx + linenosStart)) classNames.push(\"highlight\");\n        return `<span class=\"line line-${idx + linenosStart} ${classNames.join(\" \")}\"> </span>`;\n      }).join(\"\\n\");\n      elem_pre.insertBefore(elem_highlight, elem_code);\n    }\n\n    if (\n      (settings.useLanguageGlobal === \"always on\") ||\n      (settings.useLanguageGlobal === \"default on, but off when specified\" && (showLanguage === undefined || showLanguage === true)) ||\n      (settings.useLanguageGlobal === \"default off, but on when specified\" && (showLanguage === true))\n    ) {\n      elem_div.classList.add(\"hk-codeblock-show-language\");\n\n      const elem_language = document.createElement(\"div\");\n      elem_language.classList.add(\"hk-codeblock-language\");\n      elem_language.innerText = language;\n      elem_pre.prepend(elem_language);\n    }\n\n    if (\n      (settings.useCopyBtnGlobal === \"always on\") ||\n      (settings.useCopyBtnGlobal === \"default on, but off when specified\" && (showCopyBtn === undefined || showCopyBtn === true)) ||\n      (settings.useCopyBtnGlobal === \"default off, but on when specified\" && (showCopyBtn === true))\n    ) {\n      elem_div.classList.add(\"hk-codeblock-show-copybtn\");\n\n      elem_pre.appendChild(elem_copyBtn);\n    }\n\n    if (\n      (settings.usePromptGlobal === \"always on\" && settings.promptingLanguages.includes(language)) ||\n      (settings.usePromptGlobal === \"default on, but off when specified\" && settings.promptingLanguages.includes(language) && (showPrompt === undefined || showPrompt === true)) ||\n      (settings.usePromptGlobal === \"default off, but on when specified\" && (showPrompt === true))\n    ) {\n      elem_div.classList.add(\"hk-codeblock-show-prompt\");\n\n      const elem_prompt = document.createElement(\"div\");\n      elem_prompt.classList.add(\"hk-codeblock-prompt\");\n\n      const lines = elem_code.innerText.split(\"\\n\");\n      elem_prompt.innerText = Array(linenosNum).fill(0).map((_, idx) => {\n        if (idx < 0 || idx >= lines.length) return null;\n\n        const line = lines[idx].trim();\n        const prevLine = idx > 0 ? lines[idx - 1].trim() : \"\";\n\n        if (\n          (line === \"\") || // check if the line is empty\n          (line.startsWith(\"#\")) || // check if the line is a comment\n          (prevLine.endsWith(\"\\\\\")) // check if the line is a continuation of the previous line\n        ) {\n          return \" \".repeat(prompt.length);\n        }\n\n        return prompt;\n      }).filter((line) => line !== null).join(\"\\n\");\n\n      elem_pre.insertBefore(elem_prompt, elem_code);\n    }\n\n    if (settings.useResultGlobal === true && (isResult === true)) {\n      const isCodeBlockAdjacent = ((): boolean => {\n        let line_idx = lineStartInSection - 1;\n        while (line_idx >= 0) {\n          const line = view.editor.getLine(line_idx).trim();\n          if (line.length === 0) {\n            line_idx--;\n            continue;\n          } else if (line === \"```\") {\n            return true;\n          } else {\n            return false;\n          }\n        }\n        return false;\n      })();\n\n      if (isCodeBlockAdjacent) {\n        elem_div.classList.add(\"hk-codeblock-result\");\n        elem_code.classList.add(\"hk-codeblock-result-code\");\n\n        const elem_result_prompt = document.createElement(\"div\");\n        elem_result_prompt.classList.add(\"hk-codeblock-result-prompt\");\n        elem_result_prompt.innerText = resultPrompt;\n        elem_div.insertBefore(elem_result_prompt, elem_pre);\n      }\n    }\n  });\n}"],
  "mappings": "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",
  "names": ["import_obsidian", "app", "import_obsidian"]
}
 diff --git a/.obsidian/plugins/hk-code-block/manifest.json b/.obsidian/plugins/hk-code-block/manifest.json new file mode 100644 index 0000000..d05b742 --- /dev/null +++ b/.obsidian/plugins/hk-code-block/manifest.json @@ -0,0 +1,11 @@ +{ + "id": "hk-code-block", + "name": "HK Code Block", + "version": "0.4.1", + "minAppVersion": "1.0.0", + "description": "Obsidian plugin developed by Heekang Park; Make code block looking good on reading view", + "author": "Heekang Park", + "authorUrl": "https://github.com/HeekangPark", + "fundingUrl": "", + "isDesktopOnly": false +} \ No newline at end of file diff --git a/.obsidian/plugins/hk-code-block/styles.css b/.obsidian/plugins/hk-code-block/styles.css new file mode 100644 index 0000000..6e81b18 --- /dev/null +++ b/.obsidian/plugins/hk-code-block/styles.css @@ -0,0 +1,241 @@ +/* src/styles.scss */ +.hk-codeblock { + position: relative; + margin-top: var(--hk-codeblock-margin); + margin-bottom: var(--hk-codeblock-margin); +} +.hk-codeblock { + --hk-codeblock-margin: 1em; + --hk-codeblock-horizontal-padding: 16px; + --hk-codeblock-vertical-padding: 8px; + --hk-codeblock-background-color: var(--code-background); + --hk-codeblock-border-color: var(--divider-color); + --hk-codeblock-font-family: var(--font-monospace); + --hk-codeblock-font-size: var(--code-size); + --hk-codeblock-text-color: var(--code-normal); + --hk-codeblock-title-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-title-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-title-text-size: var(--hk-codeblock-font-size); + --hk-codeblock-linenos-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-linenos-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-linenos-text-size: var(--hk-codeblock-font-size); + --hk-codeblock-language-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-language-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-language-text-size: calc(var(--hk-codeblock-font-size) * 0.9); + --hk-codeblock-copy-btn-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-copy-btn-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-copy-btn-text-size: calc(var(--hk-codeblock-font-size) * 0.9); + --hk-codeblock-prompt-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-prompt-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-prompt-text-size: var(--hk-codeblock-font-size); + --hk-codeblock-result-text-font: var(--hk-codeblock-font-family); + --hk-codeblock-result-text-color: var(--hk-codeblock-text-color); + --hk-codeblock-result-text-size: var(--hk-codeblock-font-size); +} +.hk-codeblock pre { + position: relative; + border-radius: initial; + display: flex; + flex-direction: row; + margin: 0; + min-height: 0; + padding-top: var(--hk-codeblock-vertical-padding); + padding-bottom: var(--hk-codeblock-vertical-padding); + padding-left: var(--hk-codeblock-horizontal-padding); + padding-right: var(--hk-codeblock-horizontal-padding); + background-color: var(--hk-codeblock-background-color); + font-family: var(--hk-codeblock-font-family); + color: var(--hk-codeblock-text-color); +} +.hk-codeblock pre code.hk-codeblock-code { + white-space: pre; + overflow-x: auto; + padding: 0; + background-color: var(--hk-codeblock-background-color); + font-family: var(--hk-codeblock-font-family); + color: var(--hk-codeblock-text-color); + font-size: var(--hk-codeblock-font-size); +} +.hk-codeblock.hk-codeblock-show-title .hk-codeblock-title { + padding-top: var(--hk-codeblock-vertical-padding); + padding-bottom: var(--hk-codeblock-vertical-padding); + padding-left: var(--hk-codeblock-horizontal-padding); + padding-right: var(--hk-codeblock-horizontal-padding); + background-color: var(--hk-codeblock-background-color); + border-bottom: 1px solid var(--hk-codeblock-border-color); + font-family: var(--hk-codeblock-title-text-font); + color: var(--hk-codeblock-title-text-color); + font-size: var(--hk-codeblock-title-text-size); + display: flex; + flex-direction: row; + align-items: center; +} +.hk-codeblock.hk-codeblock-show-title .hk-codeblock-title ~ pre { + margin-top: 0; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible .hk-codeblock-title { + cursor: pointer; + position: relative; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible .hk-codeblock-title .hk-codeblock-collapse-btns { + display: inline-flex; + align-items: center; + justify-content: center; + margin-right: 2px; + position: relative; + top: -1px; + left: -3px; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible .hk-codeblock-title .hk-codeblock-collapse-btns .hk-codeblock-collapse-btn { + width: var(--hk-codeblock-title-text-size); + height: var(--hk-codeblock-title-text-size); + fill: var(--hk-codeblock-title-text-color); + stroke: var(--hk-codeblock-title-text-color); + stroke-width: 2; + opacity: 0.2; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible .hk-codeblock-title .hk-codeblock-collapse-btns .hk-codeblock-collapse-btn.hk-codeblock-collapsed-btn { + display: none; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible .hk-codeblock-title .hk-codeblock-collapse-btns .hk-codeblock-collapse-btn.hk-codeblock-expanded-btn { + display: inline-block; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible.hk-codeblock-collapsed .hk-codeblock-title { + border-bottom: none; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible.hk-codeblock-collapsed .hk-codeblock-title .hk-codeblock-collapse-btns .hk-codeblock-collapse-btn.hk-codeblock-collapsed-btn { + display: inline-block; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible.hk-codeblock-collapsed .hk-codeblock-title .hk-codeblock-collapse-btns .hk-codeblock-collapse-btn.hk-codeblock-expanded-btn { + display: none; +} +.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible.hk-codeblock-collapsed pre { + display: none; +} +.hk-codeblock.hk-codeblock-show-linenos pre .hk-codeblock-linenos { + flex-shrink: 0; + flex-grow: 0; + text-align: right; + padding: 0; + padding-right: 1em; + opacity: 0.6; + user-select: none; + white-space: pre; + font-family: var(--hk-codeblock-linenos-text-font); + color: var(--hk-codeblock-linenos-text-color); + font-size: var(--hk-codeblock-linenos-text-size); + background-color: transparent; +} +.hk-codeblock.hk-codeblock-show-linenos pre .hk-codeblock-linenos.show-splitter { + border-right: 1px solid var(--hk-codeblock-border-color); + margin-right: 1em; +} +.hk-codeblock.hk-codeblock-show-highlight pre .hk-codeblock-highlight { + display: flex; + flex-direction: column; + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + pointer-events: none; + user-select: none; + padding-top: var(--hk-codeblock-vertical-padding); + padding-bottom: var(--hk-codeblock-vertical-padding); + opacity: 0.2; + font-family: var(--hk-codeblock-linenos-text-font); + font-size: var(--hk-codeblock-linenos-text-font); + color: var(--hk-codeblock-linenos-text-color); + background-color: transparent; +} +.hk-codeblock.hk-codeblock-show-highlight pre .hk-codeblock-highlight .line.highlight { + background-color: var(--hk-codeblock-highlight-background-color); +} +.hk-codeblock.hk-codeblock-show-language pre .hk-codeblock-language { + opacity: 0.4; + user-select: none; + z-index: 1; + margin: 6px; + padding-top: 6px; + padding-bottom: 6px; + padding-left: 8px; + padding-right: 8px; + background-color: transparent; + box-shadow: none; + font-family: var(--hk-codeblock-language-text-font); + color: var(--hk-codeblock-language-text-color); + font-size: var(--hk-codeblock-language-text-size); + position: absolute; + top: 0; + right: 0; +} +.hk-codeblock.hk-codeblock-show-language pre:hover .hk-codeblock-language { + display: none; +} +.hk-codeblock.hk-codeblock-show-copybtn pre .copy-code-button { + cursor: pointer; + opacity: 0.4; + user-select: none; + z-index: 1; + margin: 6px; + padding-top: 6px; + padding-bottom: 6px; + padding-left: 8px; + padding-right: 8px; + background-color: transparent; + box-shadow: none; + font-family: var(--hk-codeblock-copy-btn-text-font); + color: var(--hk-codeblock-copy-btn-text-color); + font-size: var(--hk-codeblock-copy-btn-text-size); + position: absolute; + top: 0; + right: 0; +} +.hk-codeblock.hk-codeblock-show-copybtn pre .copy-code-button:hover { + opacity: 1; + background-color: rgba(255, 255, 255, 0.0745098039); +} +.hk-codeblock.hk-codeblock-show-copybtn pre .copy-code-button:active { + opacity: 1; + background-color: rgba(255, 255, 255, 0.1490196078); +} +.hk-codeblock.hk-codeblock-show-prompt pre .hk-codeblock-prompt { + flex-shrink: 0; + flex-grow: 0; + text-align: right; + padding-top: 0; + padding-bottom: 0; + padding-left: 0; + padding-right: 0.8em; + opacity: 0.6; + user-select: none; + color: var(--hk-codeblock-prompt-text-color); + white-space: pre; + font-family: var(--hk-codeblock-prompt-text-font); + font-size: var(--hk-codeblock-prompt-text-size); + background-color: transparent; +} +.hk-codeblock.hk-codeblock-result { + margin-top: calc(var(--hk-codeblock-margin) * -1); + border-top: 1px solid var(--hk-codeblock-border-color); + background-color: var(--hk-codeblock-background-color); +} +.hk-codeblock.hk-codeblock-result .hk-codeblock-result-prompt { + color: var(--hk-codeblock-result-text-color); + opacity: 0.4; + font-size: 0.8em; + padding-top: var(--hk-codeblock-vertical-padding); + padding-left: var(--hk-codeblock-horizontal-padding); + padding-right: var(--hk-codeblock-horizontal-padding); + user-select: none; + pointer-events: none; +} +.hk-codeblock.hk-codeblock-result pre { + margin-top: 0; +} +.hk-codeblock.hk-codeblock-result pre .hk-codeblock-result-code { + color: var(--hk-codeblock-result-text-color); + font-family: var(--hk-codeblock-result-text-font); + font-size: var(--hk-codeblock-result-text-size); +} +/*# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/styles.scss"],
  "sourcesContent": [".hk-codeblock {\n  & {\n    // variables\n    --hk-codeblock-margin: 1em;\n    --hk-codeblock-horizontal-padding: 16px;\n    --hk-codeblock-vertical-padding: 8px;\n    --hk-codeblock-background-color: var(--code-background);\n    --hk-codeblock-border-color: var(--divider-color); // applied to title, linenos, and result\n    --hk-codeblock-font-family: var(--font-monospace);\n    --hk-codeblock-font-size: var(--code-size);\n    --hk-codeblock-text-color: var(--code-normal);\n\n    --hk-codeblock-title-text-font: var(--hk-codeblock-font-family);\n    --hk-codeblock-title-text-color: var(--hk-codeblock-text-color);\n    --hk-codeblock-title-text-size: var(--hk-codeblock-font-size);\n\n    --hk-codeblock-linenos-text-font: var(--hk-codeblock-font-family);\n    --hk-codeblock-linenos-text-color: var(--hk-codeblock-text-color);\n    --hk-codeblock-linenos-text-size: var(--hk-codeblock-font-size);\n\n    --hk-codeblock-language-text-font: var(--hk-codeblock-font-family); \n    --hk-codeblock-language-text-color: var(--hk-codeblock-text-color); \n    --hk-codeblock-language-text-size: calc(var(--hk-codeblock-font-size) * 0.9);\n\n    --hk-codeblock-copy-btn-text-font: var(--hk-codeblock-font-family);\n    --hk-codeblock-copy-btn-text-color: var(--hk-codeblock-text-color);\n    --hk-codeblock-copy-btn-text-size: calc(var(--hk-codeblock-font-size) * 0.9);\n\n    --hk-codeblock-prompt-text-font: var(--hk-codeblock-font-family);\n    --hk-codeblock-prompt-text-color: var(--hk-codeblock-text-color);\n    --hk-codeblock-prompt-text-size: var(--hk-codeblock-font-size);\n\n    --hk-codeblock-result-text-font: var(--hk-codeblock-font-family);\n    --hk-codeblock-result-text-color: var(--hk-codeblock-text-color);\n    --hk-codeblock-result-text-size: var(--hk-codeblock-font-size);\n  }\n\n  position: relative;\n\n  margin: {\n    top: var(--hk-codeblock-margin);\n    bottom: var(--hk-codeblock-margin);\n  }\n\n  pre {\n    position: relative;\n    border-radius: initial;\n    display: flex;\n    flex-direction: row;\n    margin: 0;\n    min-height: 0;\n\n    padding: {\n      top: var(--hk-codeblock-vertical-padding);\n      bottom: var(--hk-codeblock-vertical-padding);\n      left: var(--hk-codeblock-horizontal-padding);\n      right: var(--hk-codeblock-horizontal-padding);\n    }\n\n    background-color: var(--hk-codeblock-background-color);\n    font-family: var(--hk-codeblock-font-family);\n    color: var(--hk-codeblock-text-color);\n    //font-size: var(--hk-codeblock-font-size); // if the size is provided with the em unit, this can cause text being too small\n\n    code.hk-codeblock-code {\n      white-space: pre;\n      overflow-x: auto;\n      padding: 0;\n      background-color: var(--hk-codeblock-background-color);\n      font-family: var(--hk-codeblock-font-family);\n      color: var(--hk-codeblock-text-color);\n      font-size: var(--hk-codeblock-font-size);\n    }\n  }\n}\n\n/* title */\n.hk-codeblock.hk-codeblock-show-title {\n  .hk-codeblock-title {\n    padding: {\n      top: var(--hk-codeblock-vertical-padding);\n      bottom: var(--hk-codeblock-vertical-padding);\n      left: var(--hk-codeblock-horizontal-padding);\n      right: var(--hk-codeblock-horizontal-padding);\n    }\n\n    background-color: var(--hk-codeblock-background-color);\n    border-bottom: 1px solid var(--hk-codeblock-border-color);\n    font-family: var(--hk-codeblock-title-text-font);\n    color: var(--hk-codeblock-title-text-color);\n    font-size: var(--hk-codeblock-title-text-size);\n\n    display: flex;\n    flex-direction: row;\n    align-items: center;\n  }\n\n  .hk-codeblock-title~pre {\n    margin-top: 0;\n  }\n}\n\n/* collapse */\n.hk-codeblock.hk-codeblock-show-title.hk-codeblock-collapsible {\n  .hk-codeblock-title {\n    cursor: pointer;\n    position: relative;\n\n    .hk-codeblock-collapse-btns {\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      margin-right: 2px;\n      position: relative;\n      top: -1px;\n      left: -3px;\n\n      .hk-codeblock-collapse-btn {\n        width: var(--hk-codeblock-title-text-size);\n        height: var(--hk-codeblock-title-text-size);\n\n        fill: var(--hk-codeblock-title-text-color);\n        stroke: var(--hk-codeblock-title-text-color);\n        stroke-width: 2;\n        opacity: 0.2;\n\n        &.hk-codeblock-collapsed-btn {\n          display: none;\n        }\n\n        &.hk-codeblock-expanded-btn {\n          display: inline-block;\n        }\n      }\n    }\n  }\n\n  &.hk-codeblock-collapsed {\n    .hk-codeblock-title {\n      border-bottom: none;\n\n      .hk-codeblock-collapse-btns {\n        .hk-codeblock-collapse-btn {\n          &.hk-codeblock-collapsed-btn {\n            display: inline-block;\n          }\n\n          &.hk-codeblock-expanded-btn {\n            display: none;\n          }\n        }\n      }\n    }\n\n    pre {\n      display: none;\n    }\n  }\n}\n\n/* linenos */\n.hk-codeblock.hk-codeblock-show-linenos {\n  pre {\n    .hk-codeblock-linenos {\n      flex-shrink: 0;\n      flex-grow: 0;\n      text-align: right;\n      padding: 0;\n      padding-right: 1em;\n      opacity: 0.6;\n      user-select: none;\n      white-space: pre;\n      font-family: var(--hk-codeblock-linenos-text-font);\n      color: var(--hk-codeblock-linenos-text-color);\n      font-size: var(--hk-codeblock-linenos-text-size);\n      background-color: transparent;\n\n      &.show-splitter {\n        border-right: 1px solid var(--hk-codeblock-border-color);\n        margin-right: 1em;\n      }\n    }\n  }\n}\n\n/* highlight */\n.hk-codeblock.hk-codeblock-show-highlight {\n  pre {\n    .hk-codeblock-highlight {\n      display: flex;\n      flex-direction: column;\n      position: absolute;\n      top: 0;\n      left: 0;\n      right: 0;\n      bottom: 0;\n      pointer-events: none;\n      user-select: none;\n\n      padding: {\n        top: var(--hk-codeblock-vertical-padding);\n        bottom: var(--hk-codeblock-vertical-padding);\n      }\n\n      opacity: 0.2;\n      font-family: var(--hk-codeblock-linenos-text-font);\n      font-size: var(--hk-codeblock-linenos-text-font);\n      color: var(--hk-codeblock-linenos-text-color);\n      background-color: transparent;\n\n      .line.highlight {\n        background-color: var(--hk-codeblock-highlight-background-color);\n      }\n    }\n  }\n}\n\n/* language */\n.hk-codeblock.hk-codeblock-show-language {\n  pre {\n    .hk-codeblock-language {\n      opacity: 0.4;\n      user-select: none;\n      z-index: 1;\n      margin: 6px;\n\n      padding: {\n        top: 6px;\n        bottom: 6px;\n        left: 8px;\n        right: 8px;\n      }\n\n      background-color: transparent;\n      box-shadow: none;\n      font-family: var(--hk-codeblock-language-text-font);\n      color: var(--hk-codeblock-language-text-color);\n      font-size: var(--hk-codeblock-language-text-size);\n      position: absolute;\n      top: 0;\n      right: 0;\n    }\n\n    &:hover .hk-codeblock-language {\n      display: none;\n    }\n  }\n}\n\n/* copy button */\n.hk-codeblock.hk-codeblock-show-copybtn {\n  pre {\n    .copy-code-button {\n      cursor: pointer;\n\n      opacity: 0.4;\n      user-select: none;\n      z-index: 1;\n      margin: 6px;\n\n      padding: {\n        top: 6px;\n        bottom: 6px;\n        left: 8px;\n        right: 8px;\n      }\n\n      background-color: transparent;\n      box-shadow: none;\n      font-family: var(--hk-codeblock-copy-btn-text-font);\n      color: var(--hk-codeblock-copy-btn-text-color);\n      font-size: var(--hk-codeblock-copy-btn-text-size);\n      position: absolute;\n      top: 0;\n      right: 0;\n\n      &:hover {\n        opacity: 1;\n        background-color: #ffffff13;\n      }\n\n      &:active {\n        opacity: 1;\n        background-color: #ffffff26;\n      }\n    }\n  }\n}\n\n/* prompt */\n.hk-codeblock.hk-codeblock-show-prompt {\n  pre {\n    .hk-codeblock-prompt {\n      flex-shrink: 0;\n      flex-grow: 0;\n      text-align: right;\n\n      padding: {\n        top: 0;\n        bottom: 0;\n        left: 0;\n        right: 0.8em;\n      }\n\n      opacity: 0.6;\n      user-select: none;\n      color: var(--hk-codeblock-prompt-text-color);\n      white-space: pre;\n      font-family: var(--hk-codeblock-prompt-text-font);\n      font-size: var(--hk-codeblock-prompt-text-size);\n      background-color: transparent;\n    }\n  }\n}\n\n/* result */\n.hk-codeblock.hk-codeblock-result {\n  margin-top: calc(var(--hk-codeblock-margin) * (-1));\n  border-top: 1px solid var(--hk-codeblock-border-color);\n  background-color: var(--hk-codeblock-background-color);\n\n  .hk-codeblock-result-prompt {\n    color: var(--hk-codeblock-result-text-color);\n    opacity: 0.4;\n    font-size: 0.8em;\n\n    padding: {\n      top: var(--hk-codeblock-vertical-padding);\n      left: var(--hk-codeblock-horizontal-padding);\n      right: var(--hk-codeblock-horizontal-padding);\n    }\n\n    user-select: none;\n    pointer-events: none;\n  }\n\n  pre {\n    margin-top: 0;\n\n    .hk-codeblock-result-code {\n      color: var(--hk-codeblock-result-text-color);\n      font-family: var(--hk-codeblock-result-text-font);\n      font-size: var(--hk-codeblock-result-text-size);\n    }\n  }\n}"],
  "mappings": ";AAAA;AAqCE;AAGE;AACA;;AAxCF;AAEE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;;AAUF;AACE;AACA;AACA;AACA;AACA;AACA;AAGE;AACA;AACA;AACA;AAGF;AACA;AACA;;AAGA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;;AAOJ;AAEI;AACA;AACA;AACA;AAGF;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;;AAGF;AACE;;AAMF;AACE;AACA;;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;AACA;AAEA;AACA;AACA;AACA;;AAEA;AACE;;AAGF;AACE;;AAON;AACE;;AAII;AACE;;AAGF;AACE;;AAMR;AACE;;AAQF;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;AACA;;AASJ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGE;AACA;AAGF;AACA;AACA;AACA;AACA;;AAEA;AACE;;AASJ;AACE;AACA;AACA;AACA;AAGE;AACA;AACA;AACA;AAGF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;;AAQF;AACE;AAEA;AACA;AACA;AACA;AAGE;AACA;AACA;AACA;AAGF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;AACA;;AAGF;AACE;AACA;;AASJ;AACE;AACA;AACA;AAGE;AACA;AACA;AACA;AAGF;AACA;AACA;AACA;AACA;AACA;AACA;;AAMN;AACE;AACA;AACA;;AAEA;AACE;AACA;AACA;AAGE;AACA;AACA;AAGF;AACA;;AAGF;AACE;;AAEA;AACE;AACA;AACA;;",
  "names": []
}
 */ diff --git a/.obsidian/workspace-AWIN-DESKMEET.json b/.obsidian/workspace-AWIN-DESKMEET.json new file mode 100644 index 0000000..a74d324 --- /dev/null +++ b/.obsidian/workspace-AWIN-DESKMEET.json @@ -0,0 +1,236 @@ +{ + "main": { + "id": "fd76501ab5551c59", + "type": "split", + "children": [ + { + "id": "88d942ffc79a2389", + "type": "tabs", + "children": [ + { + "id": "182a7e73c49d10ce", + "type": "leaf", + "state": { + "type": "empty", + "state": {} + } + } + ] + } + ], + "direction": "vertical" + }, + "left": { + "id": "c03b931709aac93a", + "type": "split", + "children": [ + { + "id": "262a6c92848bc73a", + "type": "tabs", + "children": [ + { + "id": "f69acad103e7f817", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": { + "sortOrder": "alphabetical" + } + } + }, + { + "id": "bad194a4534ef74b", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + } + } + }, + { + "id": "e41d3ba9ac328959", + "type": "leaf", + "state": { + "type": "bookmarks", + "state": {} + } + } + ] + } + ], + "direction": "horizontal", + "width": 267.49999618530273 + }, + "right": { + "id": "bb4f1f6a5dddbb12", + "type": "split", + "children": [ + { + "id": "e04f7f5c2b67b828", + "type": "tabs", + "children": [ + { + "id": "71679272f2e33a87", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "e7f5fe3d8a7d256b", + "type": "leaf", + "state": { + "type": "outline", + "state": {} + } + }, + { + "id": "bac9d59fdcd09bd8", + "type": "leaf", + "state": { + "type": "advanced-tables-toolbar", + "state": {} + } + }, + { + "id": "61119a6658ef61a6", + "type": "leaf", + "state": { + "type": "all-properties", + "state": { + "sortOrder": "frequency", + "showSearch": false, + "searchQuery": "" + } + } + }, + { + "id": "d24e22dd36a5a962", + "type": "leaf", + "state": { + "type": "file-properties", + "state": {} + } + }, + { + "id": "4a0bb3cb0b31da42", + "type": "leaf", + "state": { + "type": "quiet-outline", + "state": {} + } + } + ], + "currentTab": 5 + }, + { + "id": "ae4bf98badbfc7ee", + "type": "tabs", + "children": [ + { + "id": "18b9707a37e1188a", + "type": "leaf", + "state": { + "type": "tag", + "state": { + "sortOrder": "frequency", + "useHierarchy": true + } + } + } + ] + } + ], + "direction": "horizontal", + "width": 319.5 + }, + "left-ribbon": { + "hiddenItems": { + "table-editor-obsidian:Advanced Tables Toolbar": false, + "switcher:開啟快速切換": false, + "graph:查看關聯圖": false, + "canvas:建立新畫布": false, + "daily-notes:開啟今天的每日筆記": false, + "templates:插入模板": false, + "command-palette:開啟命令面板": false, + "markdown-importer:開啟 Markdown 格式轉換器": false, + "random-note:開始漫遊筆記": false, + "workspaces:管理工作區配置": false, + "periodic-notes:Open today": false + } + }, + "active": "182a7e73c49d10ce", + "lastOpenFiles": [ + "05. 資料收集/Programming/C++/万字避坑指南！C++ 的缺陷与思考（上）.md", + "05. 資料收集/Programming/C++/Modern C++ use in Chromium.md", + "05. 資料收集/Programming/C++/Modern C++ The good parts.md", + "05. 資料收集/Programming/C++/A cheatsheet of modern C++ language and library features.md", + "05. 資料收集/Programming/C++/C++20, How Hard Could It Be.md", + "05. 資料收集/Linux/Docker.md", + "05. 資料收集/軟體工具、設定/Windows Terminal.md", + "orphaned files output.md", + "attachments/Pasted image 20210722145433.png", + "attachments/Pasted image 20220908123355.png", + "attachments/Pasted image 20210818115458.png", + "attachments/Pasted image 20210422205534.png", + "attachments/Pasted image 20210722093705.png", + "attachments/Pasted image 20230504183452.png", + "attachments/Pasted image 20220506145247.png", + "attachments/Pasted image 20210125183754.png", + "attachments/para_example.png", + "attachments/Pasted image 20220815135248.png", + "10. 工作/01. Logitech/Bolide.md", + "Pasted image 20230426213611.png.md", + "Pasted image 20230418111423.png.md", + "02. 個人：Daily/2023/01/2023-01-12(週四).md", + "broken links output.md", + "empty files.md", + "02. 個人：Daily/2020/12/2020-12-22(Tue).md", + "02. 個人：Daily/2020/12/2020-12-27(Sun).md", + "02. 個人：Daily/2021/01/2021-01-14(Thu).md", + "02. 個人：Daily/2021/01/2021-01-25(Mon).md", + "02. 個人：Daily/2021/01/2021-01-28(Thu).md", + "02. 個人：Daily/2021/02/2021-02-03(Wed).md", + "02. 個人：Daily/2021/02/2021-02-04(Thu).md", + "05. 資料收集/Linux/確認日誌的完整性.md", + "05. 資料收集/Programming/Keras/categorical_crossentropy.md", + "05. 資料收集/Programming/Keras/An example that use categorical_crossentropy and softmax.md", + "05. 資料收集/Linux/journalctl.md", + "02. 個人：Daily/2020/12/2020-12-03(Thu).md", + "05. 資料收集/裝置設定", + "05. 資料收集/Programming/OpenCV", + "05. 資料收集/Programming/numpy", + "05. 資料收集/Programming/Keras", + "00. Inbox/自我成長.canvas", + "00. Inbox/vc-fwUpdate code trace(Meetup).canvas", + "00. Inbox/My Mindmap.canvas", + "05. 資料收集/Windows/_Map.canvas", + "05. 資料收集/Programming/C++", + "00. Inbox/CPU Performance Control.canvas", + "05. 資料收集/Linux/_Map.canvas", + "00. Inbox/雜", + "05. 資料收集/樹莓派/_Map.canvas", + "00. Inbox/暫記：以後可能會用到", + "05. 資料收集/Windows", + "00. Inbox/Side project", + "00. Inbox/給孩子的簡報", + "01. 個人/讀書筆記/20240101 - 筆記的魔力.canvas", + "未命名 1.canvas", + "未命名.canvas" + ] +} \ No newline at end of file