From e7b6d543bbbd22d1ac4fcd73dc0a1efb19378940 Mon Sep 17 00:00:00 2001 From: Heekang Park Date: Tue, 14 Feb 2023 01:02:21 +0900 Subject: [PATCH] v0.3.0 --- .gitignore | 4 +- README.md | 38 +++++++++-- README_ko.md | 38 +++++++++-- dist/main.js | 95 ++++++++++++++++++++-------- dist/manifest.json | 2 +- dist/styles.css | 14 +++-- dist/versions.json | 3 +- imgs/highlight1.png | Bin 7981 -> 18701 bytes manifest.json | 2 +- package-lock.json | 4 +- package.json | 2 +- src/HKCodeBlockProcessor.ts | 122 +++++++++++++++++++++++++++--------- src/styles.scss | 10 ++- versions.json | 3 +- 14 files changed, 252 insertions(+), 85 deletions(-) diff --git a/.gitignore b/.gitignore index 9ef9a46..e48d514 100644 --- a/.gitignore +++ b/.gitignore @@ -2,5 +2,7 @@ node_modules +# ignore files for local testing main.js -styles.css \ No newline at end of file +styles.css +data.json \ No newline at end of file diff --git a/README.md b/README.md index 528b7e6..099532e 100644 --- a/README.md +++ b/README.md @@ -88,15 +88,23 @@ If you want to explicitly hide the line numbers, you can do it like this. You can highlight specific lines in the code block with commas like this. - ```python highlight:"2,3" - print("Hello world") - print("I love you") - print("Wow") + ```python highlight:"2-4,8,10" + print("line 1") + print("line 2") + print("line 3") + print("line 4") + print("line 5") + print("line 6") + print("line 7") + print("line 8") + print("line 9") + print("line 10") + print("line 11") ``` ![highlight1](https://github.com/HeekangPark/obsidian-hk-code-block/raw/master/imgs/highlight1.png) -You must put the line numbers in quotes. You can use both single and double quotes. +You must put the line numbers in quotes. You can use both single and double quotes. You can also use a dash to specify a range of line numbers. If you use the line numbers feature and set the line numbers don't start from 1, you must enter the line numbers to be highlighted according to that. @@ -345,8 +353,19 @@ MIT License - [Typewriter](https://github.com/crashmoney/obsidian-typewriter) - Most of the theme problem is caused by the usage of `!important` keywords in the theme CSS. HK Code Block does not use `!important` keywords at all in order to avoid conflicts with other themes or plugins. If you want to use HK Code Block plugin with those themes, you should modify the theme CSS files, or by using `!important` keywords, you should explicitly increase the priority of the HK Code Block CSS rules. +## Bug Report, Feature Request + +If you find any bugs or have any feature requests, please report them on the GitHub Issues. Thank you! + ## Changelog +Versions are controlled by the rule below. + +- Version x.y.z + - x : increased when huge changes are made(ex. change of logic, etc.) + - y : increased when features are newly added or changed + - z : increased when bug fixes are made + ### 0.1.0 - Initial release @@ -359,4 +378,11 @@ MIT License ### 0.2.1 - Bug fix - - Fix that prompted code blocks with multiple lines always show horizontal scrollbars \ No newline at end of file + - Fix that prompted code blocks with multiple lines always show horizontal scrollbars + +### 0.3.0 + +- Bug fix + - Fix that code blocks inside other elements(ex. li) are not rendered properly +- Add features + - Now you can use `-` symbols in the highlight statement so that you can easily highlight multiple, continuous lines. diff --git a/README_ko.md b/README_ko.md index 16f7b18..bfb7646 100644 --- a/README_ko.md +++ b/README_ko.md @@ -88,15 +88,23 @@ HK CodeBlock을 이용하면 Code Block에 다양한 기능들을 추가할 수 다음과 같이 강조하고 싶은 줄의 번호를 콤마로 구분하여 입력하면 해당 줄에 강조 효과를 줄 수 있습니다. - ```python highlight:"2,3" - print("Hello world") - print("I love you") - print("Wow") + ```python highlight:"2-4,8,10" + print("line 1") + print("line 2") + print("line 3") + print("line 4") + print("line 5") + print("line 6") + print("line 7") + print("line 8") + print("line 9") + print("line 10") + print("line 11") ``` ![highlight1](https://github.com/HeekangPark/obsidian-hk-code-block/raw/master/imgs/highlight1.png) -반드시 따옴표 안에 줄 번호를 넣어야 합니다. 큰따옴표와 작은 따옴표 모두 사용 가능합니다. +반드시 따옴표 안에 줄 번호를 넣어야 합니다. 큰따옴표와 작은 따옴표 모두 사용 가능합니다. 범위를 강조하고 싶다면 대시(`-`)를 사용하면 됩니다. 만약 줄 번호 기능을 사용해 줄 번호가 1부터 시작하지 않도록 했다면, 강조할 줄 번호를 입력할 때도 이에 맞춰서 입력해야 합니다. @@ -345,8 +353,19 @@ MIT License - [Typewriter](https://github.com/crashmoney/obsidian-typewriter) - 테마 문제의 대부분은 해당 테마들이 CSS에 `!important` 키워드를 붙여 HK Code Block의 CSS 우선순위가 밀려 발생합니다. HK Code Block은 다른 테마, 플러그인과의 호환성을 위해 `!important` 키워드를 사용하지 않습니다. 만약 이런 테마들에서도 HK Code Block을 사용하고 싶다면 해당 테마의 CSS를 수정하거나 `!important` 등을 사용, HK Code Block의 CSS 우선순위를 직접 높여야 합니다. +## 버그 제보, 기능 추가 요청 + +만약 사용 중 버그를 발견하거나, 기능 추가 요청이 있으시다면 GitHub Issues에 등록해주세요. 감사합니다! + ## Changelog +버전은 다음과 같은 규칙으로 관리됩니다. + +- 버전 x.y.z + - x : 전체 기능의 큰 변화가 있을 때(ex. 로직 변경 등) 증가합니다. + - y : 기능 추가 또는 수정이 있을 때 증가합니다. + - z : 버그 수정이 있을 때 증가합니다. + ### 0.1.0 - 최초 배포 @@ -359,4 +378,11 @@ MIT License ### 0.2.1 - 버그 수정 - - 여러 줄의 소스 코드가 있는 code block에서 프롬프트 기능 활성화 시 가로 스크롤이 생기는 문제 수정 \ No newline at end of file + - 여러 줄의 소스 코드가 있는 code block에서 프롬프트 기능 활성화 시 가로 스크롤이 생기는 문제 수정 + +### 0.3.0 + +- 버그 수정 + - 다른 요소(ex. li) 아래에 있는 code block이 이상하게 렌더링되던 문제 해결 +- 기능 추가 + - 이젠 줄 강조 시 `-` 기호를 사용해 손쉽게 여러 줄을 연속적으로 강조할 수 있음 \ No newline at end of file diff --git a/dist/main.js b/dist/main.js index e748ecf..740f09b 100644 --- a/dist/main.js +++ b/dist/main.js @@ -255,10 +255,30 @@ var REGEX = { COPYBTN_COMPLICATE: /\scopybtn:(true|false)\s/, RESULT: /^```result\s/, PROMPT_SIMPLE: /\sprompt\s/, - PROMPT_COMPLICATE: /\sprompt:(true|false|'(.*?)'|"(.*?)")\s/ + PROMPT_COMPLICATE: /\sprompt:(true|false|'(.*?)'|"(.*?)")\s/, + NUMBER: /^-{0,1}\d+$/ }; function getMeta(view, elem_code, section_code, settings) { - const firstline = view.editor.getLine(section_code.lineStart) + " "; + const lineStart = (() => { + for (let i = section_code.lineStart; i <= section_code.lineEnd; i++) { + const line = view.editor.getLine(i); + if (line.trim().startsWith("```")) + return i; + } + return -1; + })(); + const lineEnd = (() => { + for (let i = section_code.lineEnd; i >= section_code.lineStart; i--) { + const line = view.editor.getLine(i); + if (line.trim().startsWith("```")) + return i; + } + return -1; + })(); + if (lineStart < 0 || lineEnd < 0 || lineStart >= lineEnd) { + throw new Error("Cannot find the first line or the last line of the code block"); + } + const firstline = view.editor.getLine(lineStart) + " "; let showTitle = void 0; let title = ""; const regexResult_title = REGEX.TITLE.exec(firstline); @@ -280,7 +300,7 @@ function getMeta(view, elem_code, section_code, settings) { } let showLinenos = void 0; let linenosStart = settings.defaultLinenosStart; - const linenosNum = section_code.lineEnd - section_code.lineStart - 1; + const linenosNum = lineEnd - lineStart - 1; const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline); const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline); if (regexResult_linenosSimple) { @@ -301,7 +321,20 @@ function getMeta(view, elem_code, section_code, settings) { if (regexResult_highlight) { showHighlight = true; const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2]; - highlightLines = highlightLines_str.split(",").map((line) => parseInt(line)); + 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))) { showHighlight = void 0; highlightLines = []; @@ -413,27 +446,12 @@ async function HKCodeBlockProcessor(el, context, plugin) { const section_code = context.getSectionInfo(elem_code); if (!section_code) return; - const { - showTitle, - title, - isCollapsible, - showLinenos, - linenosStart, - linenosNum, - showHighlight, - highlightLines, - showLanguage, - language, - showCopyBtn, - isResult, - resultPrompt, - showPrompt, - prompt - } = getMeta(view, elem_code, section_code, settings); - if (settings.debugMode) { - console.log({ + let showTitle, title, isCollapsible, showLinenos, linenosStart, linenosNum, showHighlight, highlightLines, showLanguage, language, showCopyBtn, isResult, resultPrompt, showPrompt, prompt; + try { + ({ showTitle, title, + isCollapsible, showLinenos, linenosStart, linenosNum, @@ -446,7 +464,28 @@ async function HKCodeBlockProcessor(el, context, plugin) { resultPrompt, showPrompt, prompt - }); + } = getMeta(view, elem_code, section_code, settings)); + if (settings.debugMode) { + console.log({ + showTitle, + title, + isCollapsible, + showLinenos, + linenosStart, + linenosNum, + showHighlight, + highlightLines, + showLanguage, + language, + showCopyBtn, + isResult, + resultPrompt, + showPrompt, + prompt + }); + } + } catch (e) { + return; } elem_div.classList.add("hk-codeblock"); elem_code.classList.add("hk-codeblock-code"); @@ -504,7 +543,7 @@ async function HKCodeBlockProcessor(el, context, plugin) { 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("code"); + const elem_highlight = document.createElement("div"); elem_highlight.classList.add("hk-codeblock-highlight"); elem_highlight.innerHTML = Array(linenosNum).fill(0).map((_, idx) => { const classNames = []; @@ -531,6 +570,8 @@ async function HKCodeBlockProcessor(el, context, plugin) { 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 @@ -539,7 +580,7 @@ async function HKCodeBlockProcessor(el, context, plugin) { return " ".repeat(prompt.length); } return prompt; - }).join("\n"); + }).filter((line) => line !== null).join("\n"); elem_pre.insertBefore(elem_prompt, elem_code); } if (settings.useResultGlobal === "enable" && isResult === true) { @@ -574,4 +615,4 @@ var HKCodeBlockPlugin = class extends import_obsidian3.Plugin { await this.saveData(this.settings); } }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/main.ts", "../src/HKCodeBlockSettings.ts", "../src/HKCodeBlockSettingTab.ts", "../src/HKCodeBlockProcessor.ts"],
  "sourcesContent": ["import { Plugin, loadPrism } from 'obsidian';\n\nimport type { HKCodeBlockSettings } from './HKCodeBlockSettings';\nimport { DEFAULT_SETTINGS } from './HKCodeBlockSettings';\nimport { HKCodeBlockSettingTab } from './HKCodeBlockSettingTab';\nimport { HKCodeBlockProcessor } from './HKCodeBlockProcessor';\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 HKCodeBlock 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: (\"enable\" | \"disable\");\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: \"enable\",\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useTitleGlobal = value as (\"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useCollapsibleGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultCollapse = value as (\"collapse\" | \"expand\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useLinenosGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useHighlightGlobal = value as (\"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useLanguageGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useCopyBtnGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.usePromptGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"enable\": \"enable\",\n\t\t\t\t\t\"disable\": \"disable\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useResultGlobal)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useResultGlobal = value as (\"enable\" | \"disable\");\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 \"./HKCodeBlockSettings\";\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}\n\nfunction getMeta(view: MarkdownView, elem_code: HTMLElement, section_code: MarkdownSectionInformation, settings: HKCodeBlockSettings): {\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 firstline = view.editor.getLine(section_code.lineStart) + \" \"; // add a space to the end of the line to make sure the regex works\n\n  // title\n  let showTitle: (boolean | undefined) = undefined;\n  let title = \"\";\n  const regexResult_title = REGEX.TITLE.exec(firstline);\n  if (regexResult_title) {\n    showTitle = true;\n    title = regexResult_title[1] || regexResult_title[2];\n  }\n\n  // collapsible\n  let isCollapsible: (boolean | undefined) = undefined;\n  const regexResult_collapsibleSimple = REGEX.COLLAPSIBLE_SIMPLE.exec(firstline);\n  const regexResult_collapsibleComplicate = REGEX.COLLAPSIBLE_COMPLICATE.exec(firstline);\n  if (regexResult_collapsibleSimple) {\n    isCollapsible = true;\n  } else if (regexResult_collapsibleComplicate) {\n    if (regexResult_collapsibleComplicate[1] === \"true\") {\n      isCollapsible = true;\n    } else if (regexResult_collapsibleComplicate[1] === \"false\") {\n      isCollapsible = false;\n    }\n  }\n\n  // linenos\n  let showLinenos: (boolean | undefined) = undefined;\n  let linenosStart = settings.defaultLinenosStart;\n  const linenosNum = section_code.lineEnd - section_code.lineStart - 1;\n  const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline);\n  const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline);\n  if (regexResult_linenosSimple) {\n    showLinenos = true;\n  } else if (regexResult_linenosComplicate) {\n    if (regexResult_linenosComplicate[1] === \"true\") {\n      showLinenos = true;\n    } else if (regexResult_linenosComplicate[1] === \"false\") {\n      showLinenos = false;\n    } else {\n      showLinenos = true;\n      linenosStart = parseInt(regexResult_linenosComplicate[2]) || 1;\n    }\n  }\n\n  // highlight\n  let showHighlight: (boolean | undefined) = undefined;\n  let highlightLines: number[] = [];\n  const regexResult_highlight = REGEX.HIGHLIGHT.exec(firstline);\n  if (regexResult_highlight) {\n    showHighlight = true;\n    const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2];\n    highlightLines = highlightLines_str.split(\",\").map((line) => parseInt(line));\n\n    if (highlightLines.some((line) => isNaN(line))) {\n      // if any element is nan, then set showHighlight to false\n      showHighlight = undefined;\n      highlightLines = [];\n    } else {\n      // use only valid line numbers\n      highlightLines = highlightLines.filter((line) => line >= linenosStart && line < linenosStart + linenosNum);\n    }\n  }\n\n  // language\n  let showLanguage: (boolean | undefined) = undefined;\n  let language = (() => {\n    let language = settings.defaultLanguage;\n    elem_code.classList.forEach((className) => {\n      const regexResult_languageFromClass = REGEX.LANGUAGE_FROM_CLASS.exec(className.trim());\n      if (regexResult_languageFromClass) language = regexResult_languageFromClass[1];\n    });\n\n    return language;\n  })();\n  const regexResult_languageSimple = REGEX.LANGUAGE_SIMPLE.exec(firstline);\n  const regexResult_languageComplicate = REGEX.LANGUAGE_COMPLICATE.exec(firstline);\n  if (regexResult_languageSimple) {\n    showLanguage = true;\n  } else if (regexResult_languageComplicate) {\n    if (regexResult_languageComplicate[1] === \"true\") {\n      showLanguage = true;\n    } else if (regexResult_languageComplicate[1] === \"false\") {\n      showLanguage = false;\n    } else {\n      showLanguage = true;\n      language = regexResult_languageComplicate[2] || regexResult_languageComplicate[3];\n    }\n  }\n\n  // copy button\n  let showCopyBtn: (boolean | undefined) = undefined;\n  const regexResult_copyBtnSimple = REGEX.COPYBTN_SIMPLE.exec(firstline);\n  const regexResult_copyBtnComplicate = REGEX.COPYBTN_COMPLICATE.exec(firstline);\n  if (regexResult_copyBtnSimple) {\n    showCopyBtn = true;\n  } else if (regexResult_copyBtnComplicate) {\n    if (regexResult_copyBtnComplicate[1] === \"true\") {\n      showCopyBtn = true;\n    } else if (regexResult_copyBtnComplicate[1] === \"false\") {\n      showCopyBtn = false;\n    }\n  }\n\n  // prompt\n  let showPrompt: (boolean | undefined) = undefined;\n  let prompt = settings.defaultPrompt;\n  const regexResult_promptSimple = REGEX.PROMPT_SIMPLE.exec(firstline);\n  const regexResult_promptComplicate = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_promptSimple) {\n    showPrompt = true;\n  } else if (regexResult_promptComplicate) {\n    if (regexResult_promptComplicate[1] === \"true\") {\n      showPrompt = true;\n    } else if (regexResult_promptComplicate[1] === \"false\") {\n      showPrompt = false;\n    } else {\n      showPrompt = true;\n      prompt = regexResult_promptComplicate[2] || regexResult_promptComplicate[3];\n    }\n  }\n\n  // result\n  let isResult = false;\n  let resultPrompt = settings.defaultResultPrompt;\n  const regexResult_result = REGEX.RESULT.exec(firstline);\n  const regexResultPrompt_result = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_result) {\n    isResult = true;\n\n    // override other meta data : only linenos, highlight are available\n    showTitle = false;\n    showLanguage = false;\n    showCopyBtn = false;\n    showPrompt = false;\n\n    if (regexResultPrompt_result) {\n      resultPrompt = regexResultPrompt_result[2] || regexResultPrompt_result[3];\n    }\n  }\n\n  return {\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\nexport async 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  const elem_code: (HTMLElement | null) = el.querySelector(\"pre:not(.frontmatter) > code\");\n  if (!elem_code) return;\n\n  const elem_pre: (HTMLElement | null) = elem_code.parentElement;\n  if (!elem_pre) return;\n\n  const elem_div: (HTMLElement | null) = elem_pre.parentElement;\n  if (!elem_div) return;\n\n  const elem_copyBtn: (HTMLElement | null) = elem_div.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    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  } = getMeta(view, elem_code, section_code, settings);\n\n  if (settings.debugMode) {\n    console.log({\n      showTitle: showTitle,\n      title: title,\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  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    elem_div.classList.add(\"hk-codeblock-collapsible\");\n\n    if (settings.defaultCollapse === \"collapse\") {\n      elem_div.classList.add(\"hk-codeblock-collapsed\");\n    }\n\n    if (elem_title) {\n      elem_title.addEventListener(\"click\", (ev) => {\n        ev.stopPropagation();\n        ev.preventDefault();\n        if (elem_div.classList.contains(\"hk-codeblock-collapsed\")) {\n          elem_div.classList.remove(\"hk-codeblock-collapsed\");\n        } else {\n          elem_div.classList.add(\"hk-codeblock-collapsed\");\n        }\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(\"code\");\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      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    }).join(\"\\n\");\n\n    elem_pre.insertBefore(elem_prompt, elem_code);\n  }\n\n  if (settings.useResultGlobal === \"enable\" && (isResult === true)) {\n    elem_div.classList.add(\"hk-codeblock-result\");\n    elem_code.classList.add(\"hk-codeblock-result-code\");\n\n    elem_div.setAttribute(\"data-result-prompt\", resultPrompt);\n  }\n}"],
  "mappings": "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",
  "names": ["import_obsidian", "app", "import_obsidian", "language"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/main.ts", "../src/HKCodeBlockSettings.ts", "../src/HKCodeBlockSettingTab.ts", "../src/HKCodeBlockProcessor.ts"],
  "sourcesContent": ["import { Plugin, loadPrism } from 'obsidian';\n\nimport type { HKCodeBlockSettings } from './HKCodeBlockSettings';\nimport { DEFAULT_SETTINGS } from './HKCodeBlockSettings';\nimport { HKCodeBlockSettingTab } from './HKCodeBlockSettingTab';\nimport { HKCodeBlockProcessor } from './HKCodeBlockProcessor';\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 HKCodeBlock 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: (\"enable\" | \"disable\");\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: \"enable\",\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useTitleGlobal = value as (\"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useCollapsibleGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.defaultCollapse = value as (\"collapse\" | \"expand\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useLinenosGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useHighlightGlobal = value as (\"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useLanguageGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useCopyBtnGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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: string) => {\n\t\t\t\t\t\tthis.plugin.settings.usePromptGlobal = value as (\"always on\" | \"default on, but off when specified\" | \"default off, but on when specified\" | \"always off\");\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.addDropdown(tc =>\n\t\t\t\ttc.addOptions({\n\t\t\t\t\t\"enable\": \"enable\",\n\t\t\t\t\t\"disable\": \"disable\",\n\t\t\t\t})\n\t\t\t\t\t.setValue(this.plugin.settings.useResultGlobal)\n\t\t\t\t\t.onChange(async (value: string) => {\n\t\t\t\t\t\tthis.plugin.settings.useResultGlobal = value as (\"enable\" | \"disable\");\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 \"./HKCodeBlockSettings\";\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(view: MarkdownView, elem_code: HTMLElement, section_code: MarkdownSectionInformation, settings: HKCodeBlockSettings): {\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 lineStart = (() => {\n    for(let i = section_code.lineStart; i <= section_code.lineEnd; i++) {\n      const line = view.editor.getLine(i);\n      if (line.trim().startsWith(\"```\")) return i;\n    }\n\n    return -1;\n  })();\n\n  const lineEnd = (() => {\n    for(let i = section_code.lineEnd; i >= section_code.lineStart; i--) {\n      const line = view.editor.getLine(i);\n      if (line.trim().startsWith(\"```\")) return i;\n    }\n\n    return -1;\n  })();\n\n  if (lineStart < 0 || lineEnd < 0 || lineStart >= lineEnd) {\n    throw new Error(\"Cannot find the first line or the last line of the code block\");\n  }\n\n  const firstline = view.editor.getLine(lineStart) + \" \"; // add a space to the end of the line to make sure the regex works\n\n  // title\n  let showTitle: (boolean | undefined) = undefined;\n  let title = \"\";\n  const regexResult_title = REGEX.TITLE.exec(firstline);\n  if (regexResult_title) {\n    showTitle = true;\n    title = regexResult_title[1] || regexResult_title[2];\n  }\n\n  // collapsible\n  let isCollapsible: (boolean | undefined) = undefined;\n  const regexResult_collapsibleSimple = REGEX.COLLAPSIBLE_SIMPLE.exec(firstline);\n  const regexResult_collapsibleComplicate = REGEX.COLLAPSIBLE_COMPLICATE.exec(firstline);\n  if (regexResult_collapsibleSimple) {\n    isCollapsible = true;\n  } else if (regexResult_collapsibleComplicate) {\n    if (regexResult_collapsibleComplicate[1] === \"true\") {\n      isCollapsible = true;\n    } else if (regexResult_collapsibleComplicate[1] === \"false\") {\n      isCollapsible = false;\n    }\n  }\n\n  // linenos\n  let showLinenos: (boolean | undefined) = undefined;\n  let linenosStart = settings.defaultLinenosStart;\n  const linenosNum = lineEnd - lineStart - 1;\n  const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline);\n  const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline);\n  if (regexResult_linenosSimple) {\n    showLinenos = true;\n  } else if (regexResult_linenosComplicate) {\n    if (regexResult_linenosComplicate[1] === \"true\") {\n      showLinenos = true;\n    } else if (regexResult_linenosComplicate[1] === \"false\") {\n      showLinenos = false;\n    } else {\n      showLinenos = true;\n      linenosStart = parseInt(regexResult_linenosComplicate[2]) || 1;\n    }\n  }\n\n  // highlight\n  let showHighlight: (boolean | undefined) = undefined;\n  let highlightLines: number[] = [];\n  const regexResult_highlight = REGEX.HIGHLIGHT.exec(firstline);\n  if (regexResult_highlight) {\n    showHighlight = true;\n    const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2];\n    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      showHighlight = undefined;\n      highlightLines = [];\n    } else {\n      // use only valid line numbers\n      highlightLines = highlightLines.filter((line) => line >= linenosStart && line < linenosStart + linenosNum);\n    }\n  }\n\n  // language\n  let showLanguage: (boolean | undefined) = undefined;\n  let language = (() => {\n    let language = settings.defaultLanguage;\n    elem_code.classList.forEach((className) => {\n      const regexResult_languageFromClass = REGEX.LANGUAGE_FROM_CLASS.exec(className.trim());\n      if (regexResult_languageFromClass) language = regexResult_languageFromClass[1];\n    });\n\n    return language;\n  })();\n  const regexResult_languageSimple = REGEX.LANGUAGE_SIMPLE.exec(firstline);\n  const regexResult_languageComplicate = REGEX.LANGUAGE_COMPLICATE.exec(firstline);\n  if (regexResult_languageSimple) {\n    showLanguage = true;\n  } else if (regexResult_languageComplicate) {\n    if (regexResult_languageComplicate[1] === \"true\") {\n      showLanguage = true;\n    } else if (regexResult_languageComplicate[1] === \"false\") {\n      showLanguage = false;\n    } else {\n      showLanguage = true;\n      language = regexResult_languageComplicate[2] || regexResult_languageComplicate[3];\n    }\n  }\n\n  // copy button\n  let showCopyBtn: (boolean | undefined) = undefined;\n  const regexResult_copyBtnSimple = REGEX.COPYBTN_SIMPLE.exec(firstline);\n  const regexResult_copyBtnComplicate = REGEX.COPYBTN_COMPLICATE.exec(firstline);\n  if (regexResult_copyBtnSimple) {\n    showCopyBtn = true;\n  } else if (regexResult_copyBtnComplicate) {\n    if (regexResult_copyBtnComplicate[1] === \"true\") {\n      showCopyBtn = true;\n    } else if (regexResult_copyBtnComplicate[1] === \"false\") {\n      showCopyBtn = false;\n    }\n  }\n\n  // prompt\n  let showPrompt: (boolean | undefined) = undefined;\n  let prompt = settings.defaultPrompt;\n  const regexResult_promptSimple = REGEX.PROMPT_SIMPLE.exec(firstline);\n  const regexResult_promptComplicate = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_promptSimple) {\n    showPrompt = true;\n  } else if (regexResult_promptComplicate) {\n    if (regexResult_promptComplicate[1] === \"true\") {\n      showPrompt = true;\n    } else if (regexResult_promptComplicate[1] === \"false\") {\n      showPrompt = false;\n    } else {\n      showPrompt = true;\n      prompt = regexResult_promptComplicate[2] || regexResult_promptComplicate[3];\n    }\n  }\n\n  // result\n  let isResult = false;\n  let resultPrompt = settings.defaultResultPrompt;\n  const regexResult_result = REGEX.RESULT.exec(firstline);\n  const regexResultPrompt_result = REGEX.PROMPT_COMPLICATE.exec(firstline);\n  if (regexResult_result) {\n    isResult = true;\n\n    // override other meta data : only linenos, highlight are available\n    showTitle = false;\n    showLanguage = false;\n    showCopyBtn = false;\n    showPrompt = false;\n\n    if (regexResultPrompt_result) {\n      resultPrompt = regexResultPrompt_result[2] || regexResultPrompt_result[3];\n    }\n  }\n\n  return {\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\nexport async 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  const elem_code: (HTMLElement | null) = el.querySelector(\"pre:not(.frontmatter) > code\"); // skip front matter\n  if (!elem_code) return;\n\n  const elem_pre: (HTMLElement | null) = elem_code.parentElement;\n  if (!elem_pre) return;\n\n  const elem_div: (HTMLElement | null) = elem_pre.parentElement;\n  if (!elem_div) return;\n\n  const elem_copyBtn: (HTMLElement | null) = elem_div.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  let \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  try {\n    ({\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    } = getMeta(view, elem_code, section_code, settings));\n    \n    if (settings.debugMode) {\n      console.log({\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  } catch (e) { // if cannot find metadata, skip this code block\n    return;\n  }\n\n  // create HTML elements\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    elem_div.classList.add(\"hk-codeblock-collapsible\");\n\n    if (settings.defaultCollapse === \"collapse\") {\n      elem_div.classList.add(\"hk-codeblock-collapsed\");\n    }\n\n    if (elem_title) {\n      elem_title.addEventListener(\"click\", (ev) => {\n        ev.stopPropagation();\n        ev.preventDefault();\n        if (elem_div.classList.contains(\"hk-codeblock-collapsed\")) {\n          elem_div.classList.remove(\"hk-codeblock-collapsed\");\n        } else {\n          elem_div.classList.add(\"hk-codeblock-collapsed\");\n        }\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 === \"enable\" && (isResult === true)) {\n    elem_div.classList.add(\"hk-codeblock-result\");\n    elem_code.classList.add(\"hk-codeblock-result-code\");\n\n    elem_div.setAttribute(\"data-result-prompt\", resultPrompt);\n  }\n}"],
  "mappings": "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",
  "names": ["import_obsidian", "app", "import_obsidian", "language"]
}
 diff --git a/dist/manifest.json b/dist/manifest.json index 8ef1140..bb14daf 100644 --- a/dist/manifest.json +++ b/dist/manifest.json @@ -1,7 +1,7 @@ { "id": "hk-code-block", "name": "HK Code Block", - "version": "0.2.1", + "version": "0.3.0", "minAppVersion": "1.0.0", "description": "Obsidian plugin developed by Heekang Park; Make code block looking good on reading view", "author": "Heekang Park", diff --git a/dist/styles.css b/dist/styles.css index 7918aa9..81124ed 100644 --- a/dist/styles.css +++ b/dist/styles.css @@ -1,7 +1,6 @@ /* src/styles.scss */ .hk-codeblock { position: relative; - background-color: var(--hk-codeblock-background-color); margin-bottom: var(--hk-codeblock-margin); } .hk-codeblock { @@ -36,6 +35,7 @@ white-space: pre; overflow-x: auto; padding: 0; + background-color: var(--hk-codeblock-background-color); } .hk-codeblock.hk-codeblock-show-title .hk-codeblock-title { padding-left: var(--hk-codeblock-horizontal-padding); @@ -60,9 +60,10 @@ display: inline-flex; align-items: center; justify-content: center; - margin-right: 4px; + 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: 16px; @@ -108,7 +109,7 @@ border-right: 1px solid var(--hk-codeblock-border-color); margin-right: 1em; } -.hk-codeblock.hk-codeblock-show-highlight pre code.hk-codeblock-highlight { +.hk-codeblock.hk-codeblock-show-highlight pre .hk-codeblock-highlight { display: flex; flex-direction: column; position: absolute; @@ -121,8 +122,11 @@ 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-font-size); + background-color: transparent; } -.hk-codeblock.hk-codeblock-show-highlight pre code.hk-codeblock-highlight .line.highlight { +.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 { @@ -180,4 +184,4 @@ .hk-codeblock + .hk-codeblock.hk-codeblock-result pre .hk-codeblock-result-code { color: var(--hk-codeblock-result-text-color); } -/*# 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-size: var(--code-size);\n    --hk-codeblock-title-text-color: var(--text-normal);\n    --hk-codeblock-linenos-text-color: var(--code-normal);\n    --hk-codeblock-linenos-text-font: var(--font-monospace);\n    --hk-codeblock-language-text-color: var(--text-muted); // same with copy button\n    --hk-codeblock-language-text-size: var(--font-ui-smaller); // same with copy button\n    --hk-codeblock-language-text-font: var(--font-interface); // same with copy button\n    --hk-codeblock-prompt-text-color: var(--code-normal);\n    --hk-codeblock-prompt-text-font: var(--font-monospace);\n    --hk-codeblock-result-text-color: var(--text-normal);\n  }\n\n  position: relative;\n  background-color: var(--hk-codeblock-background-color);\n  margin-bottom: var(--hk-codeblock-margin);\n\n  pre {\n    position: relative;\n    display: flex;\n    flex-direction: row;\n    margin: 0;\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-bottom: var(--hk-codeblock-vertical-padding);\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n    background-color: var(--hk-codeblock-background-color);\n\n    code.hk-codeblock-code {\n      white-space: pre;\n      overflow-x: auto;\n      padding: 0;\n    }\n  }\n}\n\n/* title */\n.hk-codeblock.hk-codeblock-show-title {\n  .hk-codeblock-title {\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-bottom: var(--hk-codeblock-vertical-padding);\n    background-color: var(--hk-codeblock-background-color);\n    border-bottom: 1px solid var(--hk-codeblock-border-color);\n    color: var(--hk-codeblock-title-text-color);\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: 4px;\n      position: relative;\n      top: -1px;\n\n      .hk-codeblock-collapse-btn {\n        width: 16px;\n        height: 16px;\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      color: var(--hk-codeblock-linenos-text-color);\n      white-space: pre;\n      font-family: var(--hk-codeblock-linenos-text-font);\n      font-size: var(--hk-codeblock-font-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    code.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      padding-top: var(--hk-codeblock-vertical-padding);\n      padding-bottom: var(--hk-codeblock-vertical-padding);\n      opacity: 0.2;\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      padding: 6px 8px;\n      background-color: transparent;\n      box-shadow: none;\n      color: var(--hk-codeblock-language-text-color);\n      font-size: var(--hk-codeblock-language-text-size);\n      font-family: var(--hk-codeblock-language-text-font);\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  }\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      padding: 0;\n      padding-right: 0.8em;\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-font-size);\n      background-color: transparent;\n    }\n  }\n}\n\n/* result */\n.hk-codeblock+.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\n  &::before {\n    content: attr(data-result-prompt);\n    display: block;\n    color: var(--hk-codeblock-result-text-color);\n    opacity: 0.6;\n    font-size: 0.8em;\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n  }\n\n  pre {\n    margin-top: 0;\n\n    .hk-codeblock-result-code {\n      color: var(--hk-codeblock-result-text-color);\n    }\n  }\n}"],
  "mappings": ";AAAA;AAoBE;AACA;AACA;;AArBA;AAEE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOF;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;AACA;AACA;;AAOJ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;;AAGF;AACE;;AAMF;AACE;AACA;;AAEA;AACE;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;AACA;AACA;AACA;;AAEA;AACE;;AASJ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;;AAQF;AACE;;AAQF;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMN;AACE;AACA;;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;;AAEA;AACE;;",
  "names": []
}
 */ +/*# 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-size: var(--code-size);\n    --hk-codeblock-title-text-color: var(--text-normal);\n    --hk-codeblock-linenos-text-color: var(--code-normal);\n    --hk-codeblock-linenos-text-font: var(--font-monospace);\n    --hk-codeblock-language-text-color: var(--text-muted); // same with copy button\n    --hk-codeblock-language-text-size: var(--font-ui-smaller); // same with copy button\n    --hk-codeblock-language-text-font: var(--font-interface); // same with copy button\n    --hk-codeblock-prompt-text-color: var(--code-normal);\n    --hk-codeblock-prompt-text-font: var(--font-monospace);\n    --hk-codeblock-result-text-color: var(--text-normal);\n  }\n\n  position: relative;\n  margin-bottom: var(--hk-codeblock-margin);\n\n  pre {\n    position: relative;\n    display: flex;\n    flex-direction: row;\n    margin: 0;\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-bottom: var(--hk-codeblock-vertical-padding);\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n    background-color: var(--hk-codeblock-background-color);\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    }\n  }\n}\n\n/* title */\n.hk-codeblock.hk-codeblock-show-title {\n  .hk-codeblock-title {\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-bottom: var(--hk-codeblock-vertical-padding);\n    background-color: var(--hk-codeblock-background-color);\n    border-bottom: 1px solid var(--hk-codeblock-border-color);\n    color: var(--hk-codeblock-title-text-color);\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: 16px;\n        height: 16px;\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      color: var(--hk-codeblock-linenos-text-color);\n      white-space: pre;\n      font-family: var(--hk-codeblock-linenos-text-font);\n      font-size: var(--hk-codeblock-font-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      padding-top: var(--hk-codeblock-vertical-padding);\n      padding-bottom: var(--hk-codeblock-vertical-padding);\n      opacity: 0.2;\n      font-family: var(--hk-codeblock-linenos-text-font);\n      font-size: var(--hk-codeblock-font-size);\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      padding: 6px 8px;\n      background-color: transparent;\n      box-shadow: none;\n      color: var(--hk-codeblock-language-text-color);\n      font-size: var(--hk-codeblock-language-text-size);\n      font-family: var(--hk-codeblock-language-text-font);\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  }\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      padding: 0;\n      padding-right: 0.8em;\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-font-size);\n      background-color: transparent;\n    }\n  }\n}\n\n/* result */\n.hk-codeblock+.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\n  &::before {\n    content: attr(data-result-prompt);\n    display: block;\n    color: var(--hk-codeblock-result-text-color);\n    opacity: 0.6;\n    font-size: 0.8em;\n    padding-top: var(--hk-codeblock-vertical-padding);\n    padding-left: var(--hk-codeblock-horizontal-padding);\n    padding-right: var(--hk-codeblock-horizontal-padding);\n  }\n\n  pre {\n    margin-top: 0;\n\n    .hk-codeblock-result-code {\n      color: var(--hk-codeblock-result-text-color);\n    }\n  }\n}"],
  "mappings": ";AAAA;AAoBE;AACA;;AApBA;AAEE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMF;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;AACA;AACA;AACA;;AAOJ;AACE;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACE;;AASJ;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;;AAQF;AACE;;AAQF;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMN;AACE;AACA;;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;;AAEA;AACE;;",
  "names": []
}
 */ diff --git a/dist/versions.json b/dist/versions.json index 586b35b..841ea9b 100644 --- a/dist/versions.json +++ b/dist/versions.json @@ -1,5 +1,6 @@ { "0.1.0": "1.0.0", "0.2.0": "1.0.0", - "0.2.1": "1.0.0" + "0.2.1": "1.0.0", + "0.3.0": "1.0.0" } diff --git a/imgs/highlight1.png b/imgs/highlight1.png index 520d7466cec1abe6bc887801b33e33c0042ac2fa..59c82a0f1bcfae41b9bf00b9cb7cf5a74f762ace 100644 GIT binary patch literal 18701 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 q&_5G_K16xpp|V1r2!Mh>02$Ajgr zIs5cMbx@WPLn#?1-+3AUOhx6MBFZDM@AO|hjWKPdH62h;@H+l^P zjQnnQG|Vc_Z1`wqycN9wwxD<@OEhU#1)BHtQj8@k1KTI8q8t6}s+f*5eYKb#T6{G#%l;T^iX=9;(!1VrPFu$DpRmx{JA%#h^}y(@0}r za=#Q6lg>-WAQBV9m5d}HvS5P2BNfF7>EQ4;!EdSQCKLgf)am{-e1t`_;ler|WzaC0 zh#�!#y$epWo(^_=Y7#$ng0^xkw{y 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 { + for(let i = section_code.lineStart; i <= section_code.lineEnd; i++) { + const line = view.editor.getLine(i); + if (line.trim().startsWith("```")) return i; + } + + return -1; + })(); + + const lineEnd = (() => { + for(let i = section_code.lineEnd; i >= section_code.lineStart; i--) { + const line = view.editor.getLine(i); + if (line.trim().startsWith("```")) return i; + } + + return -1; + })(); + + if (lineStart < 0 || lineEnd < 0 || lineStart >= lineEnd) { + throw new Error("Cannot find the first line or the last line of the code block"); + } + + const firstline = view.editor.getLine(lineStart) + " "; // add a space to the end of the line to make sure the regex works // title let showTitle: (boolean | undefined) = undefined; @@ -66,7 +89,7 @@ function getMeta(view: MarkdownView, elem_code: HTMLElement, section_code: Markd // linenos let showLinenos: (boolean | undefined) = undefined; let linenosStart = settings.defaultLinenosStart; - const linenosNum = section_code.lineEnd - section_code.lineStart - 1; + const linenosNum = lineEnd - lineStart - 1; const regexResult_linenosSimple = REGEX.LINENOS_SIMPLE.exec(firstline); const regexResult_linenosComplicate = REGEX.LINENOS_COMPLICATE.exec(firstline); if (regexResult_linenosSimple) { @@ -89,7 +112,23 @@ function getMeta(view: MarkdownView, elem_code: HTMLElement, section_code: Markd if (regexResult_highlight) { showHighlight = true; const highlightLines_str = regexResult_highlight[1] || regexResult_highlight[2]; - highlightLines = highlightLines_str.split(",").map((line) => parseInt(line)); + 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))) { // if any element is nan, then set showHighlight to false @@ -207,7 +246,7 @@ export async function HKCodeBlockProcessor( const view = app.workspace.getActiveViewOfType(MarkdownView); if (!view) return; - const elem_code: (HTMLElement | null) = el.querySelector("pre:not(.frontmatter) > code"); + const elem_code: (HTMLElement | null) = el.querySelector("pre:not(.frontmatter) > code"); // skip front matter if (!elem_code) return; const elem_pre: (HTMLElement | null) = elem_code.parentElement; @@ -223,28 +262,27 @@ export async function HKCodeBlockProcessor( if (!section_code) return; // get metadata - const { - showTitle, - title, - isCollapsible, - showLinenos, - linenosStart, - linenosNum, - showHighlight, - highlightLines, - showLanguage, - language, - showCopyBtn, - isResult, - resultPrompt, - showPrompt, - prompt - } = getMeta(view, elem_code, section_code, settings); - - if (settings.debugMode) { - console.log({ + let + showTitle: (boolean | undefined), + title: string, + isCollapsible: (boolean | undefined), + showLinenos: (boolean | undefined), + linenosStart: number, + linenosNum: number, + showHighlight: (boolean | undefined), + highlightLines: number[], + showLanguage: (boolean | undefined), + language: string, + showCopyBtn: (boolean | undefined), + isResult: boolean, + resultPrompt: string, + showPrompt: (boolean | undefined), + prompt: string; + try { + ({ showTitle: showTitle, title: title, + isCollapsible: isCollapsible, showLinenos: showLinenos, linenosStart: linenosStart, linenosNum: linenosNum, @@ -257,7 +295,29 @@ export async function HKCodeBlockProcessor( resultPrompt: resultPrompt, showPrompt: showPrompt, prompt: prompt, - }) + } = getMeta(view, elem_code, section_code, settings)); + + if (settings.debugMode) { + console.log({ + showTitle: showTitle, + title: title, + isCollapsible: isCollapsible, + showLinenos: showLinenos, + linenosStart: linenosStart, + linenosNum: linenosNum, + showHighlight: showHighlight, + highlightLines: highlightLines, + showLanguage: showLanguage, + language: language, + showCopyBtn: showCopyBtn, + isResult: isResult, + resultPrompt: resultPrompt, + showPrompt: showPrompt, + prompt: prompt, + }) + } + } catch (e) { // if cannot find metadata, skip this code block + return; } // create HTML elements @@ -341,7 +401,7 @@ export async function HKCodeBlockProcessor( elem_div.style.setProperty("--hk-codeblock-highlight-background-color", settings.highlightColor); - const elem_highlight = document.createElement("code"); + const elem_highlight = document.createElement("div"); elem_highlight.classList.add("hk-codeblock-highlight"); elem_highlight.innerHTML = Array(linenosNum).fill(0).map((_, idx) => { const classNames: string[] = []; @@ -383,22 +443,24 @@ export async function HKCodeBlockProcessor( 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(): ""; + 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("\\")) // check if the line is a continuation of the previous line - ) { + ) { return " ".repeat(prompt.length); } return prompt; - }).join("\n"); + }).filter((line) => line !== null).join("\n"); elem_pre.insertBefore(elem_prompt, elem_code); } diff --git a/src/styles.scss b/src/styles.scss index b037747..7ca9cd7 100644 --- a/src/styles.scss +++ b/src/styles.scss @@ -19,7 +19,6 @@ } position: relative; - background-color: var(--hk-codeblock-background-color); margin-bottom: var(--hk-codeblock-margin); pre { @@ -37,6 +36,7 @@ white-space: pre; overflow-x: auto; padding: 0; + background-color: var(--hk-codeblock-background-color); } } } @@ -72,9 +72,10 @@ display: inline-flex; align-items: center; justify-content: center; - margin-right: 4px; + margin-right: 2px; position: relative; top: -1px; + left: -3px; .hk-codeblock-collapse-btn { width: 16px; @@ -147,7 +148,7 @@ /* highlight */ .hk-codeblock.hk-codeblock-show-highlight { pre { - code.hk-codeblock-highlight { + .hk-codeblock-highlight { display: flex; flex-direction: column; position: absolute; @@ -160,6 +161,9 @@ 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-font-size); + background-color: transparent; .line.highlight { background-color: var(--hk-codeblock-highlight-background-color); diff --git a/versions.json b/versions.json index 586b35b..841ea9b 100644 --- a/versions.json +++ b/versions.json @@ -1,5 +1,6 @@ { "0.1.0": "1.0.0", "0.2.0": "1.0.0", - "0.2.1": "1.0.0" + "0.2.1": "1.0.0", + "0.3.0": "1.0.0" }