diff --git a/.gitignore b/.gitignore index e09a007e..b5b913d1 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,7 @@ node_modules # Don't include the compiled main.js file in the repo. # They should be uploaded to GitHub releases instead. -main.js +# main.js # Exclude sourcemaps *.map diff --git a/main.js b/main.js new file mode 100644 index 00000000..4b796c43 --- /dev/null +++ b/main.js @@ -0,0 +1,620 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// main.ts +var main_exports = {}; +__export(main_exports, { + MultLineHandle: () => MultLineHandle, + default: () => BlockLinkPlus +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian = require("obsidian"); +var import_view = require("@codemirror/view"); +var MultLineHandle = /* @__PURE__ */ ((MultLineHandle2) => { + MultLineHandle2[MultLineHandle2["oneline"] = 0] = "oneline"; + MultLineHandle2[MultLineHandle2["heading"] = 1] = "heading"; + MultLineHandle2[MultLineHandle2["multblock"] = 2] = "multblock"; + return MultLineHandle2; +})(MultLineHandle || {}); +var DEFAULT_SETTINGS = { + mult_line_handle: 0 /* oneline */, + // as one line handle + enble_prefix: false, + // no prefix + id_prefix: "", + // prefix + id_length: 4 + // id length +}; +function generateRandomId(prefix, length) { + if (length < 3 || length > 7) { + throw new Error("Length must be between 3 and 7."); + } + const separator = prefix ? "-" : ""; + return `${prefix}${separator}${Math.random().toString(36).substring(2, 2 + length)}`; +} +function shouldInsertAfter(block) { + if (block.type) { + return [ + "blockquote", + "code", + "table", + "comment", + "footnoteDefinition" + ].includes(block.type); + } +} +function analyzeHeadings(fileCache, start_line, end_line) { + var _a, _b; + if (!fileCache || end_line < start_line) { + return { + isValid: false, + start_line, + end_line, + isMultiline: false, + block: null, + nearestBeforeStartLevel: 0, + minLevelInRange: Infinity, + hasHeadingAtStart: false, + hasHeadingAtEnd: false, + headingAtStart: null, + headingAtEnd: null, + isStartHeadingMinLevel: false, + isEndLineJustBeforeHeading: false + }; + } + if (start_line == end_line) { + let head_block = (_a = fileCache.headings) == null ? void 0 : _a.find( + (heading) => { + const { start, end } = heading.position; + return start.line == start_line; + } + ); + let block2 = (fileCache.sections || []).find((section) => { + return section.position.start.line <= end_line && section.position.end.line >= end_line; + }); + return { + isValid: true, + start_line, + end_line, + isMultiline: false, + block: block2, + nearestBeforeStartLevel: 0, + minLevelInRange: head_block ? head_block.level : Infinity, + hasHeadingAtStart: !!block2, + hasHeadingAtEnd: false, + headingAtStart: head_block || null, + headingAtEnd: null, + isStartHeadingMinLevel: block2 ? true : false, + isEndLineJustBeforeHeading: false + }; + } + let nearestBeforeStartLevel = 0; + let minLevelInRange = Infinity; + let hasHeadingAtStart = false; + let hasHeadingAtEnd = false; + let headingAtStart = null; + let headingAtEnd = null; + let isStartHeadingMinLevel = false; + let isEndLineJustBeforeHeading = false; + let closestBeforeStartDistance = Infinity; + let inner_levels = new Array(); + (_b = fileCache.headings) == null ? void 0 : _b.forEach((heading) => { + const { start, end } = heading.position; + if (start.line < start_line) { + const distance = start_line - start.line; + if (start_line - start.line < closestBeforeStartDistance) { + closestBeforeStartDistance = distance; + nearestBeforeStartLevel = heading.level; + } + } + if (start.line >= start_line && end.line <= end_line) { + minLevelInRange = Math.min(minLevelInRange, heading.level); + inner_levels.push(heading.level); + } + if (start.line === start_line) { + hasHeadingAtStart = true; + headingAtStart = heading; + } + if (start.line === end_line) { + hasHeadingAtEnd = true; + headingAtEnd = heading; + } + if (start.line === end_line + 1 || start.line === end_line + 2) { + isEndLineJustBeforeHeading = true; + } + }); + if (hasHeadingAtStart && headingAtStart != null) { + if (headingAtStart.level === minLevelInRange) { + const minLevel = Math.min(...inner_levels); + const countOfMinLevel = inner_levels.filter( + (level) => level === minLevel + ).length; + if (headingAtStart && // @ts-ignore + headingAtStart.level === minLevel && countOfMinLevel === 1) { + isStartHeadingMinLevel = true; + } + } + } + let block = (fileCache.sections || []).find((section) => { + return section.position.start.line <= end_line && section.position.end.line >= end_line; + }); + return { + isValid: true, + start_line, + end_line, + isMultiline: true, + block, + nearestBeforeStartLevel, + minLevelInRange, + hasHeadingAtStart, + hasHeadingAtEnd, + headingAtStart, + headingAtEnd, + isStartHeadingMinLevel, + isEndLineJustBeforeHeading + }; +} +function get_is_heading(head_analysis) { + if (!head_analysis.isValid) { + return false; + } + if (!head_analysis.isMultiline) { + if (head_analysis.hasHeadingAtStart && head_analysis.headingAtStart != null) + return true; + } else { + if (head_analysis.hasHeadingAtStart && // start_line is a heading + head_analysis.isStartHeadingMinLevel) + return true; + } + return false; +} +function gen_insert_blocklink_singleline(block, editor, settings) { + if (block.id) { + return `^${block.id}`; + } + const sectionEnd = block.position.end; + const end = { + ch: sectionEnd.col, + line: sectionEnd.line + }; + const id = generateRandomId( + settings.enble_prefix ? settings.id_prefix : "", + settings.id_length + ); + const spacer = shouldInsertAfter(block) ? "\n\n" : " "; + editor.replaceRange(`${spacer}^${id}`, end); + return `^${id}`; +} +function gen_insert_blocklink_multline_heading(block, editor, settings, heading_level) { + const id = generateRandomId( + settings.enble_prefix ? settings.id_prefix : "", + settings.id_length + ); + const sectionEnd = block.position.end; + const end = { + ch: sectionEnd.col, + line: sectionEnd.line + }; + const heading = "#".repeat(heading_level); + editor.replaceRange(` + + ${heading} ^${id}`, end); + const cursor = editor.getCursor("from"); + editor.setCursor(cursor.line, cursor.ch); + editor.replaceRange(`${heading} \u02C5${id} + +`, { + line: cursor.line, + ch: 0 + }); + return `\u02C5${id}`; +} +function gen_insert_blocklink_multline_block(fileCache, editor, settings) { + if (fileCache.sections == null) + return ""; + const start_line = editor.getCursor("from").line; + const end_line = editor.getCursor("to").line; + const sortedSections = [...fileCache.sections].sort( + (a, b) => a.position.start.line - b.position.start.line + ); + let links = new Array(); + for (const section of sortedSections) { + if (section.position.start.line > end_line) + break; + if (section.position.start.line >= start_line && section.position.end.line <= end_line) { + const id = gen_insert_blocklink_singleline( + section, + editor, + settings + ); + links.push(id); + } + } + return links; +} +function markdownPostProcessor(el) { + if (el.firstChild instanceof Node) { + let walker = document.createTreeWalker( + el.firstChild, + NodeFilter.SHOW_TEXT, + null + ); + let currentNode = walker.currentNode; + while (currentNode) { + const originalText = currentNode.textContent; + let cleanedText = originalText ? originalText.replace(/\s*˅[a-zA-Z0-9-]*/g, "") : ""; + if (originalText !== cleanedText) { + currentNode.textContent = cleanedText; + } + currentNode = walker.nextNode(); + } + } +} +function createViewPlugin(rule = "(^| )\u02C5[a-zA-Z0-9_]+$") { + let decorator = new import_view.MatchDecorator({ + regexp: new RegExp(rule, "g"), + decoration: import_view.Decoration.mark({ class: "small-font" }) + }); + return import_view.ViewPlugin.define( + (view) => ({ + decorations: decorator.createDeco(view), + update(u) { + this.decorations = decorator.updateDeco(u, this.decorations); + } + }), + { + decorations: (v) => v.decorations + } + ); +} +var BlockLinkPlus = class extends import_obsidian.Plugin { + constructor() { + super(...arguments); + this.appName = this.manifest.name; + this.editorExtensions = []; + } + async onload() { + console.log(`loading ${this.appName}`); + await this.loadSettings(); + this.addSettingTab(new BlockLinkPlusSettingsTab(this.app, this)); + this.registerEvent( + this.app.workspace.on( + "editor-menu", + this.handleEditorMenu.bind(this) + ) + ); + this.addCommand({ + id: "copy-link-to-block2", + name: "Copy link to current block or heading", + editorCheckCallback: (isChecking, editor, view) => { + return this.handleCommand(isChecking, editor, view, false); + } + }); + this.addCommand({ + id: "copy-embed-to-block2", + name: "Copy embed to current block or heading", + editorCheckCallback: (isChecking, editor, view) => { + return this.handleCommand(isChecking, editor, view, true); + } + }); + this.registerMarkdownPostProcessor(markdownPostProcessor); + this.viewPlugin = createViewPlugin(); + this.registerEditorExtension([this.viewPlugin]); + } + // Creates new LinkifyViewPlugins and registers them. + // refreshExtensions() { + // this.viewPlugin = createViewPlugin(); + // this.app.workspace.updateOptions(); + // } + handleEditorMenu(menu, editor, view) { + const file = view.file; + if (!file) + return; + const start_line = editor.getCursor("from").line; + const end_line = editor.getCursor("to").line; + const fileCache = this.app.metadataCache.getFileCache(file); + if (!fileCache) + return; + let head_analysis = analyzeHeadings(fileCache, start_line, end_line); + if (!head_analysis.isValid) { + return; + } + let isHeading = get_is_heading(head_analysis); + const addItemToMenu = (title, isEmbed) => { + menu.addItem((item) => { + item.setTitle(title).setIcon("links-coming-in").onClick( + () => this.handleMenuItemClick( + view, + isHeading, + isEmbed, + head_analysis + ) + ); + }); + }; + addItemToMenu( + isHeading ? "Copy link to heading" : "Copy link to block", + false + ); + addItemToMenu( + isHeading ? "Copy heading embed" : "Copy block embed", + true + ); + } + handleMenuItemClick(view, isHeading, isEmbed, head_analysis) { + if (!view.file || !head_analysis.isValid) + return; + const { file, editor } = view; + const fileCache = this.app.metadataCache.getFileCache(file); + if (!fileCache) + return; + if (!head_analysis.isMultiline) { + this.handleSingleLine( + file, + isHeading, + isEmbed, + head_analysis, + editor + ); + } else { + this.handleMultiLine( + file, + isHeading, + isEmbed, + head_analysis, + editor, + fileCache + ); + } + } + handleSingleLine(file, isHeading, isEmbed, head_analysis, editor) { + if (isHeading && head_analysis.headingAtStart) { + this.copyToClipboard( + file, + head_analysis.headingAtStart.heading, + isEmbed + ); + } else if (!isHeading && head_analysis.block) { + const link = gen_insert_blocklink_singleline( + head_analysis.block, + editor, + this.settings + ); + this.copyToClipboard(file, link, isEmbed); + } + } + handleMultiLine(file, isHeading, isEmbed, head_analysis, editor, fileCache) { + if (isHeading && head_analysis.headingAtStart) { + this.copyToClipboard( + file, + head_analysis.headingAtStart.heading, + isEmbed + ); + } else { + this.handleMultiLineBlock( + file, + isEmbed, + head_analysis, + editor, + fileCache + ); + } + } + _gen_insert_blocklink_multline_heading(fileCache, editor, head_analysis) { + if (!head_analysis.block) + return ""; + return gen_insert_blocklink_multline_heading( + head_analysis.block, + editor, + this.settings, + head_analysis.nearestBeforeStartLevel + 1 + ); + } + _gen_insert_blocklink_multline_block(fileCache, editor, head_analysis) { + return gen_insert_blocklink_multline_block( + fileCache, + editor, + this.settings + ); + } + handleMultiLineBlock(file, isEmbed, head_analysis, editor, fileCache) { + if (this.settings.mult_line_handle == 0 /* oneline */) { + if (head_analysis.block) { + const link = gen_insert_blocklink_singleline( + head_analysis.block, + editor, + this.settings + ); + this.copyToClipboard(file, link, isEmbed); + } + return; + } else { + if (head_analysis.minLevelInRange != Infinity) { + new import_obsidian.Notice( + `Please select text that does not include headings`, + 1500 + ); + return; + } + const linkMethod = this.settings.mult_line_handle == 1 /* heading */ ? this._gen_insert_blocklink_multline_heading : this._gen_insert_blocklink_multline_block; + const link = linkMethod.call( + this, + fileCache, + editor, + head_analysis + ); + this.copyToClipboard(file, link, isEmbed); + return; + } + } + onunload() { + } + async loadSettings() { + this.settings = Object.assign( + {}, + DEFAULT_SETTINGS, + await this.loadData() + ); + } + async saveSettings() { + await this.saveData(this.settings); + } + handleCommand(isChecking, editor, view, isEmbed) { + if (isChecking) { + return true; + } + const file = view.file; + if (!file) + return; + const start_line = editor.getCursor("from").line; + const end_line = editor.getCursor("to").line; + const fileCache = this.app.metadataCache.getFileCache(file); + if (!fileCache) + return; + let head_analysis = analyzeHeadings(fileCache, start_line, end_line); + if (!head_analysis.isValid) { + return; + } + let isHeading = get_is_heading(head_analysis); + if (!head_analysis.isMultiline) { + this.handleSingleLine( + file, + isHeading, + isEmbed, + head_analysis, + editor + ); + } else { + this.handleMultiLine( + file, + isHeading, + isEmbed, + head_analysis, + editor, + fileCache + ); + } + return true; + } + /** + * Copies links to one or more blocks to the clipboard. + * + * @param file - The file containing the blocks. + * @param links - An array of block links (^id) or heading links (heading without `#`). + * @param isEmbed - Specifies whether the links should be embedded. + * @param alias - An optional alias for the links. + */ + copyToClipboard(file, links, isEmbed, alias) { + const linksArray = typeof links === "string" ? [links] : links; + const markdownLinks = linksArray.map((link, index) => { + const addNewLine = index < links.length - 1 ? "\n" : ""; + return `${isEmbed ? "!" : ""}${this.app.fileManager.generateMarkdownLink( + file, + "", + "#" + link, + alias + )}${addNewLine}`; + }).join(""); + navigator.clipboard.writeText(markdownLinks); + } +}; +var BlockLinkPlusSettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + addToggleSetting(settingName, extraOnChange) { + return new import_obsidian.Setting(this.containerEl).addToggle((toggle) => { + toggle.setValue(this.plugin.settings[settingName]).onChange(async (value) => { + this.plugin.settings[settingName] = value; + await this.plugin.saveSettings(); + extraOnChange == null ? void 0 : extraOnChange(value); + }); + }); + } + // 文本输入框 + addTextInputSetting(settingName, placeholder) { + return new import_obsidian.Setting(this.containerEl).addText( + (text) => text.setPlaceholder(placeholder).setValue(this.plugin.settings[settingName]).onChange(async (value) => { + if (value.length > 0) { + this.plugin.settings[settingName] = value; + await this.plugin.saveSettings(); + } + }) + ); + } + addDropdownSetting(settingName, options, display) { + return new import_obsidian.Setting(this.containerEl).addDropdown((dropdown) => { + var _a; + const displayNames = /* @__PURE__ */ new Set(); + for (const option of options) { + const displayName = (_a = display == null ? void 0 : display(option)) != null ? _a : option; + if (!displayNames.has(displayName)) { + dropdown.addOption(option, displayName); + displayNames.add(displayName); + } + } + dropdown.setValue(this.plugin.settings[settingName]).onChange(async (value) => { + this.plugin.settings[settingName] = value; + await this.plugin.saveSettings(); + }); + }); + } + addSliderSetting(settingName, min, max, step) { + return new import_obsidian.Setting(this.containerEl).addSlider((slider) => { + slider.setLimits(min, max, step).setValue(this.plugin.settings[settingName]).setDynamicTooltip().onChange(async (value) => { + this.plugin.settings[settingName] = value; + await this.plugin.saveSettings(); + }); + }); + } + addHeading(heading) { + return new import_obsidian.Setting(this.containerEl).setName(heading).setHeading(); + } + display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h2", { text: "Block-link Settings" }); + this.addDropdownSetting( + //@ts-ignore + "mult_line_handle", + ["0", "1", "2"], + (option) => { + const optionsSet = /* @__PURE__ */ new Map([ + ["0", "Default"], + ["1", "Add new heading"], + ["2", "Add multi block"] + ]); + return optionsSet.get(option) || "Unknown"; + } + ).setName("Multi-line Block Behavior").setDesc( + "Define how multi-line selections generate block IDs. 'Default' treats them as a single line." + ); + this.addHeading("Block ID settings"); + this.addSliderSetting("id_length", 3, 7, 1).setName("Max Block ID Length").setDesc("Set the maximum number of characters for a block ID."); + this.addToggleSetting("enble_prefix").setName("Custom ID Prefix"); + this.addTextInputSetting("id_prefix", "").setName("Block ID Prefix").setDesc("Block ID will be: prefix-random_str"); + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import {\n\tApp,\n\tEditor,\n\tMarkdownView,\n\tModal,\n\tNotice,\n\tPlugin,\n\tPluginSettingTab,\n\tSetting,\n\tTFile,\n\tHeadingCache,\n\tListItemCache,\n\tSectionCache,\n\tEditorPosition,\n\tMarkdownFileInfo,\n\tMenu,\n\tCachedMetadata,\n} from \"obsidian\";\n\nimport {\n\tDecoration,\n\tMatchDecorator,\n\tViewPlugin,\n\tViewUpdate,\n} from \"@codemirror/view\";\nimport { Extension, RangeSet } from \"@codemirror/state\";\nimport { assert } from \"console\";\nimport { inflate } from \"zlib\";\n// import { RangeSet } from \"@codemirror/state\";\n\ntype HeadingAnalysisResult = {\n\tisValid: boolean; // \u662F\u5426\u6709\u6548\n\tstart_line: number; // \u9009\u4E2D\u6587\u672C\u7684\u5F00\u59CB\u884C\n\tend_line: number; // \u9009\u4E2D\u6587\u672C\u7684\u7ED3\u675F\u884C\n\tisMultiline: boolean; // \u662F\u5426\u662F\u591A\u884C\u9009\u4E2D\n\tblock: SectionCache | null; // \u6682\u65F6for single line\n\tnearestBeforeStartLevel: number; // \u8DDD\u79BB start_line \u6700\u8FD1\u7684 heading \u7684 level\n\tminLevelInRange: number; // [start_line, end_line] \u8303\u56F4\u5185\u7684\u6700\u5C0F heading level\n\thasHeadingAtStart: boolean; // \u662F\u5426\u6709 heading \u7684 start.line \u6B63\u597D\u662F start_line\n\thasHeadingAtEnd: boolean; // \u662F\u5426\u6709 heading \u7684 start.line \u6B63\u597D\u662F end_line\n\theadingAtStart: HeadingCache | null; // \u5728 start_line \u5904\u7684 heading | \u4EC5\u5728 hasHeadingAtStart \u4E3A true \u65F6\u6709\u6548\n\theadingAtEnd: HeadingCache | null; // \u5728 end_line \u5904\u7684 heading | \u4EC5\u5728 hasHeadingAtEnd \u4E3A true \u65F6\u6709\u6548\n\tisStartHeadingMinLevel: boolean; //\theadingAtStart \u662F\u5426\u662F\u6700\u5C0F\u5176\u552F\u4E00 level \u7684 heading | \u4EC5\u5728 hasHeadingAtStart \u4E3A true \u65F6\u6709\u6548\n\tisEndLineJustBeforeHeading: boolean; // end_line \u662F\u5426\u6B63\u597D\u662F\u67D0\u4E2A heading \u7684 start.line - 1\n};\n\nexport const enum MultLineHandle {\n\toneline, // as one line handle\n\theading, // add new heading, if select text contain not heading\n\tmultblock, // add new block, if select text contain not block\n}\n\nexport type KeysOfType<Obj, Type> = {\n\t[k in keyof Obj]: Obj[k] extends Type ? k : never;\n}[keyof Obj];\n\ntype BlockLinkPlusViewPlugin = ViewPlugin<{\n\tdecorations: RangeSet<Decoration>;\n\tupdate(u: ViewUpdate): void;\n}>;\n\ninterface PluginSettings {\n\tmult_line_handle: MultLineHandle;\n\tenble_prefix: boolean;\n\tid_prefix: string;\n\tid_length: number;\n}\n\nconst DEFAULT_SETTINGS: PluginSettings = {\n\tmult_line_handle: MultLineHandle.oneline, // as one line handle\n\tenble_prefix: false, // no prefix\n\tid_prefix: \"\", // prefix\n\tid_length: 4, // id length\n};\n\n/**\n * Generates a random ID with the specified prefix and length.\n *\n * @param prefix - The prefix to be added to the ID (optional).\n * @param length - The length of the random ID. Must be between 3 and 7 (inclusive).\n * @returns The generated random ID.\n * @throws Error if the length is not between 3 and 7.\n */\nfunction generateRandomId(prefix: string, length: number): string {\n\tif (length < 3 || length > 7) {\n\t\tthrow new Error(\"Length must be between 3 and 7.\");\n\t}\n\tconst separator = prefix ? \"-\" : \"\";\n\treturn `${prefix}${separator}${Math.random()\n\t\t.toString(36)\n\t\t.substring(2, 2 + length)}`;\n}\n\n/**\n * Determines whether a block should be inserted at next line.\n *\n * @param block - The block to check.\n * @returns `true` if the block should be inserted after, `false` otherwise.\n */\nfunction shouldInsertAfter(block: ListItemCache | SectionCache) {\n\tif ((block as any).type) {\n\t\treturn [\n\t\t\t\"blockquote\",\n\t\t\t\"code\",\n\t\t\t\"table\",\n\t\t\t\"comment\",\n\t\t\t\"footnoteDefinition\",\n\t\t].includes((block as SectionCache).type);\n\t}\n}\n\n/**\n * Analyzes the headings within a specified range of lines in a file.\n *\n * @param fileCache - The cached metadata of the file.\n * @param start_line - The starting line of the range.\n * @param end_line - The ending line of the range.\n * @returns The analysis result of the headings within the specified range.\n */\nfunction analyzeHeadings(\n\tfileCache: CachedMetadata,\n\tstart_line: number,\n\tend_line: number\n): HeadingAnalysisResult {\n\tif (!fileCache || end_line < start_line) {\n\t\treturn {\n\t\t\tisValid: false,\n\t\t\tstart_line,\n\t\t\tend_line,\n\t\t\tisMultiline: false,\n\t\t\tblock: null,\n\t\t\tnearestBeforeStartLevel: 0,\n\t\t\tminLevelInRange: Infinity,\n\t\t\thasHeadingAtStart: false,\n\t\t\thasHeadingAtEnd: false,\n\t\t\theadingAtStart: null,\n\t\t\theadingAtEnd: null,\n\t\t\tisStartHeadingMinLevel: false,\n\t\t\tisEndLineJustBeforeHeading: false,\n\t\t};\n\t}\n\n\t// console.log(\"analyzeHeadings\", fileCache, start_line, end_line); // debug\n\t// one line\n\tif (start_line == end_line) {\n\t\tlet head_block: HeadingCache | undefined = fileCache.headings?.find(\n\t\t\t(heading) => {\n\t\t\t\tconst { start, end } = heading.position;\n\t\t\t\treturn start.line == start_line;\n\t\t\t}\n\t\t);\n\n\t\tlet block = (fileCache.sections || []).find((section) => {\n\t\t\treturn (\n\t\t\t\tsection.position.start.line <= end_line &&\n\t\t\t\tsection.position.end.line >= end_line\n\t\t\t);\n\t\t})!;\n\t\treturn {\n\t\t\tisValid: true,\n\t\t\tstart_line,\n\t\t\tend_line,\n\t\t\tisMultiline: false,\n\t\t\tblock,\n\t\t\tnearestBeforeStartLevel: 0,\n\t\t\tminLevelInRange: head_block ? head_block.level : Infinity,\n\t\t\thasHeadingAtStart: !!block,\n\t\t\thasHeadingAtEnd: false,\n\t\t\theadingAtStart: head_block || null,\n\t\t\theadingAtEnd: null,\n\t\t\tisStartHeadingMinLevel: block ? true : false,\n\t\t\tisEndLineJustBeforeHeading: false,\n\t\t};\n\t}\n\n\tlet nearestBeforeStartLevel = 0;\n\tlet minLevelInRange = Infinity;\n\tlet hasHeadingAtStart = false;\n\tlet hasHeadingAtEnd = false;\n\n\tlet headingAtStart: HeadingCache | null = null;\n\tlet headingAtEnd: HeadingCache | null = null;\n\tlet isStartHeadingMinLevel = false;\n\n\tlet isEndLineJustBeforeHeading = false;\n\n\tlet closestBeforeStartDistance = Infinity; // record the closest heading distance at [0, start_line)\n\n\tlet inner_levels = new Array<number>();\n\n\tfileCache.headings?.forEach((heading) => {\n\t\tconst { start, end } = heading.position;\n\t\t// \u5BF9\u4E8E start.line \u5728 (0, start_line) \u5F00\u533A\u95F4\u7684\u5904\u7406\n\t\tif (start.line < start_line) {\n\t\t\tconst distance = start_line - start.line;\n\t\t\tif (start_line - start.line < closestBeforeStartDistance) {\n\t\t\t\tclosestBeforeStartDistance = distance;\n\t\t\t\tnearestBeforeStartLevel = heading.level;\n\t\t\t}\n\t\t}\n\t\t// \u5BF9\u4E8E start.line \u5728 [start_line, end_line] \u5168\u95ED\u533A\u95F4\u7684\u5904\u7406\n\t\tif (start.line >= start_line && end.line <= end_line) {\n\t\t\tminLevelInRange = Math.min(minLevelInRange, heading.level);\n\t\t\tinner_levels.push(heading.level);\n\t\t}\n\t\t// \u68C0\u67E5\u662F\u5426\u6709 heading \u7684 start.line \u6B63\u597D\u662F start_line \u6216 end_line\n\t\tif (start.line === start_line) {\n\t\t\thasHeadingAtStart = true;\n\t\t\theadingAtStart = heading;\n\t\t}\n\t\tif (start.line === end_line) {\n\t\t\thasHeadingAtEnd = true;\n\t\t\theadingAtEnd = heading;\n\t\t}\n\t\t// \u68C0\u67E5 end_line \u662F\u5426\u6070\u597D\u5728\u4E00\u4E2A heading \u7684\u4E0A\u4E00\u884C\n\t\tif (start.line === end_line + 1 || start.line === end_line + 2) {\n\t\t\tisEndLineJustBeforeHeading = true;\n\t\t}\n\t});\n\n\t// \u68C0\u67E5\u5728 hasHeadingAtStart \u4E3A true \u65F6\uFF0C\u5176 level \u662F\u5426\u662F\u8303\u56F4\u5185\u6700\u5C0F\u7684\uFF0C\u5E76\u4E14\u8FD9\u4E2A\u503C\u7684 heading \u662F\u5426\u552F\u4E00\n\tif (hasHeadingAtStart && headingAtStart != null) {\n\t\t// @ts-ignore | ts \u7C7B\u578B\u8BC6\u522B\u9519\u8BEF\u4E86\n\t\tif (headingAtStart.level === minLevelInRange) {\n\t\t\tconst minLevel = Math.min(...inner_levels);\n\t\t\tconst countOfMinLevel = inner_levels.filter(\n\t\t\t\t(level) => level === minLevel\n\t\t\t).length;\n\t\t\t// headingAtStart.level is the min level in the range\n\t\t\t// and it is the only heading in the range\n\t\t\tif (\n\t\t\t\theadingAtStart &&\n\t\t\t\t// @ts-ignore\n\t\t\t\theadingAtStart.level === minLevel &&\n\t\t\t\tcountOfMinLevel === 1\n\t\t\t) {\n\t\t\t\tisStartHeadingMinLevel = true;\n\t\t\t}\n\t\t}\n\t}\n\tlet block = (fileCache.sections || []).find((section) => {\n\t\treturn (\n\t\t\tsection.position.start.line <= end_line &&\n\t\t\tsection.position.end.line >= end_line\n\t\t);\n\t})!;\n\treturn {\n\t\tisValid: true,\n\t\tstart_line,\n\t\tend_line,\n\t\tisMultiline: true,\n\t\tblock: block,\n\t\tnearestBeforeStartLevel,\n\t\tminLevelInRange,\n\t\thasHeadingAtStart,\n\t\thasHeadingAtEnd,\n\t\theadingAtStart,\n\t\theadingAtEnd,\n\t\tisStartHeadingMinLevel,\n\t\tisEndLineJustBeforeHeading,\n\t};\n}\n\n/**\n * Determines whether the given `head_analysis` is a heading.\n *\n * @param head_analysis - The analysis result of a heading.\n * @returns `true` if the `head_analysis` is a heading, `false` otherwise.\n */\nfunction get_is_heading(head_analysis: HeadingAnalysisResult): boolean {\n\t// invalid input\n\tif (!head_analysis.isValid) {\n\t\treturn false;\n\t}\n\t// console.log(\"head_analysis\", head_analysis); // debug\n\n\tif (!head_analysis.isMultiline) {\n\t\t// single line\n\t\tif (\n\t\t\thead_analysis.hasHeadingAtStart &&\n\t\t\thead_analysis.headingAtStart != null\n\t\t)\n\t\t\treturn true;\n\t} else {\n\t\t// multi line\n\t\tif (\n\t\t\thead_analysis.hasHeadingAtStart && // start_line is a heading\n\t\t\thead_analysis.isStartHeadingMinLevel // start_line's heading level is the min and only level in the range\n\t\t)\n\t\t\treturn true;\n\t}\n\treturn false;\n}\n\n/**\n * Generates and inserts a block link for a single line block.\n * If the block already has an ID, returns the existing ID.\n * Otherwise, generates a random ID and inserts it at the end of the block.\n * @param block - The section cache representing the block.\n * @param editor - The editor instance.\n * @returns The ID of the block link.\n */\nfunction gen_insert_blocklink_singleline(\n\tblock: SectionCache,\n\teditor: Editor,\n\tsettings: PluginSettings\n): string {\n\tif (block.id) {\n\t\treturn `^${block.id}`;\n\t}\n\n\tconst sectionEnd = block.position.end;\n\tconst end: EditorPosition = {\n\t\tch: sectionEnd.col,\n\t\tline: sectionEnd.line,\n\t};\n\n\tconst id = generateRandomId(\n\t\tsettings.enble_prefix ? settings.id_prefix : \"\",\n\t\tsettings.id_length\n\t);\n\tconst spacer = shouldInsertAfter(block) ? \"\\n\\n\" : \" \"; // insert to line or next line\n\n\teditor.replaceRange(`${spacer}^${id}`, end); // insert block id at end of block\n\treturn `^${id}`;\n}\n\n/**\n * Generates and inserts a block link with a multiline heading.\n *\n * @param block - The section cache representing the block.\n * @param editor - The editor instance.\n * @param settings - The plugin settings.\n * @param heading_level - The level of the heading.\n * @returns The generated block ID.\n */\nfunction gen_insert_blocklink_multline_heading(\n\tblock: SectionCache,\n\teditor: Editor,\n\tsettings: PluginSettings,\n\theading_level: number\n) {\n\tconst id = generateRandomId(\n\t\tsettings.enble_prefix ? settings.id_prefix : \"\",\n\t\tsettings.id_length\n\t);\n\n\tconst sectionEnd = block.position.end;\n\tconst end: EditorPosition = {\n\t\tch: sectionEnd.col,\n\t\tline: sectionEnd.line,\n\t};\n\n\t// const spacer = shouldInsertAfter(block) ? \"\\n\\n\" : \" \"; // insert to line or next line\n\tconst heading = \"#\".repeat(heading_level); // generate heading\n\teditor.replaceRange(`\\n\\n ${heading} ^${id}`, end); // insert block id at end of block\n\n\tconst cursor = editor.getCursor(\"from\"); // getCursor\n\t// const lineLength = editor.getLine(cursor.line).length;\n\teditor.setCursor(cursor.line, cursor.ch);\n\teditor.replaceRange(`${heading} \u02C5${id}\\n\\n`, {\n\t\tline: cursor.line,\n\t\tch: 0,\n\t});\n\n\treturn `\u02C5${id}`;\n}\n\n/**\n * Generates block links for multiple lines of a block.\n *\n * @param fileCache - The cached metadata of the file.\n * @param editor - The editor instance.\n * @param settings - The plugin settings.\n * @returns An array of block link IDs or an empty string.\n */\nfunction gen_insert_blocklink_multline_block(\n\tfileCache: CachedMetadata,\n\teditor: Editor,\n\tsettings: PluginSettings\n): string[] | string {\n\tif (fileCache.sections == null) return \"\";\n\n\tconst start_line = editor.getCursor(\"from\").line;\n\tconst end_line = editor.getCursor(\"to\").line;\n\n\tconst sortedSections = [...fileCache.sections].sort(\n\t\t(a, b) => a.position.start.line - b.position.start.line\n\t);\n\tlet links = new Array<string>();\n\n\tfor (const section of sortedSections) {\n\t\tif (section.position.start.line > end_line) break;\n\t\tif (\n\t\t\tsection.position.start.line >= start_line &&\n\t\t\tsection.position.end.line <= end_line\n\t\t) {\n\t\t\tconst id = gen_insert_blocklink_singleline(\n\t\t\t\tsection,\n\t\t\t\teditor,\n\t\t\t\tsettings\n\t\t\t);\n\t\t\tlinks.push(id);\n\t\t}\n\t}\n\n\treturn links;\n}\n\n/**\n * Processes the markdown element by removing specific text patterns.\n * make \u02C5id to \"\"\n * @param el - The HTML element to process.\n */\nfunction markdownPostProcessor(el: HTMLElement) {\n\tif (el.firstChild instanceof Node) {\n\t\tlet walker = document.createTreeWalker(\n\t\t\tel.firstChild,\n\t\t\tNodeFilter.SHOW_TEXT,\n\t\t\tnull\n\t\t);\n\t\tlet currentNode: Node | null = walker.currentNode;\n\n\t\twhile (currentNode) {\n\t\t\tconst originalText = currentNode.textContent; // \u76F4\u63A5\u5904\u7406\u6BCF\u4E2A\u8282\u70B9\n\t\t\tlet cleanedText = originalText\n\t\t\t\t? originalText.replace(/\\s*\u02C5[a-zA-Z0-9-]*/g, \"\")\n\t\t\t\t: \"\";\n\t\t\tif (originalText !== cleanedText) {\n\t\t\t\tcurrentNode.textContent = cleanedText;\n\t\t\t}\n\t\t\tcurrentNode = walker.nextNode(); // \u79FB\u52A8\u5230\u4E0B\u4E00\u4E2A\u8282\u70B9\n\t\t}\n\t}\n}\n\n/**\n * Creates a BlockLinkPlusViewPlugin with the specified rule.\n *\n * @param rule - The regular expression rule used to match the block links.\n * @returns The created BlockLinkPlusViewPlugin.\n */\nfunction createViewPlugin(\n\trule: string = \"(^| )\u02C5[a-zA-Z0-9_]+$\"\n): BlockLinkPlusViewPlugin {\n\tlet decorator = new MatchDecorator({\n\t\tregexp: new RegExp(rule, \"g\"),\n\t\tdecoration: Decoration.mark({ class: \"small-font\" }),\n\t});\n\treturn ViewPlugin.define(\n\t\t(view) => ({\n\t\t\tdecorations: decorator.createDeco(view),\n\t\t\tupdate(u) {\n\t\t\t\tthis.decorations = decorator.updateDeco(u, this.decorations);\n\t\t\t},\n\t\t}),\n\t\t{\n\t\t\tdecorations: (v) => v.decorations,\n\t\t}\n\t);\n}\n\n// all plugin need extends Plugin\nexport default class BlockLinkPlus extends Plugin {\n\tappName = this.manifest.name;\n\tsettings: PluginSettings;\n\tviewPlugin: BlockLinkPlusViewPlugin;\n\teditorExtensions: Extension[] = [];\n\n\tasync onload() {\n\t\tconsole.log(`loading ${this.appName}`);\n\n\t\t// Load settings.\n\t\tawait this.loadSettings();\n\t\t// Create settings tab.\n\t\tthis.addSettingTab(new BlockLinkPlusSettingsTab(this.app, this));\n\n\t\t// Register right click menu\n\t\tthis.registerEvent(\n\t\t\tthis.app.workspace.on(\n\t\t\t\t\"editor-menu\",\n\t\t\t\tthis.handleEditorMenu.bind(this)\n\t\t\t)\n\t\t);\n\n\t\tthis.addCommand({\n\t\t\tid: \"copy-link-to-block2\",\n\t\t\tname: \"Copy link to current block or heading\",\n\t\t\teditorCheckCallback: (isChecking, editor, view) => {\n\t\t\t\treturn this.handleCommand(isChecking, editor, view, false);\n\t\t\t},\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: \"copy-embed-to-block2\",\n\t\t\tname: \"Copy embed to current block or heading\",\n\t\t\teditorCheckCallback: (isChecking, editor, view) => {\n\t\t\t\treturn this.handleCommand(isChecking, editor, view, true);\n\t\t\t},\n\t\t});\n\n\t\t// for reading mode\n\t\tthis.registerMarkdownPostProcessor(markdownPostProcessor);\n\t\t// for live preview\n\t\tthis.viewPlugin = createViewPlugin();\n\t\tthis.registerEditorExtension([this.viewPlugin]);\n\t\t// this.refreshExtensions();\n\t}\n\n\t// Creates new LinkifyViewPlugins and registers them.\n\t// refreshExtensions() {\n\t// \tthis.viewPlugin = createViewPlugin();\n\t// \tthis.app.workspace.updateOptions();\n\t// }\n\n\tprivate handleEditorMenu(\n\t\tmenu: Menu,\n\t\teditor: Editor,\n\t\tview: MarkdownView | MarkdownFileInfo\n\t) {\n\t\tconst file: TFile | null = view.file;\n\t\tif (!file) return; // no file , return\n\n\t\tconst start_line = editor.getCursor(\"from\").line;\n\t\tconst end_line = editor.getCursor(\"to\").line;\n\t\tconst fileCache = this.app.metadataCache.getFileCache(file);\n\t\tif (!fileCache) return; // no fileCache, return\n\n\t\tlet head_analysis = analyzeHeadings(fileCache, start_line, end_line);\n\t\t// console.log(\"head_analysis\", head_analysis); // debug\n\n\t\tif (!head_analysis.isValid) {\n\t\t\treturn; // invalid input\n\t\t}\n\t\tlet isHeading = get_is_heading(head_analysis); // is heading?\n\n\t\t// inner function\n\t\tconst addItemToMenu = (title: string, isEmbed: boolean) => {\n\t\t\tmenu.addItem((item: any) => {\n\t\t\t\titem.setTitle(title)\n\t\t\t\t\t.setIcon(\"links-coming-in\")\n\t\t\t\t\t.onClick(() =>\n\t\t\t\t\t\tthis.handleMenuItemClick(\n\t\t\t\t\t\t\tview,\n\t\t\t\t\t\t\tisHeading,\n\t\t\t\t\t\t\tisEmbed,\n\t\t\t\t\t\t\thead_analysis\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t});\n\t\t};\n\n\t\t// add menu item\n\t\taddItemToMenu(\n\t\t\tisHeading ? \"Copy link to heading\" : \"Copy link to block\",\n\t\t\tfalse\n\t\t);\n\t\taddItemToMenu(\n\t\t\tisHeading ? \"Copy heading embed\" : \"Copy block embed\",\n\t\t\ttrue\n\t\t);\n\t}\n\n\tprivate handleMenuItemClick(\n\t\tview: any,\n\t\tisHeading: boolean,\n\t\tisEmbed: boolean,\n\t\thead_analysis: HeadingAnalysisResult\n\t) {\n\t\tif (!view.file || !head_analysis.isValid) return; // no file or invalid input\n\n\t\tconst { file, editor } = view;\n\t\tconst fileCache = this.app.metadataCache.getFileCache(file);\n\t\tif (!fileCache) return; // no fileCache, return\n\n\t\t// console.log(\"handleMenuItemClick\", fileCache);\n\n\t\tif (!head_analysis.isMultiline) {\n\t\t\t// Single line\n\t\t\tthis.handleSingleLine(\n\t\t\t\tfile,\n\t\t\t\tisHeading,\n\t\t\t\tisEmbed,\n\t\t\t\thead_analysis,\n\t\t\t\teditor\n\t\t\t);\n\t\t} else {\n\t\t\t// Multi line\n\t\t\tthis.handleMultiLine(\n\t\t\t\tfile,\n\t\t\t\tisHeading,\n\t\t\t\tisEmbed,\n\t\t\t\thead_analysis,\n\t\t\t\teditor,\n\t\t\t\tfileCache\n\t\t\t);\n\t\t}\n\t}\n\n\tprivate handleSingleLine(\n\t\tfile: any,\n\t\tisHeading: boolean,\n\t\tisEmbed: boolean,\n\t\thead_analysis: HeadingAnalysisResult,\n\t\teditor: any\n\t) {\n\t\tif (isHeading && head_analysis.headingAtStart) {\n\t\t\t// start_line is a heading\n\t\t\tthis.copyToClipboard(\n\t\t\t\tfile,\n\t\t\t\thead_analysis.headingAtStart.heading,\n\t\t\t\tisEmbed\n\t\t\t);\n\t\t} else if (!isHeading && head_analysis.block) {\n\t\t\t// start_line is not a heading\n\t\t\tconst link = gen_insert_blocklink_singleline(\n\t\t\t\thead_analysis.block,\n\t\t\t\teditor,\n\t\t\t\tthis.settings\n\t\t\t);\n\t\t\tthis.copyToClipboard(file, link, isEmbed);\n\t\t}\n\t}\n\n\tprivate handleMultiLine(\n\t\tfile: any,\n\t\tisHeading: boolean,\n\t\tisEmbed: boolean,\n\t\thead_analysis: HeadingAnalysisResult,\n\t\teditor: any,\n\t\tfileCache: any\n\t) {\n\t\tif (isHeading && head_analysis.headingAtStart) {\n\t\t\t// start_line is a heading\n\t\t\tthis.copyToClipboard(\n\t\t\t\tfile,\n\t\t\t\thead_analysis.headingAtStart.heading,\n\t\t\t\tisEmbed\n\t\t\t);\n\t\t} else {\n\t\t\tthis.handleMultiLineBlock(\n\t\t\t\tfile,\n\t\t\t\tisEmbed,\n\t\t\t\thead_analysis,\n\t\t\t\teditor,\n\t\t\t\tfileCache\n\t\t\t);\n\t\t}\n\t}\n\n\tprivate _gen_insert_blocklink_multline_heading(\n\t\tfileCache: CachedMetadata,\n\t\teditor: any,\n\t\thead_analysis: HeadingAnalysisResult\n\t): string {\n\t\tif (!head_analysis.block) return \"\";\n\n\t\treturn gen_insert_blocklink_multline_heading(\n\t\t\thead_analysis.block,\n\t\t\teditor,\n\t\t\tthis.settings,\n\t\t\thead_analysis.nearestBeforeStartLevel + 1\n\t\t);\n\t}\n\n\tprivate _gen_insert_blocklink_multline_block(\n\t\tfileCache: CachedMetadata,\n\t\teditor: any,\n\t\thead_analysis: HeadingAnalysisResult\n\t) {\n\t\treturn gen_insert_blocklink_multline_block(\n\t\t\tfileCache,\n\t\t\teditor,\n\t\t\tthis.settings\n\t\t);\n\t}\n\n\tprivate handleMultiLineBlock(\n\t\tfile: any,\n\t\tisEmbed: boolean,\n\t\thead_analysis: HeadingAnalysisResult,\n\t\teditor: any,\n\t\tfileCache: any\n\t) {\n\t\tif (this.settings.mult_line_handle == MultLineHandle.oneline) {\n\t\t\tif (head_analysis.block) {\n\t\t\t\tconst link = gen_insert_blocklink_singleline(\n\t\t\t\t\thead_analysis.block,\n\t\t\t\t\teditor,\n\t\t\t\t\tthis.settings\n\t\t\t\t);\n\t\t\t\tthis.copyToClipboard(file, link, isEmbed);\n\t\t\t}\n\t\t\treturn;\n\t\t} else {\n\t\t\tif (head_analysis.minLevelInRange != Infinity) {\n\t\t\t\tnew Notice(\n\t\t\t\t\t`Please select text that does not include headings`,\n\t\t\t\t\t1500\n\t\t\t\t);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst linkMethod =\n\t\t\t\tthis.settings.mult_line_handle == MultLineHandle.heading\n\t\t\t\t\t? this._gen_insert_blocklink_multline_heading\n\t\t\t\t\t: this._gen_insert_blocklink_multline_block;\n\t\t\tconst link = linkMethod.call(\n\t\t\t\tthis,\n\t\t\t\tfileCache,\n\t\t\t\teditor,\n\t\t\t\thead_analysis\n\t\t\t);\n\t\t\tthis.copyToClipboard(file, link, isEmbed);\n\t\t\treturn;\n\t\t}\n\t}\n\n\tonunload() {}\n\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign(\n\t\t\t{},\n\t\t\tDEFAULT_SETTINGS,\n\t\t\tawait this.loadData()\n\t\t);\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n\n\tprivate handleCommand(\n\t\tisChecking: boolean,\n\t\teditor: Editor,\n\t\tview: MarkdownView | MarkdownFileInfo,\n\t\tisEmbed: boolean\n\t) {\n\t\tif (isChecking) {\n\t\t\treturn true;\n\t\t}\n\n\t\tconst file: TFile | null = view.file;\n\t\tif (!file) return; // no file , return\n\n\t\tconst start_line = editor.getCursor(\"from\").line;\n\t\tconst end_line = editor.getCursor(\"to\").line;\n\t\tconst fileCache = this.app.metadataCache.getFileCache(file);\n\t\tif (!fileCache) return; // no fileCache, return\n\n\t\tlet head_analysis = analyzeHeadings(fileCache, start_line, end_line);\n\t\tif (!head_analysis.isValid) {\n\t\t\treturn; // invalid input\n\t\t}\n\n\t\tlet isHeading = get_is_heading(head_analysis); // is heading?\n\n\t\tif (!head_analysis.isMultiline) {\n\t\t\t// Single line\n\t\t\tthis.handleSingleLine(\n\t\t\t\tfile,\n\t\t\t\tisHeading,\n\t\t\t\tisEmbed,\n\t\t\t\thead_analysis,\n\t\t\t\teditor\n\t\t\t);\n\t\t} else {\n\t\t\t// Multi line\n\t\t\tthis.handleMultiLine(\n\t\t\t\tfile,\n\t\t\t\tisHeading,\n\t\t\t\tisEmbed,\n\t\t\t\thead_analysis,\n\t\t\t\teditor,\n\t\t\t\tfileCache\n\t\t\t);\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * Copies links to one or more blocks to the clipboard.\n\t *\n\t * @param file - The file containing the blocks.\n\t * @param links - An array of block links (^id) or heading links (heading without `#`).\n\t * @param isEmbed - Specifies whether the links should be embedded.\n\t * @param alias - An optional alias for the links.\n\t */\n\tcopyToClipboard(\n\t\tfile: TFile,\n\t\tlinks: string | string[],\n\t\tisEmbed: boolean,\n\t\talias?: string\n\t) {\n\t\t// Convert single link to array if necessary\n\t\tconst linksArray = typeof links === \"string\" ? [links] : links;\n\n\t\tconst markdownLinks = linksArray\n\t\t\t.map((link, index) => {\n\t\t\t\tconst addNewLine = index < links.length - 1 ? \"\\n\" : \"\";\n\t\t\t\treturn `${\n\t\t\t\t\tisEmbed ? \"!\" : \"\"\n\t\t\t\t}${this.app.fileManager.generateMarkdownLink(\n\t\t\t\t\tfile,\n\t\t\t\t\t\"\",\n\t\t\t\t\t\"#\" + link,\n\t\t\t\t\talias\n\t\t\t\t)}${addNewLine}`;\n\t\t\t})\n\t\t\t.join(\"\");\n\n\t\tnavigator.clipboard.writeText(markdownLinks);\n\t}\n}\n\nclass BlockLinkPlusSettingsTab extends PluginSettingTab {\n\tplugin: BlockLinkPlus;\n\n\tconstructor(app: App, plugin: BlockLinkPlus) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\taddToggleSetting(\n\t\tsettingName: KeysOfType<PluginSettings, boolean>,\n\t\textraOnChange?: (value: boolean) => void\n\t) {\n\t\treturn new Setting(this.containerEl).addToggle((toggle) => {\n\t\t\ttoggle\n\t\t\t\t.setValue(this.plugin.settings[settingName])\n\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tthis.plugin.settings[settingName] = value;\n\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\textraOnChange?.(value);\n\t\t\t\t});\n\t\t});\n\t}\n\n\t// \u6587\u672C\u8F93\u5165\u6846\n\taddTextInputSetting(\n\t\tsettingName: KeysOfType<PluginSettings, string>,\n\t\tplaceholder: string\n\t) {\n\t\treturn new Setting(this.containerEl).addText((text) =>\n\t\t\ttext\n\t\t\t\t.setPlaceholder(placeholder)\n\t\t\t\t.setValue(this.plugin.settings[settingName])\n\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\tif (value.length > 0) {\n\t\t\t\t\t\t// @ts-ignore\n\t\t\t\t\t\tthis.plugin.settings[settingName] = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t);\n\t}\n\n\taddDropdownSetting(\n\t\tsettingName: KeysOfType<PluginSettings, string>,\n\t\toptions: string[],\n\t\tdisplay?: (option: string) => string\n\t) {\n\t\treturn new Setting(this.containerEl).addDropdown((dropdown) => {\n\t\t\tconst displayNames = new Set<string>();\n\t\t\tfor (const option of options) {\n\t\t\t\tconst displayName = display?.(option) ?? option;\n\t\t\t\tif (!displayNames.has(displayName)) {\n\t\t\t\t\tdropdown.addOption(option, displayName);\n\t\t\t\t\tdisplayNames.add(displayName);\n\t\t\t\t}\n\t\t\t}\n\t\t\tdropdown\n\t\t\t\t.setValue(this.plugin.settings[settingName])\n\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tthis.plugin.settings[settingName] = value;\n\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t});\n\t\t});\n\t}\n\n\taddSliderSetting(\n\t\tsettingName: KeysOfType<PluginSettings, number>,\n\t\tmin: number,\n\t\tmax: number,\n\t\tstep: number\n\t) {\n\t\treturn new Setting(this.containerEl).addSlider((slider) => {\n\t\t\tslider\n\t\t\t\t.setLimits(min, max, step)\n\t\t\t\t.setValue(this.plugin.settings[settingName])\n\t\t\t\t.setDynamicTooltip()\n\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tthis.plugin.settings[settingName] = value;\n\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t});\n\t\t});\n\t}\n\n\taddHeading(heading: string) {\n\t\treturn new Setting(this.containerEl).setName(heading).setHeading();\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\t\t// title\n\t\tcontainerEl.empty();\n\t\tcontainerEl.createEl(\"h2\", { text: \"Block-link Settings\" });\n\n\t\tthis.addDropdownSetting(\n\t\t\t//@ts-ignore\n\t\t\t\"mult_line_handle\",\n\t\t\t[\"0\", \"1\", \"2\"],\n\t\t\t(option) => {\n\t\t\t\tconst optionsSet = new Map([\n\t\t\t\t\t[\"0\", \"Default\"],\n\t\t\t\t\t[\"1\", \"Add new heading\"],\n\t\t\t\t\t[\"2\", \"Add multi block\"],\n\t\t\t\t]);\n\t\t\t\treturn optionsSet.get(option) || \"Unknown\";\n\t\t\t}\n\t\t)\n\t\t\t.setName(\"Multi-line Block Behavior\")\n\t\t\t.setDesc(\n\t\t\t\t\"Define how multi-line selections generate block IDs. 'Default' treats them as a single line.\"\n\t\t\t);\n\n\t\tthis.addHeading(\"Block ID settings\");\n\t\tthis.addSliderSetting(\"id_length\", 3, 7, 1)\n\t\t\t.setName(\"Max Block ID Length\")\n\t\t\t.setDesc(\"Set the maximum number of characters for a block ID.\");\n\n\t\tthis.addToggleSetting(\"enble_prefix\").setName(\"Custom ID Prefix\");\n\n\t\tthis.addTextInputSetting(\"id_prefix\", \"\")\n\t\t\t.setName(\"Block ID Prefix\")\n\t\t\t.setDesc(\"Block ID will be: prefix-random_str\");\n\t}\n}\n"],
  "mappings": "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",
  "names": ["MultLineHandle", "block"]
}
