From 3520551e5e5c2ee0caf9a777c8342859d1d401f0 Mon Sep 17 00:00:00 2001 From: iLiftALot Date: Wed, 13 Nov 2024 01:25:02 -0500 Subject: [PATCH] Working on workflow... --- esbuild.config.mjs | 29 +--- main.js | 420 ++++++++++++++++++++++++++++++++++++++++++++- package.json | 2 +- 3 files changed, 427 insertions(+), 24 deletions(-) mode change 120000 => 100644 main.js diff --git a/esbuild.config.mjs b/esbuild.config.mjs index b913973..6dc3332 100644 --- a/esbuild.config.mjs +++ b/esbuild.config.mjs @@ -8,9 +8,7 @@ import { existsSync, writeFileSync, readFileSync, - symlinkSync, - unlinkSync, - lstatSync + copyFileSync } from "fs"; const banner = @@ -155,25 +153,12 @@ const context = await esbuild.context({ }) try { - if (existsSync(targetPath)) { - try { - const stat = lstatSync(targetPath); - if (stat.isDirectory()) { - // Remove directory - rmSync(targetPath, { recursive: true, force: true }); - logs.push(`Removed existing directory at ${targetPath}`); - } else { - // Remove file or symlink - unlinkSync(targetPath); - logs.push(`Removed existing file/symlink at ${targetPath}`); - } - } catch (unlinkError) { - console.error(`Error removing existing file/symlink: ${unlinkError}\nLogs:\n${logs.join('\n')}`); - process.exit(1); - } - } - symlinkSync(sourcePath, targetPath); - logs.push(`Symlink created: ${targetPath} -> ${sourcePath}`); + //symlinkSync(sourcePath, targetPath); + //logs.push(`Symlink created: ${targetPath} -> ${sourcePath}`); + + // Copy the file instead of creating a symlink + copyFileSync(sourcePath, targetPath); + logs.push(`Copied file: ${sourcePath} -> ${targetPath}`); } catch (error) { console.error(`Error creating symlink: ${error}\nLogs:\n${logs.join('\n')}`); process.exit(1); diff --git a/main.js b/main.js deleted file mode 120000 index e7b54cf..0000000 --- a/main.js +++ /dev/null @@ -1 +0,0 @@ -/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync/.obsidian/plugins/insta-toc/dist/dev/main.js \ No newline at end of file diff --git a/main.js b/main.js new file mode 100644 index 0000000..8aca44d --- /dev/null +++ b/main.js @@ -0,0 +1,419 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/main.ts +var main_exports = {}; +__export(main_exports, { + default: () => InstaTocPlugin +}); +module.exports = __toCommonJS(main_exports); + +// +var define_Process_env_default = { envPath: "/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync/.env", pluginRoot: "/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync/.obsidian/plugins/insta-toc", pluginManifest: { id: "insta-toc", name: "Insta TOC", version: "2.0.2", minAppVersion: "0.15.0", description: "Simultaneously generate, update, and maintain a table of contents for your notes.", author: "Nick C.", autherUrl: "https://github.com/iLiftALot/insta-toc", isDesktopOnly: false }, pluginSettingsPath: "/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync/.obsidian/plugins/insta-toc/data.json", pluginSettings: {}, projectRoot: "/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync/.obsidian/plugins/insta-toc", vaultRoot: "/Users/nicholascorbin/Desktop/Knowledge/MyObsidian/ObsidianBackup/My Sync", vaultName: "My Sync" }; + +// src/main.ts +var import_obsidian2 = require("obsidian"); + +// src/Settings.ts +var DEFAULT_SETTINGS = { + tocString: `> [!SUMMARY] Table of Contents`, + shouldGenToc: false +}; + +// src/SettingsTab.ts +var import_obsidian = require("obsidian"); +var SettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + new import_obsidian.Setting(containerEl).setName("Setting #1").setDesc("It's a secret").addText((text) => text.setPlaceholder("Enter your secret").setValue(this.plugin.settings.tocString).onChange(async (value) => { + this.plugin.settings.tocString = value; + await this.plugin.saveSettings(); + })); + new import_obsidian.Setting(containerEl).setName("TOC Files").setDesc("Insert files to automatically ").addText((text) => text.setPlaceholder("Enter your secret").setValue(this.plugin.settings.tocString).onChange(async (value) => { + this.plugin.settings.tocString = value; + await this.plugin.saveSettings(); + })); + } +}; + +// node_modules/deepmerge-ts/dist/index.mjs +var actions = { + defaultMerge: Symbol("deepmerge-ts: default merge"), + skip: Symbol("deepmerge-ts: skip") +}; +var actionsInto = { + defaultMerge: actions.defaultMerge +}; +function defaultMetaDataUpdater(previousMeta, metaMeta) { + return metaMeta; +} +function defaultFilterValues(values, meta) { + return values.filter((value) => value !== void 0); +} +var ObjectType; +(function(ObjectType2) { + ObjectType2[ObjectType2["NOT"] = 0] = "NOT"; + ObjectType2[ObjectType2["RECORD"] = 1] = "RECORD"; + ObjectType2[ObjectType2["ARRAY"] = 2] = "ARRAY"; + ObjectType2[ObjectType2["SET"] = 3] = "SET"; + ObjectType2[ObjectType2["MAP"] = 4] = "MAP"; + ObjectType2[ObjectType2["OTHER"] = 5] = "OTHER"; +})(ObjectType || (ObjectType = {})); +function getObjectType(object) { + if (typeof object !== "object" || object === null) { + return 0; + } + if (Array.isArray(object)) { + return 2; + } + if (isRecord(object)) { + return 1; + } + if (object instanceof Set) { + return 3; + } + if (object instanceof Map) { + return 4; + } + return 5; +} +function getKeys(objects) { + const keys = /* @__PURE__ */ new Set(); + for (const object of objects) { + for (const key of [...Object.keys(object), ...Object.getOwnPropertySymbols(object)]) { + keys.add(key); + } + } + return keys; +} +function objectHasProperty(object, property) { + return typeof object === "object" && Object.prototype.propertyIsEnumerable.call(object, property); +} +function getIterableOfIterables(iterables) { + let m_iterablesIndex = 0; + let m_iterator = iterables[0]?.[Symbol.iterator](); + return { + [Symbol.iterator]() { + return { + next() { + do { + if (m_iterator === void 0) { + return { done: true, value: void 0 }; + } + const result = m_iterator.next(); + if (result.done === true) { + m_iterablesIndex += 1; + m_iterator = iterables[m_iterablesIndex]?.[Symbol.iterator](); + continue; + } + return { + done: false, + value: result.value + }; + } while (true); + } + }; + } + }; +} +var validRecordToStringValues = ["[object Object]", "[object Module]"]; +function isRecord(value) { + if (!validRecordToStringValues.includes(Object.prototype.toString.call(value))) { + return false; + } + const { constructor } = value; + if (constructor === void 0) { + return true; + } + const prototype = constructor.prototype; + if (prototype === null || typeof prototype !== "object" || !validRecordToStringValues.includes(Object.prototype.toString.call(prototype))) { + return false; + } + if (!prototype.hasOwnProperty("isPrototypeOf")) { + return false; + } + return true; +} +function mergeRecords$1(values, utils, meta) { + const result = {}; + for (const key of getKeys(values)) { + const propValues = []; + for (const value of values) { + if (objectHasProperty(value, key)) { + propValues.push(value[key]); + } + } + if (propValues.length === 0) { + continue; + } + const updatedMeta = utils.metaDataUpdater(meta, { + key, + parents: values + }); + const propertyResult = mergeUnknowns(propValues, utils, updatedMeta); + if (propertyResult === actions.skip) { + continue; + } + if (key === "__proto__") { + Object.defineProperty(result, key, { + value: propertyResult, + configurable: true, + enumerable: true, + writable: true + }); + } else { + result[key] = propertyResult; + } + } + return result; +} +function mergeArrays$1(values) { + return values.flat(); +} +function mergeSets$1(values) { + return new Set(getIterableOfIterables(values)); +} +function mergeMaps$1(values) { + return new Map(getIterableOfIterables(values)); +} +function mergeOthers$1(values) { + return values.at(-1); +} +var mergeFunctions = { + mergeRecords: mergeRecords$1, + mergeArrays: mergeArrays$1, + mergeSets: mergeSets$1, + mergeMaps: mergeMaps$1, + mergeOthers: mergeOthers$1 +}; +function deepmerge(...objects) { + return deepmergeCustom({})(...objects); +} +function deepmergeCustom(options, rootMetaData) { + const utils = getUtils(options, customizedDeepmerge); + function customizedDeepmerge(...objects) { + return mergeUnknowns(objects, utils, rootMetaData); + } + return customizedDeepmerge; +} +function getUtils(options, customizedDeepmerge) { + return { + defaultMergeFunctions: mergeFunctions, + mergeFunctions: { + ...mergeFunctions, + ...Object.fromEntries(Object.entries(options).filter(([key, option]) => Object.hasOwn(mergeFunctions, key)).map(([key, option]) => option === false ? [key, mergeFunctions.mergeOthers] : [key, option])) + }, + metaDataUpdater: options.metaDataUpdater ?? defaultMetaDataUpdater, + deepmerge: customizedDeepmerge, + useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false, + filterValues: options.filterValues === false ? void 0 : options.filterValues ?? defaultFilterValues, + actions + }; +} +function mergeUnknowns(values, utils, meta) { + const filteredValues = utils.filterValues?.(values, meta) ?? values; + if (filteredValues.length === 0) { + return void 0; + } + if (filteredValues.length === 1) { + return mergeOthers(filteredValues, utils, meta); + } + const type = getObjectType(filteredValues[0]); + if (type !== 0 && type !== 5) { + for (let m_index = 1; m_index < filteredValues.length; m_index++) { + if (getObjectType(filteredValues[m_index]) === type) { + continue; + } + return mergeOthers(filteredValues, utils, meta); + } + } + switch (type) { + case 1: { + return mergeRecords(filteredValues, utils, meta); + } + case 2: { + return mergeArrays(filteredValues, utils, meta); + } + case 3: { + return mergeSets(filteredValues, utils, meta); + } + case 4: { + return mergeMaps(filteredValues, utils, meta); + } + default: { + return mergeOthers(filteredValues, utils, meta); + } + } +} +function mergeRecords(values, utils, meta) { + const result = utils.mergeFunctions.mergeRecords(values, utils, meta); + if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeRecords !== utils.defaultMergeFunctions.mergeRecords) { + return utils.defaultMergeFunctions.mergeRecords(values, utils, meta); + } + return result; +} +function mergeArrays(values, utils, meta) { + const result = utils.mergeFunctions.mergeArrays(values, utils, meta); + if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeArrays !== utils.defaultMergeFunctions.mergeArrays) { + return utils.defaultMergeFunctions.mergeArrays(values); + } + return result; +} +function mergeSets(values, utils, meta) { + const result = utils.mergeFunctions.mergeSets(values, utils, meta); + if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeSets !== utils.defaultMergeFunctions.mergeSets) { + return utils.defaultMergeFunctions.mergeSets(values); + } + return result; +} +function mergeMaps(values, utils, meta) { + const result = utils.mergeFunctions.mergeMaps(values, utils, meta); + if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeMaps !== utils.defaultMergeFunctions.mergeMaps) { + return utils.defaultMergeFunctions.mergeMaps(values); + } + return result; +} +function mergeOthers(values, utils, meta) { + const result = utils.mergeFunctions.mergeOthers(values, utils, meta); + if (result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions.mergeOthers !== utils.defaultMergeFunctions.mergeOthers) { + return utils.defaultMergeFunctions.mergeOthers(values); + } + return result; +} + +// typings/Utility.js +function debounce(func, wait) { + let timeout = null; + return function(...args) { + if (timeout !== null) { + clearTimeout(timeout); + } + timeout = window.setTimeout(() => { + func.apply(this, args); + timeout = null; + }, wait); + }; +} + +// src/main.ts +var InstaTocPlugin = class extends import_obsidian2.Plugin { + constructor(app, manifest) { + const mainManifest = manifest ?? define_Process_env_default.pluginManifest; + super(app, mainManifest); + this.app = app; + } + async onload() { + console.log("Loading Insta TOC Plugin"); + await this.loadSettings(); + this.addSettingTab(new SettingTab(this.app, this)); + this.registerMarkdownCodeBlockProcessor( + "insta-toc", + async (source, el, ctx) => { + const pathWithFileExtension = ctx.sourcePath; + const filePath = pathWithFileExtension.substring(0, pathWithFileExtension.lastIndexOf(".")); + const listRegex = /^(\s*)-\s*(.*)/; + const lines = source.split("\n"); + const processedSource = lines.map((line) => { + const match = line.match(listRegex); + if (!match) return line; + const [, indent, contentText] = match; + const navLink = `${filePath}#${contentText}`; + return `${indent}- [[${navLink}|${contentText}]]`; + }).join("\n"); + await import_obsidian2.MarkdownRenderer.render(this.app, processedSource, el, pathWithFileExtension, this); + } + ); + this.registerEvent( + this.app.vault.on( + "modify", + debounce(this.handleEditorChange.bind(this), 2e3) + ) + ); + } + onunload() { + console.log("Unloading Insta TOC Plugin"); + } + async loadSettings() { + let mergedSettings = DEFAULT_SETTINGS; + const settingsData = await this.loadData(); + if (settingsData) { + mergedSettings = deepmerge(DEFAULT_SETTINGS, settingsData); + } + this.settings = mergedSettings; + } + async saveSettings() { + await this.saveData(this.settings); + } + // Provides the insert location range for the new insta-toc codeblock + getTocInsertPosition(instaTocSection) { + const startLine = instaTocSection.position.start.line; + const startCh = 0; + const endLine = instaTocSection.position.end.line; + const endCh = instaTocSection.position.end.col; + const tocStartPos = { line: startLine, ch: startCh }; + const tocEndPos = { line: endLine, ch: endCh }; + return { from: tocStartPos, to: tocEndPos }; + } + // Generates a new insta-toc codeblock + generateToc(fileHeadings) { + const tocHeadingRefs = []; + if (fileHeadings.length > 0) { + fileHeadings.forEach((headingCache) => { + const headingLevel = headingCache.level; + const headingText = headingCache.heading; + const tocHeadingRef = `${" ".repeat((headingLevel - 1) * 4)}- ${headingText}`; + tocHeadingRefs.push(tocHeadingRef); + }); + } + const tocContent = tocHeadingRefs.join("\n"); + return `\`\`\`insta-toc +${tocContent} +\`\`\``; + } + // Dynamically update the TOC + updateAutoToc(editor, file) { + const fileCache = this.app.metadataCache.getFileCache(file); + const fileHeadings = fileCache?.headings ?? []; + const instaTocSection = fileCache?.sections ? fileCache.sections.find( + (section) => section.type === "code" && editor.getLine(section.position.start.line) === "```insta-toc" + ) : void 0; + if (!instaTocSection) return; + const tocInsertRange = this.getTocInsertPosition(instaTocSection); + const newTocBlock = this.generateToc(fileHeadings); + editor.replaceRange(newTocBlock, tocInsertRange.from, tocInsertRange.to); + } + // Main control method to handle all active file changes + async handleEditorChange() { + const activeEditor = this.app.workspace.activeEditor; + const editor = activeEditor?.editor; + const file = activeEditor?.file ?? void 0; + if (!activeEditor || !editor || !file) return; + if (editor) this.updateAutoToc(editor, file); + } +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/main.ts", "<define:Process.env>", "../../src/Settings.ts", "../../src/SettingsTab.ts", "../../node_modules/deepmerge-ts/dist/index.mjs", "../../typings/Utility.js"],
  "sourcesContent": ["import {\n\tApp,\n\tCachedMetadata,\n\tEditor,\n\tEditorPosition,\n\tEditorRange,\n\tHeadingCache,\n\tMarkdownFileInfo,\n\tMarkdownPostProcessorContext,\n\tMarkdownRenderer,\n\tPlugin,\n\tPluginManifest,\n\tSectionCache,\n\tTFile\n} from 'obsidian';\nimport { InstaTocSettings, DEFAULT_SETTINGS } from './Settings';\nimport { SettingTab } from './SettingsTab';\nimport { deepmerge } from 'deepmerge-ts';\nimport { debounce } from 'Utility';\n\n\nexport default class InstaTocPlugin extends Plugin {\n\tpublic app: App;\n\tpublic settings: InstaTocSettings;\n\n\tconstructor(app: App, manifest?: PluginManifest) {\n\t\tconst mainManifest = manifest ?? Process.env.pluginManifest;\n\t\tsuper(app, mainManifest);\n\t\tthis.app = app;\n\t}\n\n\tasync onload() {\n\t\tconsole.log('Loading Insta TOC Plugin');\n\n\t\tawait this.loadSettings();\n\t\tthis.addSettingTab(new SettingTab(this.app, this));\n\n\t\t// Custom codeblock processor for the insta-toc codeblock\n\t\tthis.registerMarkdownCodeBlockProcessor(\n\t\t\t\"insta-toc\",\n\t\t\tasync (source: string, el: HTMLElement, ctx: MarkdownPostProcessorContext): Promise<void> => {\n\t\t\t\tconst pathWithFileExtension: string = ctx.sourcePath; // Includes .md\n\t\t\t\tconst filePath: string = pathWithFileExtension.substring(0, pathWithFileExtension.lastIndexOf(\".\"));\n\n\t\t\t\tconst listRegex = /^(\\s*)-\\s*(.*)/; // Regex to match leading spaces/tabs, bullet, and content\n\t\t\t\tconst lines: string[] = source.split('\\n'); // insta-toc codeblock content\n\n\t\t\t\t// Process the codeblock text by converting each line into a markdown link list item\n\t\t\t\tconst processedSource: string = lines.map((line) => {\n\t\t\t\t\tconst match: RegExpMatchArray | null = line.match(listRegex);\n\t\t\t\t\tif (!match) return line;\n\n\t\t\t\t\tconst [, indent, contentText]: RegExpMatchArray = match;\n\t\t\t\t\tconst navLink = `${filePath}#${contentText}`;\n\n\t\t\t\t\treturn `${indent}- [[${navLink}|${contentText}]]`;\n\t\t\t\t})\n\t\t\t\t\t.join('\\n');\n\n\t\t\t\t// Now render the markdown\n\t\t\t\tawait MarkdownRenderer.render(this.app, processedSource, el, pathWithFileExtension, this);\n\t\t\t}\n\t\t);\n\n\t\t// Detect when the user types and update headers\n\t\tthis.registerEvent(\n\t\t\tthis.app.vault.on(\n\t\t\t\t\"modify\",\n\t\t\t\tdebounce(this.handleEditorChange.bind(this), 2000)\n\t\t\t)\n\t\t);\n\t}\n\n\tonunload() {\n\t\tconsole.log('Unloading Insta TOC Plugin');\n\t}\n\n\tasync loadSettings() {\n\t\tlet mergedSettings = DEFAULT_SETTINGS;\n\t\tconst settingsData = await this.loadData();\n\t\tif (settingsData) {\n\t\t\tmergedSettings = deepmerge(DEFAULT_SETTINGS, settingsData);\n\t\t}\n\t\tthis.settings = mergedSettings;\n\t}\n\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n\n\t// Provides the insert location range for the new insta-toc codeblock\n\tprivate getTocInsertPosition(instaTocSection: SectionCache): EditorRange {\n\t\t// Define the star/end line/character index\n\t\tconst startLine: number = instaTocSection.position.start.line;\n\t\tconst startCh = 0;\n\t\tconst endLine: number = instaTocSection.position.end.line;\n\t\tconst endCh: number = instaTocSection.position.end.col;\n\n\t\tconst tocStartPos: EditorPosition = { line: startLine, ch: startCh };\n\t\tconst tocEndPos: EditorPosition = { line: endLine, ch: endCh };\n\n\t\treturn { from: tocStartPos, to: tocEndPos };\n\t}\n\n\t// Generates a new insta-toc codeblock\n\tprivate generateToc(fileHeadings: HeadingCache[]): string {\n\t\tconst tocHeadingRefs: string[] = [];\n\n\t\t// Iterate each heading cache object to generate the new TOC content\n\t\tif (fileHeadings.length > 0) {\n\t\t\tfileHeadings.forEach((headingCache: HeadingCache) => {\n\t\t\t\tconst headingLevel: number = headingCache.level;\n\t\t\t\tconst headingText: string = headingCache.heading;\n\t\t\t\tconst tocHeadingRef = `${' '.repeat((headingLevel - 1) * 4)}- ${headingText}`;\n\n\t\t\t\ttocHeadingRefs.push(tocHeadingRef);\n\t\t\t});\n\t\t}\n\n\t\tconst tocContent: string = tocHeadingRefs.join('\\n');\n\t\treturn `\\`\\`\\`insta-toc\\n${tocContent}\\n\\`\\`\\``;\n\t}\n\n\t// Dynamically update the TOC\n\tprivate updateAutoToc(editor: Editor, file: TFile): void {\n\t\t// Extract the headings and sections from the active file's cache\n\t\tconst fileCache: CachedMetadata | null = this.app.metadataCache.getFileCache(file);\n\t\tconst fileHeadings: HeadingCache[] = fileCache?.headings ?? [];\n\t\tconst instaTocSection: SectionCache | undefined = fileCache?.sections\n\t\t\t? fileCache.sections.find(\n\t\t\t\t(section: SectionCache) => section.type === 'code' &&\n\t\t\t\t\teditor.getLine(section.position.start.line) === '```insta-toc'\n\t\t\t) : undefined;\n\n\t\t// Return early if no sections (which means no insta-toc blocks)\n\t\tif (!instaTocSection) return;\n\n\t\t// Get the insertion position and generate the updated TOC\n\t\tconst tocInsertRange: EditorRange = this.getTocInsertPosition(instaTocSection);\n\t\tconst newTocBlock = this.generateToc(fileHeadings);\n\n\t\t// Replace the old TOC with the updated TOC\n\t\teditor.replaceRange(newTocBlock, tocInsertRange.from, tocInsertRange.to);\n\t}\n\n\t// Main control method to handle all active file changes\n\tprivate async handleEditorChange(): Promise<void> {\n\t\tconst activeEditor: MarkdownFileInfo | null = this.app.workspace.activeEditor;\n\t\tconst editor: Editor | undefined = activeEditor?.editor;\n\t\tconst file: TFile | undefined = activeEditor?.file ?? undefined;\n\n\t\tif (!activeEditor || !editor || !file) return;\n\n\t\t// Dynamically update the insta-toc codeblock\n\t\tif (editor) this.updateAutoToc(editor, file);\n\t}\n}\n", "", "export interface InstaTocSettings {\n    tocString: string;\n    shouldGenToc: boolean;\n}\n\nexport const DEFAULT_SETTINGS: InstaTocSettings = {\n    tocString: `> [!SUMMARY] Table of Contents`,\n    shouldGenToc: false\n}\n\n\n", "import { App, PluginSettingTab, Setting } from 'obsidian';\nimport InstaToc from './main';\n\nexport class SettingTab extends PluginSettingTab {\n    plugin: InstaToc;\n\n    constructor(app: App, plugin: InstaToc) {\n        super(app, plugin);\n        this.plugin = plugin;\n    }\n\n    display(): void {\n        const { containerEl } = this;\n\n        containerEl.empty();\n\n        new Setting(containerEl)\n            .setName('Setting #1')\n            .setDesc('It\\'s a secret')\n            .addText(text => text\n                .setPlaceholder('Enter your secret')\n                .setValue(this.plugin.settings.tocString)\n                .onChange(async (value) => {\n                    this.plugin.settings.tocString = value;\n                    await this.plugin.saveSettings();\n                }));\n        new Setting(containerEl)\n            .setName('TOC Files')\n            .setDesc('Insert files to automatically ')\n            .addText(text => text\n                .setPlaceholder('Enter your secret')\n                .setValue(this.plugin.settings.tocString)\n                .onChange(async (value) => {\n                    this.plugin.settings.tocString = value;\n                    await this.plugin.saveSettings();\n                }));\n    }\n}", "/**\n * Special values that tell deepmerge to perform a certain action.\n */\nconst actions = {\n    defaultMerge: Symbol(\"deepmerge-ts: default merge\"),\n    skip: Symbol(\"deepmerge-ts: skip\"),\n};\n/**\n * Special values that tell deepmergeInto to perform a certain action.\n */\nconst actionsInto = {\n    defaultMerge: actions.defaultMerge,\n};\n\n/**\n * The default function to update meta data.\n *\n * It doesn't update the meta data.\n */\nfunction defaultMetaDataUpdater(previousMeta, metaMeta) {\n    return metaMeta;\n}\n/**\n * The default function to filter values.\n *\n * It filters out undefined values.\n */\nfunction defaultFilterValues(values, meta) {\n    return values.filter((value) => value !== undefined);\n}\n\n/**\n * The different types of objects deepmerge-ts support.\n */\nvar ObjectType;\n(function (ObjectType) {\n    ObjectType[ObjectType[\"NOT\"] = 0] = \"NOT\";\n    ObjectType[ObjectType[\"RECORD\"] = 1] = \"RECORD\";\n    ObjectType[ObjectType[\"ARRAY\"] = 2] = \"ARRAY\";\n    ObjectType[ObjectType[\"SET\"] = 3] = \"SET\";\n    ObjectType[ObjectType[\"MAP\"] = 4] = \"MAP\";\n    ObjectType[ObjectType[\"OTHER\"] = 5] = \"OTHER\";\n})(ObjectType || (ObjectType = {}));\n/**\n * Get the type of the given object.\n *\n * @param object - The object to get the type of.\n * @returns The type of the given object.\n */\nfunction getObjectType(object) {\n    if (typeof object !== \"object\" || object === null) {\n        return 0 /* ObjectType.NOT */;\n    }\n    if (Array.isArray(object)) {\n        return 2 /* ObjectType.ARRAY */;\n    }\n    if (isRecord(object)) {\n        return 1 /* ObjectType.RECORD */;\n    }\n    if (object instanceof Set) {\n        return 3 /* ObjectType.SET */;\n    }\n    if (object instanceof Map) {\n        return 4 /* ObjectType.MAP */;\n    }\n    return 5 /* ObjectType.OTHER */;\n}\n/**\n * Get the keys of the given objects including symbol keys.\n *\n * Note: Only keys to enumerable properties are returned.\n *\n * @param objects - An array of objects to get the keys of.\n * @returns A set containing all the keys of all the given objects.\n */\nfunction getKeys(objects) {\n    const keys = new Set();\n    for (const object of objects) {\n        for (const key of [...Object.keys(object), ...Object.getOwnPropertySymbols(object)]) {\n            keys.add(key);\n        }\n    }\n    return keys;\n}\n/**\n * Does the given object have the given property.\n *\n * @param object - The object to test.\n * @param property - The property to test.\n * @returns Whether the object has the property.\n */\nfunction objectHasProperty(object, property) {\n    return typeof object === \"object\" && Object.prototype.propertyIsEnumerable.call(object, property);\n}\n/**\n * Get an iterable object that iterates over the given iterables.\n */\nfunction getIterableOfIterables(iterables) {\n    let m_iterablesIndex = 0;\n    let m_iterator = iterables[0]?.[Symbol.iterator]();\n    return {\n        [Symbol.iterator]() {\n            return {\n                next() {\n                    do {\n                        if (m_iterator === undefined) {\n                            return { done: true, value: undefined };\n                        }\n                        const result = m_iterator.next();\n                        if (result.done === true) {\n                            m_iterablesIndex += 1;\n                            m_iterator = iterables[m_iterablesIndex]?.[Symbol.iterator]();\n                            continue;\n                        }\n                        return {\n                            done: false,\n                            value: result.value,\n                        };\n                    } while (true);\n                },\n            };\n        },\n    };\n}\n// eslint-disable-next-line unicorn/prefer-set-has -- Array is more performant for a low number of elements.\nconst validRecordToStringValues = [\"[object Object]\", \"[object Module]\"];\n/**\n * Does the given object appear to be a record.\n */\nfunction isRecord(value) {\n    // All records are objects.\n    if (!validRecordToStringValues.includes(Object.prototype.toString.call(value))) {\n        return false;\n    }\n    const { constructor } = value;\n    // If has modified constructor.\n    // eslint-disable-next-line ts/no-unnecessary-condition\n    if (constructor === undefined) {\n        return true;\n    }\n    const prototype = constructor.prototype;\n    // If has modified prototype.\n    if (prototype === null ||\n        typeof prototype !== \"object\" ||\n        !validRecordToStringValues.includes(Object.prototype.toString.call(prototype))) {\n        return false;\n    }\n    // If constructor does not have an Object-specific method.\n    // eslint-disable-next-line sonar/prefer-single-boolean-return, no-prototype-builtins\n    if (!prototype.hasOwnProperty(\"isPrototypeOf\")) {\n        return false;\n    }\n    // Most likely a record.\n    return true;\n}\n\n/**\n * The default strategy to merge records.\n *\n * @param values - The records.\n */\nfunction mergeRecords$1(values, utils, meta) {\n    const result = {};\n    for (const key of getKeys(values)) {\n        const propValues = [];\n        for (const value of values) {\n            if (objectHasProperty(value, key)) {\n                propValues.push(value[key]);\n            }\n        }\n        if (propValues.length === 0) {\n            continue;\n        }\n        const updatedMeta = utils.metaDataUpdater(meta, {\n            key,\n            parents: values,\n        });\n        const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);\n        if (propertyResult === actions.skip) {\n            continue;\n        }\n        if (key === \"__proto__\") {\n            Object.defineProperty(result, key, {\n                value: propertyResult,\n                configurable: true,\n                enumerable: true,\n                writable: true,\n            });\n        }\n        else {\n            result[key] = propertyResult;\n        }\n    }\n    return result;\n}\n/**\n * The default strategy to merge arrays.\n *\n * @param values - The arrays.\n */\nfunction mergeArrays$1(values) {\n    return values.flat();\n}\n/**\n * The default strategy to merge sets.\n *\n * @param values - The sets.\n */\nfunction mergeSets$1(values) {\n    return new Set(getIterableOfIterables(values));\n}\n/**\n * The default strategy to merge maps.\n *\n * @param values - The maps.\n */\nfunction mergeMaps$1(values) {\n    return new Map(getIterableOfIterables(values));\n}\n/**\n * Get the last non-undefined value in the given array.\n */\nfunction mergeOthers$1(values) {\n    return values.at(-1);\n}\n/**\n * The merge functions.\n */\nconst mergeFunctions = {\n    mergeRecords: mergeRecords$1,\n    mergeArrays: mergeArrays$1,\n    mergeSets: mergeSets$1,\n    mergeMaps: mergeMaps$1,\n    mergeOthers: mergeOthers$1,\n};\n\n/**\n * Deeply merge objects.\n *\n * @param objects - The objects to merge.\n */\nfunction deepmerge(...objects) {\n    return deepmergeCustom({})(...objects);\n}\nfunction deepmergeCustom(options, rootMetaData) {\n    const utils = getUtils(options, customizedDeepmerge);\n    /**\n     * The customized deepmerge function.\n     */\n    function customizedDeepmerge(...objects) {\n        return mergeUnknowns(objects, utils, rootMetaData);\n    }\n    return customizedDeepmerge;\n}\n/**\n * The the utils that are available to the merge functions.\n *\n * @param options - The options the user specified\n */\nfunction getUtils(options, customizedDeepmerge) {\n    return {\n        defaultMergeFunctions: mergeFunctions,\n        mergeFunctions: {\n            ...mergeFunctions,\n            ...Object.fromEntries(Object.entries(options)\n                .filter(([key, option]) => Object.hasOwn(mergeFunctions, key))\n                .map(([key, option]) => (option === false ? [key, mergeFunctions.mergeOthers] : [key, option]))),\n        },\n        metaDataUpdater: (options.metaDataUpdater ?? defaultMetaDataUpdater),\n        deepmerge: customizedDeepmerge,\n        useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,\n        filterValues: options.filterValues === false ? undefined : (options.filterValues ?? defaultFilterValues),\n        actions,\n    };\n}\n/**\n * Merge unknown things.\n *\n * @param values - The values.\n */\nfunction mergeUnknowns(values, utils, meta) {\n    const filteredValues = utils.filterValues?.(values, meta) ?? values;\n    if (filteredValues.length === 0) {\n        return undefined;\n    }\n    if (filteredValues.length === 1) {\n        return mergeOthers(filteredValues, utils, meta);\n    }\n    const type = getObjectType(filteredValues[0]);\n    if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {\n        for (let m_index = 1; m_index < filteredValues.length; m_index++) {\n            if (getObjectType(filteredValues[m_index]) === type) {\n                continue;\n            }\n            return mergeOthers(filteredValues, utils, meta);\n        }\n    }\n    switch (type) {\n        case 1 /* ObjectType.RECORD */: {\n            return mergeRecords(filteredValues, utils, meta);\n        }\n        case 2 /* ObjectType.ARRAY */: {\n            return mergeArrays(filteredValues, utils, meta);\n        }\n        case 3 /* ObjectType.SET */: {\n            return mergeSets(filteredValues, utils, meta);\n        }\n        case 4 /* ObjectType.MAP */: {\n            return mergeMaps(filteredValues, utils, meta);\n        }\n        default: {\n            return mergeOthers(filteredValues, utils, meta);\n        }\n    }\n}\n/**\n * Merge records.\n *\n * @param values - The records.\n */\nfunction mergeRecords(values, utils, meta) {\n    const result = utils.mergeFunctions.mergeRecords(values, utils, meta);\n    if (result === actions.defaultMerge ||\n        (utils.useImplicitDefaultMerging &&\n            result === undefined &&\n            utils.mergeFunctions.mergeRecords !== utils.defaultMergeFunctions.mergeRecords)) {\n        return utils.defaultMergeFunctions.mergeRecords(values, utils, meta);\n    }\n    return result;\n}\n/**\n * Merge arrays.\n *\n * @param values - The arrays.\n */\nfunction mergeArrays(values, utils, meta) {\n    const result = utils.mergeFunctions.mergeArrays(values, utils, meta);\n    if (result === actions.defaultMerge ||\n        (utils.useImplicitDefaultMerging &&\n            result === undefined &&\n            utils.mergeFunctions.mergeArrays !== utils.defaultMergeFunctions.mergeArrays)) {\n        return utils.defaultMergeFunctions.mergeArrays(values);\n    }\n    return result;\n}\n/**\n * Merge sets.\n *\n * @param values - The sets.\n */\nfunction mergeSets(values, utils, meta) {\n    const result = utils.mergeFunctions.mergeSets(values, utils, meta);\n    if (result === actions.defaultMerge ||\n        (utils.useImplicitDefaultMerging &&\n            result === undefined &&\n            utils.mergeFunctions.mergeSets !== utils.defaultMergeFunctions.mergeSets)) {\n        return utils.defaultMergeFunctions.mergeSets(values);\n    }\n    return result;\n}\n/**\n * Merge maps.\n *\n * @param values - The maps.\n */\nfunction mergeMaps(values, utils, meta) {\n    const result = utils.mergeFunctions.mergeMaps(values, utils, meta);\n    if (result === actions.defaultMerge ||\n        (utils.useImplicitDefaultMerging &&\n            result === undefined &&\n            utils.mergeFunctions.mergeMaps !== utils.defaultMergeFunctions.mergeMaps)) {\n        return utils.defaultMergeFunctions.mergeMaps(values);\n    }\n    return result;\n}\n/**\n * Merge other things.\n *\n * @param values - The other things.\n */\nfunction mergeOthers(values, utils, meta) {\n    const result = utils.mergeFunctions.mergeOthers(values, utils, meta);\n    if (result === actions.defaultMerge ||\n        (utils.useImplicitDefaultMerging &&\n            result === undefined &&\n            utils.mergeFunctions.mergeOthers !== utils.defaultMergeFunctions.mergeOthers)) {\n        return utils.defaultMergeFunctions.mergeOthers(values);\n    }\n    return result;\n}\n\n/**\n * The default strategy to merge records into a target record.\n *\n * @param m_target - The result will be mutated into this record\n * @param values - The records (including the target's value if there is one).\n */\nfunction mergeRecordsInto$1(m_target, values, utils, meta) {\n    for (const key of getKeys(values)) {\n        const propValues = [];\n        for (const value of values) {\n            if (objectHasProperty(value, key)) {\n                propValues.push(value[key]);\n            }\n        }\n        if (propValues.length === 0) {\n            continue;\n        }\n        const updatedMeta = utils.metaDataUpdater(meta, {\n            key,\n            parents: values,\n        });\n        const propertyTarget = { value: propValues[0] };\n        mergeUnknownsInto(propertyTarget, propValues, utils, updatedMeta);\n        if (key === \"__proto__\") {\n            Object.defineProperty(m_target.value, key, {\n                value: propertyTarget.value,\n                configurable: true,\n                enumerable: true,\n                writable: true,\n            });\n        }\n        else {\n            m_target.value[key] = propertyTarget.value;\n        }\n    }\n}\n/**\n * The default strategy to merge arrays into a target array.\n *\n * @param m_target - The result will be mutated into this array\n * @param values - The arrays (including the target's value if there is one).\n */\nfunction mergeArraysInto$1(m_target, values) {\n    m_target.value.push(...values.slice(1).flat());\n}\n/**\n * The default strategy to merge sets into a target set.\n *\n * @param m_target - The result will be mutated into this set\n * @param values - The sets (including the target's value if there is one).\n */\nfunction mergeSetsInto$1(m_target, values) {\n    for (const value of getIterableOfIterables(values.slice(1))) {\n        m_target.value.add(value);\n    }\n}\n/**\n * The default strategy to merge maps into a target map.\n *\n * @param m_target - The result will be mutated into this map\n * @param values - The maps (including the target's value if there is one).\n */\nfunction mergeMapsInto$1(m_target, values) {\n    for (const [key, value] of getIterableOfIterables(values.slice(1))) {\n        m_target.value.set(key, value);\n    }\n}\n/**\n * Set the target to the last non-undefined value.\n */\nfunction mergeOthersInto$1(m_target, values) {\n    m_target.value = values.at(-1);\n}\n/**\n * The merge functions.\n */\nconst mergeIntoFunctions = {\n    mergeRecords: mergeRecordsInto$1,\n    mergeArrays: mergeArraysInto$1,\n    mergeSets: mergeSetsInto$1,\n    mergeMaps: mergeMapsInto$1,\n    mergeOthers: mergeOthersInto$1,\n};\n\nfunction deepmergeInto(target, ...objects) {\n    return void deepmergeIntoCustom({})(target, ...objects);\n}\nfunction deepmergeIntoCustom(options, rootMetaData) {\n    const utils = getIntoUtils(options, customizedDeepmergeInto);\n    /**\n     * The customized deepmerge function.\n     */\n    function customizedDeepmergeInto(target, ...objects) {\n        mergeUnknownsInto({ value: target }, [target, ...objects], utils, rootMetaData);\n    }\n    return customizedDeepmergeInto;\n}\n/**\n * The the utils that are available to the merge functions.\n *\n * @param options - The options the user specified\n */\nfunction getIntoUtils(options, customizedDeepmergeInto) {\n    return {\n        defaultMergeFunctions: mergeIntoFunctions,\n        mergeFunctions: {\n            ...mergeIntoFunctions,\n            ...Object.fromEntries(Object.entries(options)\n                .filter(([key, option]) => Object.hasOwn(mergeIntoFunctions, key))\n                .map(([key, option]) => (option === false ? [key, mergeIntoFunctions.mergeOthers] : [key, option]))),\n        },\n        metaDataUpdater: (options.metaDataUpdater ?? defaultMetaDataUpdater),\n        deepmergeInto: customizedDeepmergeInto,\n        filterValues: options.filterValues === false ? undefined : (options.filterValues ?? defaultFilterValues),\n        actions: actionsInto,\n    };\n}\n/**\n * Merge unknown things into a target.\n *\n * @param m_target - The target to merge into.\n * @param values - The values.\n */\nfunction mergeUnknownsInto(m_target, values, utils, meta) {\n    const filteredValues = utils.filterValues?.(values, meta) ?? values;\n    if (filteredValues.length === 0) {\n        return;\n    }\n    if (filteredValues.length === 1) {\n        return void mergeOthersInto(m_target, filteredValues, utils, meta);\n    }\n    const type = getObjectType(m_target.value);\n    if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {\n        for (let m_index = 1; m_index < filteredValues.length; m_index++) {\n            if (getObjectType(filteredValues[m_index]) === type) {\n                continue;\n            }\n            return void mergeOthersInto(m_target, filteredValues, utils, meta);\n        }\n    }\n    switch (type) {\n        case 1 /* ObjectType.RECORD */: {\n            return void mergeRecordsInto(m_target, filteredValues, utils, meta);\n        }\n        case 2 /* ObjectType.ARRAY */: {\n            return void mergeArraysInto(m_target, filteredValues, utils, meta);\n        }\n        case 3 /* ObjectType.SET */: {\n            return void mergeSetsInto(m_target, filteredValues, utils, meta);\n        }\n        case 4 /* ObjectType.MAP */: {\n            return void mergeMapsInto(m_target, filteredValues, utils, meta);\n        }\n        default: {\n            return void mergeOthersInto(m_target, filteredValues, utils, meta);\n        }\n    }\n}\n/**\n * Merge records into a target record.\n *\n * @param m_target - The target to merge into.\n * @param values - The records.\n */\nfunction mergeRecordsInto(m_target, values, utils, meta) {\n    const action = utils.mergeFunctions.mergeRecords(m_target, values, utils, meta);\n    if (action === actionsInto.defaultMerge) {\n        utils.defaultMergeFunctions.mergeRecords(m_target, values, utils, meta);\n    }\n}\n/**\n * Merge arrays into a target array.\n *\n * @param m_target - The target to merge into.\n * @param values - The arrays.\n */\nfunction mergeArraysInto(m_target, values, utils, meta) {\n    const action = utils.mergeFunctions.mergeArrays(m_target, values, utils, meta);\n    if (action === actionsInto.defaultMerge) {\n        utils.defaultMergeFunctions.mergeArrays(m_target, values);\n    }\n}\n/**\n * Merge sets into a target set.\n *\n * @param m_target - The target to merge into.\n * @param values - The sets.\n */\nfunction mergeSetsInto(m_target, values, utils, meta) {\n    const action = utils.mergeFunctions.mergeSets(m_target, values, utils, meta);\n    if (action === actionsInto.defaultMerge) {\n        utils.defaultMergeFunctions.mergeSets(m_target, values);\n    }\n}\n/**\n * Merge maps into a target map.\n *\n * @param m_target - The target to merge into.\n * @param values - The maps.\n */\nfunction mergeMapsInto(m_target, values, utils, meta) {\n    const action = utils.mergeFunctions.mergeMaps(m_target, values, utils, meta);\n    if (action === actionsInto.defaultMerge) {\n        utils.defaultMergeFunctions.mergeMaps(m_target, values);\n    }\n}\n/**\n * Merge other things into a target.\n *\n * @param m_target - The target to merge into.\n * @param values - The other things.\n */\nfunction mergeOthersInto(m_target, values, utils, meta) {\n    const action = utils.mergeFunctions.mergeOthers(m_target, values, utils, meta);\n    if (action === actionsInto.defaultMerge || m_target.value === actionsInto.defaultMerge) {\n        utils.defaultMergeFunctions.mergeOthers(m_target, values);\n    }\n}\n\nexport { deepmerge, deepmergeCustom, deepmergeInto, deepmergeIntoCustom, getKeys, getObjectType, objectHasProperty };\n", "export function debounce(\n    func,\n    wait\n) {\n    let timeout = null;\n    return function (...args) {\n        if (timeout !== null) {\n            clearTimeout(timeout);\n        }\n        timeout = window.setTimeout(() => {\n            func.apply(this, args);\n            timeout = null;\n        }, wait);\n    };\n}"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mCAAC,SAAU,kFAAiF,YAAa,yGAAwG,gBAAiB,EAAC,IAAK,aAAY,MAAO,aAAY,SAAU,SAAQ,eAAgB,UAAS,aAAc,qFAAoF,QAAS,WAAU,WAAY,0CAAyC,eAAgB,MAAK,GAAE,oBAAqB,mHAAkH,gBAAiB,CAAC,GAAE,aAAc,yGAAwG,WAAY,6EAA4E,WAAY,UAAS;;;ADAj3B,IAAAA,mBAcO;;;AETA,IAAM,mBAAqC;AAAA,EAC9C,WAAW;AAAA,EACX,cAAc;AAClB;;;ACRA,sBAA+C;AAGxC,IAAM,aAAN,cAAyB,iCAAiB;AAAA,EAG7C,YAAY,KAAU,QAAkB;AACpC,UAAM,KAAK,MAAM;AACjB,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,UAAgB;AACZ,UAAM,EAAE,YAAY,IAAI;AAExB,gBAAY,MAAM;AAElB,QAAI,wBAAQ,WAAW,EAClB,QAAQ,YAAY,EACpB,QAAQ,eAAgB,EACxB,QAAQ,UAAQ,KACZ,eAAe,mBAAmB,EAClC,SAAS,KAAK,OAAO,SAAS,SAAS,EACvC,SAAS,OAAO,UAAU;AACvB,WAAK,OAAO,SAAS,YAAY;AACjC,YAAM,KAAK,OAAO,aAAa;AAAA,IACnC,CAAC,CAAC;AACV,QAAI,wBAAQ,WAAW,EAClB,QAAQ,WAAW,EACnB,QAAQ,gCAAgC,EACxC,QAAQ,UAAQ,KACZ,eAAe,mBAAmB,EAClC,SAAS,KAAK,OAAO,SAAS,SAAS,EACvC,SAAS,OAAO,UAAU;AACvB,WAAK,OAAO,SAAS,YAAY;AACjC,YAAM,KAAK,OAAO,aAAa;AAAA,IACnC,CAAC,CAAC;AAAA,EACd;AACJ;;;AClCA,IAAM,UAAU;AAAA,EACZ,cAAc,OAAO,6BAA6B;AAAA,EAClD,MAAM,OAAO,oBAAoB;AACrC;AAIA,IAAM,cAAc;AAAA,EAChB,cAAc,QAAQ;AAC1B;AAOA,SAAS,uBAAuB,cAAc,UAAU;AACpD,SAAO;AACX;AAMA,SAAS,oBAAoB,QAAQ,MAAM;AACvC,SAAO,OAAO,OAAO,CAAC,UAAU,UAAU,MAAS;AACvD;AAKA,IAAI;AAAA,CACH,SAAUC,aAAY;AACnB,EAAAA,YAAWA,YAAW,KAAK,IAAI,CAAC,IAAI;AACpC,EAAAA,YAAWA,YAAW,QAAQ,IAAI,CAAC,IAAI;AACvC,EAAAA,YAAWA,YAAW,OAAO,IAAI,CAAC,IAAI;AACtC,EAAAA,YAAWA,YAAW,KAAK,IAAI,CAAC,IAAI;AACpC,EAAAA,YAAWA,YAAW,KAAK,IAAI,CAAC,IAAI;AACpC,EAAAA,YAAWA,YAAW,OAAO,IAAI,CAAC,IAAI;AAC1C,GAAG,eAAe,aAAa,CAAC,EAAE;AAOlC,SAAS,cAAc,QAAQ;AAC3B,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AAC/C,WAAO;AAAA,EACX;AACA,MAAI,MAAM,QAAQ,MAAM,GAAG;AACvB,WAAO;AAAA,EACX;AACA,MAAI,SAAS,MAAM,GAAG;AAClB,WAAO;AAAA,EACX;AACA,MAAI,kBAAkB,KAAK;AACvB,WAAO;AAAA,EACX;AACA,MAAI,kBAAkB,KAAK;AACvB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AASA,SAAS,QAAQ,SAAS;AACtB,QAAM,OAAO,oBAAI,IAAI;AACrB,aAAW,UAAU,SAAS;AAC1B,eAAW,OAAO,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,sBAAsB,MAAM,CAAC,GAAG;AACjF,WAAK,IAAI,GAAG;AAAA,IAChB;AAAA,EACJ;AACA,SAAO;AACX;AAQA,SAAS,kBAAkB,QAAQ,UAAU;AACzC,SAAO,OAAO,WAAW,YAAY,OAAO,UAAU,qBAAqB,KAAK,QAAQ,QAAQ;AACpG;AAIA,SAAS,uBAAuB,WAAW;AACvC,MAAI,mBAAmB;AACvB,MAAI,aAAa,UAAU,CAAC,IAAI,OAAO,QAAQ,EAAE;AACjD,SAAO;AAAA,IACH,CAAC,OAAO,QAAQ,IAAI;AAChB,aAAO;AAAA,QACH,OAAO;AACH,aAAG;AACC,gBAAI,eAAe,QAAW;AAC1B,qBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,YAC1C;AACA,kBAAM,SAAS,WAAW,KAAK;AAC/B,gBAAI,OAAO,SAAS,MAAM;AACtB,kCAAoB;AACpB,2BAAa,UAAU,gBAAgB,IAAI,OAAO,QAAQ,EAAE;AAC5D;AAAA,YACJ;AACA,mBAAO;AAAA,cACH,MAAM;AAAA,cACN,OAAO,OAAO;AAAA,YAClB;AAAA,UACJ,SAAS;AAAA,QACb;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;AAEA,IAAM,4BAA4B,CAAC,mBAAmB,iBAAiB;AAIvE,SAAS,SAAS,OAAO;AAErB,MAAI,CAAC,0BAA0B,SAAS,OAAO,UAAU,SAAS,KAAK,KAAK,CAAC,GAAG;AAC5E,WAAO;AAAA,EACX;AACA,QAAM,EAAE,YAAY,IAAI;AAGxB,MAAI,gBAAgB,QAAW;AAC3B,WAAO;AAAA,EACX;AACA,QAAM,YAAY,YAAY;AAE9B,MAAI,cAAc,QACd,OAAO,cAAc,YACrB,CAAC,0BAA0B,SAAS,OAAO,UAAU,SAAS,KAAK,SAAS,CAAC,GAAG;AAChF,WAAO;AAAA,EACX;AAGA,MAAI,CAAC,UAAU,eAAe,eAAe,GAAG;AAC5C,WAAO;AAAA,EACX;AAEA,SAAO;AACX;AAOA,SAAS,eAAe,QAAQ,OAAO,MAAM;AACzC,QAAM,SAAS,CAAC;AAChB,aAAW,OAAO,QAAQ,MAAM,GAAG;AAC/B,UAAM,aAAa,CAAC;AACpB,eAAW,SAAS,QAAQ;AACxB,UAAI,kBAAkB,OAAO,GAAG,GAAG;AAC/B,mBAAW,KAAK,MAAM,GAAG,CAAC;AAAA,MAC9B;AAAA,IACJ;AACA,QAAI,WAAW,WAAW,GAAG;AACzB;AAAA,IACJ;AACA,UAAM,cAAc,MAAM,gBAAgB,MAAM;AAAA,MAC5C;AAAA,MACA,SAAS;AAAA,IACb,CAAC;AACD,UAAM,iBAAiB,cAAc,YAAY,OAAO,WAAW;AACnE,QAAI,mBAAmB,QAAQ,MAAM;AACjC;AAAA,IACJ;AACA,QAAI,QAAQ,aAAa;AACrB,aAAO,eAAe,QAAQ,KAAK;AAAA,QAC/B,OAAO;AAAA,QACP,cAAc;AAAA,QACd,YAAY;AAAA,QACZ,UAAU;AAAA,MACd,CAAC;AAAA,IACL,OACK;AACD,aAAO,GAAG,IAAI;AAAA,IAClB;AAAA,EACJ;AACA,SAAO;AACX;AAMA,SAAS,cAAc,QAAQ;AAC3B,SAAO,OAAO,KAAK;AACvB;AAMA,SAAS,YAAY,QAAQ;AACzB,SAAO,IAAI,IAAI,uBAAuB,MAAM,CAAC;AACjD;AAMA,SAAS,YAAY,QAAQ;AACzB,SAAO,IAAI,IAAI,uBAAuB,MAAM,CAAC;AACjD;AAIA,SAAS,cAAc,QAAQ;AAC3B,SAAO,OAAO,GAAG,EAAE;AACvB;AAIA,IAAM,iBAAiB;AAAA,EACnB,cAAc;AAAA,EACd,aAAa;AAAA,EACb,WAAW;AAAA,EACX,WAAW;AAAA,EACX,aAAa;AACjB;AAOA,SAAS,aAAa,SAAS;AAC3B,SAAO,gBAAgB,CAAC,CAAC,EAAE,GAAG,OAAO;AACzC;AACA,SAAS,gBAAgB,SAAS,cAAc;AAC5C,QAAM,QAAQ,SAAS,SAAS,mBAAmB;AAInD,WAAS,uBAAuB,SAAS;AACrC,WAAO,cAAc,SAAS,OAAO,YAAY;AAAA,EACrD;AACA,SAAO;AACX;AAMA,SAAS,SAAS,SAAS,qBAAqB;AAC5C,SAAO;AAAA,IACH,uBAAuB;AAAA,IACvB,gBAAgB;AAAA,MACZ,GAAG;AAAA,MACH,GAAG,OAAO,YAAY,OAAO,QAAQ,OAAO,EACvC,OAAO,CAAC,CAAC,KAAK,MAAM,MAAM,OAAO,OAAO,gBAAgB,GAAG,CAAC,EAC5D,IAAI,CAAC,CAAC,KAAK,MAAM,MAAO,WAAW,QAAQ,CAAC,KAAK,eAAe,WAAW,IAAI,CAAC,KAAK,MAAM,CAAE,CAAC;AAAA,IACvG;AAAA,IACA,iBAAkB,QAAQ,mBAAmB;AAAA,IAC7C,WAAW;AAAA,IACX,2BAA2B,QAAQ,gCAAgC;AAAA,IACnE,cAAc,QAAQ,iBAAiB,QAAQ,SAAa,QAAQ,gBAAgB;AAAA,IACpF;AAAA,EACJ;AACJ;AAMA,SAAS,cAAc,QAAQ,OAAO,MAAM;AACxC,QAAM,iBAAiB,MAAM,eAAe,QAAQ,IAAI,KAAK;AAC7D,MAAI,eAAe,WAAW,GAAG;AAC7B,WAAO;AAAA,EACX;AACA,MAAI,eAAe,WAAW,GAAG;AAC7B,WAAO,YAAY,gBAAgB,OAAO,IAAI;AAAA,EAClD;AACA,QAAM,OAAO,cAAc,eAAe,CAAC,CAAC;AAC5C,MAAI,SAAS,KAA0B,SAAS,GAA0B;AACtE,aAAS,UAAU,GAAG,UAAU,eAAe,QAAQ,WAAW;AAC9D,UAAI,cAAc,eAAe,OAAO,CAAC,MAAM,MAAM;AACjD;AAAA,MACJ;AACA,aAAO,YAAY,gBAAgB,OAAO,IAAI;AAAA,IAClD;AAAA,EACJ;AACA,UAAQ,MAAM;AAAA,IACV,KAAK,GAA2B;AAC5B,aAAO,aAAa,gBAAgB,OAAO,IAAI;AAAA,IACnD;AAAA,IACA,KAAK,GAA0B;AAC3B,aAAO,YAAY,gBAAgB,OAAO,IAAI;AAAA,IAClD;AAAA,IACA,KAAK,GAAwB;AACzB,aAAO,UAAU,gBAAgB,OAAO,IAAI;AAAA,IAChD;AAAA,IACA,KAAK,GAAwB;AACzB,aAAO,UAAU,gBAAgB,OAAO,IAAI;AAAA,IAChD;AAAA,IACA,SAAS;AACL,aAAO,YAAY,gBAAgB,OAAO,IAAI;AAAA,IAClD;AAAA,EACJ;AACJ;AAMA,SAAS,aAAa,QAAQ,OAAO,MAAM;AACvC,QAAM,SAAS,MAAM,eAAe,aAAa,QAAQ,OAAO,IAAI;AACpE,MAAI,WAAW,QAAQ,gBAClB,MAAM,6BACH,WAAW,UACX,MAAM,eAAe,iBAAiB,MAAM,sBAAsB,cAAe;AACrF,WAAO,MAAM,sBAAsB,aAAa,QAAQ,OAAO,IAAI;AAAA,EACvE;AACA,SAAO;AACX;AAMA,SAAS,YAAY,QAAQ,OAAO,MAAM;AACtC,QAAM,SAAS,MAAM,eAAe,YAAY,QAAQ,OAAO,IAAI;AACnE,MAAI,WAAW,QAAQ,gBAClB,MAAM,6BACH,WAAW,UACX,MAAM,eAAe,gBAAgB,MAAM,sBAAsB,aAAc;AACnF,WAAO,MAAM,sBAAsB,YAAY,MAAM;AAAA,EACzD;AACA,SAAO;AACX;AAMA,SAAS,UAAU,QAAQ,OAAO,MAAM;AACpC,QAAM,SAAS,MAAM,eAAe,UAAU,QAAQ,OAAO,IAAI;AACjE,MAAI,WAAW,QAAQ,gBAClB,MAAM,6BACH,WAAW,UACX,MAAM,eAAe,cAAc,MAAM,sBAAsB,WAAY;AAC/E,WAAO,MAAM,sBAAsB,UAAU,MAAM;AAAA,EACvD;AACA,SAAO;AACX;AAMA,SAAS,UAAU,QAAQ,OAAO,MAAM;AACpC,QAAM,SAAS,MAAM,eAAe,UAAU,QAAQ,OAAO,IAAI;AACjE,MAAI,WAAW,QAAQ,gBAClB,MAAM,6BACH,WAAW,UACX,MAAM,eAAe,cAAc,MAAM,sBAAsB,WAAY;AAC/E,WAAO,MAAM,sBAAsB,UAAU,MAAM;AAAA,EACvD;AACA,SAAO;AACX;AAMA,SAAS,YAAY,QAAQ,OAAO,MAAM;AACtC,QAAM,SAAS,MAAM,eAAe,YAAY,QAAQ,OAAO,IAAI;AACnE,MAAI,WAAW,QAAQ,gBAClB,MAAM,6BACH,WAAW,UACX,MAAM,eAAe,gBAAgB,MAAM,sBAAsB,aAAc;AACnF,WAAO,MAAM,sBAAsB,YAAY,MAAM;AAAA,EACzD;AACA,SAAO;AACX;;;ACrYO,SAAS,SACZ,MACA,MACF;AACE,MAAI,UAAU;AACd,SAAO,YAAa,MAAM;AACtB,QAAI,YAAY,MAAM;AAClB,mBAAa,OAAO;AAAA,IACxB;AACA,cAAU,OAAO,WAAW,MAAM;AAC9B,WAAK,MAAM,MAAM,IAAI;AACrB,gBAAU;AAAA,IACd,GAAG,IAAI;AAAA,EACX;AACJ;;;ALOA,IAAqB,iBAArB,cAA4C,wBAAO;AAAA,EAIlD,YAAY,KAAU,UAA2B;AAChD,UAAM,eAAe,YAAY,2BAAY;AAC7C,UAAM,KAAK,YAAY;AACvB,SAAK,MAAM;AAAA,EACZ;AAAA,EAEA,MAAM,SAAS;AACd,YAAQ,IAAI,0BAA0B;AAEtC,UAAM,KAAK,aAAa;AACxB,SAAK,cAAc,IAAI,WAAW,KAAK,KAAK,IAAI,CAAC;AAGjD,SAAK;AAAA,MACJ;AAAA,MACA,OAAO,QAAgB,IAAiB,QAAqD;AAC5F,cAAM,wBAAgC,IAAI;AAC1C,cAAM,WAAmB,sBAAsB,UAAU,GAAG,sBAAsB,YAAY,GAAG,CAAC;AAElG,cAAM,YAAY;AAClB,cAAM,QAAkB,OAAO,MAAM,IAAI;AAGzC,cAAM,kBAA0B,MAAM,IAAI,CAAC,SAAS;AACnD,gBAAM,QAAiC,KAAK,MAAM,SAAS;AAC3D,cAAI,CAAC,MAAO,QAAO;AAEnB,gBAAM,CAAC,EAAE,QAAQ,WAAW,IAAsB;AAClD,gBAAM,UAAU,GAAG,QAAQ,IAAI,WAAW;AAE1C,iBAAO,GAAG,MAAM,OAAO,OAAO,IAAI,WAAW;AAAA,QAC9C,CAAC,EACC,KAAK,IAAI;AAGX,cAAM,kCAAiB,OAAO,KAAK,KAAK,iBAAiB,IAAI,uBAAuB,IAAI;AAAA,MACzF;AAAA,IACD;AAGA,SAAK;AAAA,MACJ,KAAK,IAAI,MAAM;AAAA,QACd;AAAA,QACA,SAAS,KAAK,mBAAmB,KAAK,IAAI,GAAG,GAAI;AAAA,MAClD;AAAA,IACD;AAAA,EACD;AAAA,EAEA,WAAW;AACV,YAAQ,IAAI,4BAA4B;AAAA,EACzC;AAAA,EAEA,MAAM,eAAe;AACpB,QAAI,iBAAiB;AACrB,UAAM,eAAe,MAAM,KAAK,SAAS;AACzC,QAAI,cAAc;AACjB,uBAAiB,UAAU,kBAAkB,YAAY;AAAA,IAC1D;AACA,SAAK,WAAW;AAAA,EACjB;AAAA,EAEA,MAAM,eAAe;AACpB,UAAM,KAAK,SAAS,KAAK,QAAQ;AAAA,EAClC;AAAA;AAAA,EAGQ,qBAAqB,iBAA4C;AAExE,UAAM,YAAoB,gBAAgB,SAAS,MAAM;AACzD,UAAM,UAAU;AAChB,UAAM,UAAkB,gBAAgB,SAAS,IAAI;AACrD,UAAM,QAAgB,gBAAgB,SAAS,IAAI;AAEnD,UAAM,cAA8B,EAAE,MAAM,WAAW,IAAI,QAAQ;AACnE,UAAM,YAA4B,EAAE,MAAM,SAAS,IAAI,MAAM;AAE7D,WAAO,EAAE,MAAM,aAAa,IAAI,UAAU;AAAA,EAC3C;AAAA;AAAA,EAGQ,YAAY,cAAsC;AACzD,UAAM,iBAA2B,CAAC;AAGlC,QAAI,aAAa,SAAS,GAAG;AAC5B,mBAAa,QAAQ,CAAC,iBAA+B;AACpD,cAAM,eAAuB,aAAa;AAC1C,cAAM,cAAsB,aAAa;AACzC,cAAM,gBAAgB,GAAG,IAAI,QAAQ,eAAe,KAAK,CAAC,CAAC,KAAK,WAAW;AAE3E,uBAAe,KAAK,aAAa;AAAA,MAClC,CAAC;AAAA,IACF;AAEA,UAAM,aAAqB,eAAe,KAAK,IAAI;AACnD,WAAO;AAAA,EAAoB,UAAU;AAAA;AAAA,EACtC;AAAA;AAAA,EAGQ,cAAc,QAAgB,MAAmB;AAExD,UAAM,YAAmC,KAAK,IAAI,cAAc,aAAa,IAAI;AACjF,UAAM,eAA+B,WAAW,YAAY,CAAC;AAC7D,UAAM,kBAA4C,WAAW,WAC1D,UAAU,SAAS;AAAA,MACpB,CAAC,YAA0B,QAAQ,SAAS,UAC3C,OAAO,QAAQ,QAAQ,SAAS,MAAM,IAAI,MAAM;AAAA,IAClD,IAAI;AAGL,QAAI,CAAC,gBAAiB;AAGtB,UAAM,iBAA8B,KAAK,qBAAqB,eAAe;AAC7E,UAAM,cAAc,KAAK,YAAY,YAAY;AAGjD,WAAO,aAAa,aAAa,eAAe,MAAM,eAAe,EAAE;AAAA,EACxE;AAAA;AAAA,EAGA,MAAc,qBAAoC;AACjD,UAAM,eAAwC,KAAK,IAAI,UAAU;AACjE,UAAM,SAA6B,cAAc;AACjD,UAAM,OAA0B,cAAc,QAAQ;AAEtD,QAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAM;AAGvC,QAAI,OAAQ,MAAK,cAAc,QAAQ,IAAI;AAAA,EAC5C;AACD;",
  "names": ["import_obsidian", "ObjectType"]
}
 diff --git a/package.json b/package.json index c21d241..acf08e2 100644 --- a/package.json +++ b/package.json @@ -41,4 +41,4 @@ "dependencies": { "deepmerge-ts": "7.1.3" } -} +} \ No newline at end of file