obsidian-typings 2.23.2 → 2.23.4

package/dist/cjs/implementations.cjs

@@ -0,0 +1,499 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+*/
+
+"use strict";
+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/obsidian/implementations/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CustomArrayDictImpl: () => CustomArrayDictImpl,
+  FileExtension: () => FileExtension,
+  InternalPluginName: () => InternalPluginName,
+  ViewType: () => ViewType,
+  createTFileInstance: () => createTFileInstance,
+  createTFolderInstance: () => createTFolderInstance,
+  getAllPropertiesViewConstructor: () => getAllPropertiesViewConstructor,
+  getAppConstructor: () => getAppConstructor,
+  getAudioViewConstructor: () => getAudioViewConstructor,
+  getBacklinkViewConstructor: () => getBacklinkViewConstructor,
+  getBookmarksViewConstructor: () => getBookmarksViewConstructor,
+  getBrowserHistoryViewConstructor: () => getBrowserHistoryViewConstructor,
+  getBrowserViewConstructor: () => getBrowserViewConstructor,
+  getCanvasViewConstructor: () => getCanvasViewConstructor,
+  getEmptyViewConstructor: () => getEmptyViewConstructor,
+  getFileExplorerViewConstructor: () => getFileExplorerViewConstructor,
+  getFilePropertiesViewConstructor: () => getFilePropertiesViewConstructor,
+  getGraphViewConstructor: () => getGraphViewConstructor,
+  getImageViewConstructor: () => getImageViewConstructor,
+  getInternalPluginConstructor: () => getInternalPluginConstructor,
+  getInternalPluginsConstructor: () => getInternalPluginsConstructor,
+  getLocalGraphViewConstructor: () => getLocalGraphViewConstructor,
+  getMarkdownViewConstructor: () => getMarkdownViewConstructor,
+  getOutgoingLinkViewConstructor: () => getOutgoingLinkViewConstructor,
+  getOutlineViewConstructor: () => getOutlineViewConstructor,
+  getPdfViewConstructor: () => getPdfViewConstructor,
+  getReleaseNotesViewConstructor: () => getReleaseNotesViewConstructor,
+  getSearchViewConstructor: () => getSearchViewConstructor,
+  getSyncViewConstructor: () => getSyncViewConstructor,
+  getTFileConstructor: () => getTFileConstructor,
+  getTFolderConstructor: () => getTFolderConstructor,
+  getTagViewConstructor: () => getTagViewConstructor,
+  getVideoViewConstructor: () => getVideoViewConstructor,
+  getViewConstructorByViewType: () => getViewConstructorByViewType,
+  isEmbedCache: () => isEmbedCache,
+  isFrontmatterLinkCache: () => isFrontmatterLinkCache,
+  isLinkCache: () => isLinkCache,
+  isReferenceCache: () => isReferenceCache,
+  parentFolderPath: () => parentFolderPath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/obsidian/implementations/Classes/CustomArrayDictImpl.ts
+var CustomArrayDictImpl = class {
+  data = /* @__PURE__ */ new Map();
+  add(key, value) {
+    let values = this.get(key);
+    if (!values) {
+      values = [];
+      this.data.set(key, values);
+    }
+    if (!values.includes(value)) {
+      values.push(value);
+    }
+  }
+  remove(key, value) {
+    const values = this.get(key);
+    if (!values) {
+      return;
+    }
+    values.remove(value);
+    if (values.length === 0) {
+      this.clear(key);
+    }
+  }
+  get(key) {
+    return this.data.get(key) || null;
+  }
+  keys() {
+    return Array.from(this.data.keys());
+  }
+  clear(key) {
+    this.data.delete(key);
+  }
+  clearAll() {
+    this.data.clear();
+  }
+  contains(key, value) {
+    return !!this.get(key)?.contains(value);
+  }
+  count() {
+    let ans = 0;
+    for (const key in this.keys()) {
+      ans += this.get(key)?.length ?? 0;
+    }
+    return ans;
+  }
+};
+
+// src/obsidian/implementations/Constants/FileExtension.ts
+var FileExtension = {
+  _3gp: "3gp",
+  avif: "avif",
+  bmp: "bmp",
+  canvas: "canvas",
+  flac: "flac",
+  gif: "gif",
+  jpeg: "jpeg",
+  jpg: "jpg",
+  m4a: "m4a",
+  md: "md",
+  mkv: "mkv",
+  mov: "mov",
+  mp3: "mp3",
+  mp4: "mp4",
+  oga: "oga",
+  ogg: "ogg",
+  ogv: "ogv",
+  opus: "opus",
+  pdf: "pdf",
+  png: "png",
+  svg: "svg",
+  wav: "wav",
+  webm: "webm",
+  webp: "webp"
+};
+
+// src/obsidian/implementations/Constants/InternalPluginName.ts
+var InternalPluginName = {
+  /**
+   * Plugin name in UI: Audio recorder
+   */
+  AudioRecorder: "audio-recorder",
+  /**
+   * Plugin name in UI: Backlinks
+   */
+  Backlink: "backlink",
+  /**
+   * Plugin name in UI: Bookmarks
+   */
+  Bookmarks: "bookmarks",
+  /**
+   * Plugin name in UI: Web viewer
+   */
+  Browser: "browser",
+  /**
+   * Plugin name in UI: Canvas
+   */
+  Canvas: "canvas",
+  /**
+   * Plugin name in UI: Command palette
+   */
+  CommandPalette: "command-palette",
+  /**
+   * Plugin name in UI: Daily notes
+   */
+  DailyNotes: "daily-notes",
+  /**
+   * Plugin name in UI: (hidden)
+   */
+  EditorStatus: "editor-status",
+  /**
+   * Plugin name in UI: Files
+   */
+  FileExplorer: "file-explorer",
+  /**
+   * Plugin name in UI: File recovery
+   */
+  FileRecovery: "file-recovery",
+  /**
+   * Plugin name in UI: Search
+   */
+  GlobalSearch: "global-search",
+  /**
+   * Plugin name in UI: Graph view
+   */
+  Graph: "graph",
+  /**
+   * Plugin name in UI: Format converter
+   */
+  MarkdownImporter: "markdown-importer",
+  /**
+   * Plugin name in UI: Note composer
+   */
+  NoteComposer: "note-composer",
+  /**
+   * Plugin name in UI: Outgoing links
+   */
+  OutgoingLink: "outgoing-link",
+  /**
+   * Plugin name in UI: Outline
+   */
+  Outline: "outline",
+  /**
+   * Plugin name in UI: Page preview
+   */
+  PagePreview: "page-preview",
+  /**
+   * Plugin name in UI: Properties view
+   */
+  Properties: "properties",
+  /**
+   * Plugin name in UI: Publish
+   */
+  Publish: "publish",
+  /**
+   * Plugin name in UI: Random note
+   */
+  RandomNote: "random-note",
+  /**
+   * Plugin name in UI: Slash commands
+   */
+  SlashCommand: "slash-command",
+  /**
+   * Plugin name in UI: Slides
+   */
+  Slides: "slides",
+  /**
+   * Plugin name in UI: Quick Switcher
+   */
+  Switcher: "switcher",
+  /**
+   * Plugin name in UI: Sync
+   */
+  Sync: "sync",
+  /**
+   * Plugin name in UI: Tags view
+   */
+  TagPane: "tag-pane",
+  /**
+   * Plugin name in UI: Templates
+   */
+  Templates: "templates",
+  /**
+   * Plugin name in UI: Word count
+   */
+  WordCount: "word-count",
+  /**
+   * Plugin name in UI: Workspaces
+   */
+  Workspaces: "workspaces",
+  /**
+   * Plugin name in UI: Unique note creator
+   */
+  ZkPrefixer: "zk-prefixer"
+};
+
+// src/obsidian/implementations/Constants/ViewType.ts
+var ViewType = {
+  AllProperties: "all-properties",
+  Audio: "audio",
+  Backlink: InternalPluginName.Backlink,
+  Bookmarks: InternalPluginName.Bookmarks,
+  Browser: "browser",
+  BrowserHistory: "browser-history",
+  Canvas: InternalPluginName.Canvas,
+  Empty: "empty",
+  FileExplorer: InternalPluginName.FileExplorer,
+  FileProperties: "file-properties",
+  Graph: InternalPluginName.Graph,
+  Image: "image",
+  LocalGraph: "localgraph",
+  Markdown: "markdown",
+  OutgoingLink: InternalPluginName.OutgoingLink,
+  Outline: InternalPluginName.Outline,
+  Pdf: "pdf",
+  ReleaseNotes: "release-notes",
+  Search: "search",
+  Sync: "sync",
+  Tag: "tag",
+  Video: "video"
+};
+
+// src/obsidian/implementations/Constructors/getAppConstructor.ts
+var import_obsidian = require("obsidian");
+function getAppConstructor() {
+  return import_obsidian.App;
+}
+
+// src/obsidian/implementations/Constructors/getInternalPluginConstructor.ts
+function getInternalPluginConstructor(app) {
+  const anyPlugin = Object.values(app.internalPlugins.plugins)[0];
+  if (!anyPlugin) {
+    throw new Error("No internal plugin found");
+  }
+  return anyPlugin.constructor;
+}
+
+// src/obsidian/implementations/Constructors/getInternalPluginsConstructor.ts
+function getInternalPluginsConstructor(app) {
+  return app.internalPlugins.constructor;
+}
+
+// src/obsidian/implementations/Constructors/getTFileConstructor.ts
+var import_obsidian2 = require("obsidian");
+function getTFileConstructor() {
+  return import_obsidian2.TFile;
+}
+
+// src/obsidian/implementations/Constructors/getTFolderConstructor.ts
+var import_obsidian3 = require("obsidian");
+function getTFolderConstructor() {
+  return import_obsidian3.TFolder;
+}
+
+// src/obsidian/implementations/Constructors/Views/getViewConstructorByViewType.ts
+function getViewConstructorByViewType(app, viewType) {
+  const leaf = app.workspace.createLeafInTabGroup();
+  try {
+    const viewCreator = app.viewRegistry.getViewCreatorByType(viewType);
+    if (!viewCreator) {
+      throw new Error("View creator not found");
+    }
+    const view = viewCreator(leaf);
+    return view.constructor;
+  } finally {
+    leaf.detach();
+  }
+}
+
+// src/obsidian/implementations/Constructors/Views/getAllPropertiesViewConstructor.ts
+function getAllPropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.AllProperties);
+}
+
+// src/obsidian/implementations/Constructors/Views/getAudioViewConstructor.ts
+function getAudioViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Audio);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBacklinkViewConstructor.ts
+function getBacklinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Backlink);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBookmarksViewConstructor.ts
+function getBookmarksViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Bookmarks);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBrowserHistoryViewConstructor.ts
+function getBrowserHistoryViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.BrowserHistory);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBrowserViewConstructor.ts
+function getBrowserViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Browser);
+}
+
+// src/obsidian/implementations/Constructors/Views/getCanvasViewConstructor.ts
+function getCanvasViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Canvas);
+}
+
+// src/obsidian/implementations/Constructors/Views/getEmptyViewConstructor.ts
+function getEmptyViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Empty);
+}
+
+// src/obsidian/implementations/Constructors/Views/getFileExplorerViewConstructor.ts
+function getFileExplorerViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileExplorer);
+}
+
+// src/obsidian/implementations/Constructors/Views/getFilePropertiesViewConstructor.ts
+function getFilePropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileProperties);
+}
+
+// src/obsidian/implementations/Constructors/Views/getGraphViewConstructor.ts
+function getGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Graph);
+}
+
+// src/obsidian/implementations/Constructors/Views/getImageViewConstructor.ts
+function getImageViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Image);
+}
+
+// src/obsidian/implementations/Constructors/Views/getLocalGraphViewConstructor.ts
+function getLocalGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.LocalGraph);
+}
+
+// src/obsidian/implementations/Constructors/Views/getMarkdownViewConstructor.ts
+function getMarkdownViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Markdown);
+}
+
+// src/obsidian/implementations/Constructors/Views/getOutgoingLinkViewConstructor.ts
+function getOutgoingLinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.OutgoingLink);
+}
+
+// src/obsidian/implementations/Constructors/Views/getOutlineViewConstructor.ts
+function getOutlineViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Outline);
+}
+
+// src/obsidian/implementations/Constructors/Views/getPdfViewConstructor.ts
+function getPdfViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Pdf);
+}
+
+// src/obsidian/implementations/Constructors/Views/getReleaseNotesViewConstructor.ts
+function getReleaseNotesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.ReleaseNotes);
+}
+
+// src/obsidian/implementations/Constructors/Views/getSearchViewConstructor.ts
+function getSearchViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Search);
+}
+
+// src/obsidian/implementations/Constructors/Views/getSyncViewConstructor.ts
+function getSyncViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Sync);
+}
+
+// src/obsidian/implementations/Constructors/Views/getTagViewConstructor.ts
+function getTagViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Tag);
+}
+
+// src/obsidian/implementations/Constructors/Views/getVideoViewConstructor.ts
+function getVideoViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Video);
+}
+
+// src/obsidian/implementations/Functions/createTFileInstance.ts
+var import_obsidian5 = require("obsidian");
+
+// src/obsidian/implementations/Utils/PathUtils.ts
+function parentFolderPath(path) {
+  return path.replace(/\/?[^\/]*$/, "") || "/";
+}
+
+// src/obsidian/implementations/Functions/createTFolderInstance.ts
+var import_obsidian4 = require("obsidian");
+function createTFolderInstance(app, path) {
+  let folder = app.vault.getFolderByPath(path);
+  if (folder) {
+    return folder;
+  }
+  folder = new (getTFolderConstructor())(app.vault, path);
+  folder.parent = createTFolderInstance(app, parentFolderPath(path));
+  folder.deleted = true;
+  return folder;
+}
+
+// src/obsidian/implementations/Functions/createTFileInstance.ts
+function createTFileInstance(app, path) {
+  let file = app.vault.getFileByPath(path);
+  if (file) {
+    return file;
+  }
+  file = new (getTFileConstructor())(app.vault, path);
+  file.parent = createTFolderInstance(app, parentFolderPath(path));
+  file.deleted = true;
+  return file;
+}
+
+// src/obsidian/implementations/TypeGuards/isReferenceCache.ts
+function isReferenceCache(reference) {
+  return !!reference.position;
+}
+
+// src/obsidian/implementations/TypeGuards/isEmbedCache.ts
+function isEmbedCache(reference) {
+  return isReferenceCache(reference) && reference.original[0] === "!";
+}
+
+// src/obsidian/implementations/TypeGuards/isFrontmatterLinkCache.ts
+function isFrontmatterLinkCache(reference) {
+  return !!reference.key;
+}
+
+// src/obsidian/implementations/TypeGuards/isLinkCache.ts
+function isLinkCache(reference) {
+  return isReferenceCache(reference) && reference.original[0] !== "!";
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/obsidian/implementations/index.ts", "../../src/obsidian/implementations/Classes/CustomArrayDictImpl.ts", "../../src/obsidian/implementations/Constants/FileExtension.ts", "../../src/obsidian/implementations/Constants/InternalPluginName.ts", "../../src/obsidian/implementations/Constants/ViewType.ts", "../../src/obsidian/implementations/Constructors/getAppConstructor.ts", "../../src/obsidian/implementations/Constructors/getInternalPluginConstructor.ts", "../../src/obsidian/implementations/Constructors/getInternalPluginsConstructor.ts", "../../src/obsidian/implementations/Constructors/getTFileConstructor.ts", "../../src/obsidian/implementations/Constructors/getTFolderConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getViewConstructorByViewType.ts", "../../src/obsidian/implementations/Constructors/Views/getAllPropertiesViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getAudioViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getBacklinkViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getBookmarksViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getBrowserHistoryViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getBrowserViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getCanvasViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getEmptyViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getFileExplorerViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getFilePropertiesViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getGraphViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getImageViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getLocalGraphViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getMarkdownViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getOutgoingLinkViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getOutlineViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getPdfViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getReleaseNotesViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getSearchViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getSyncViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getTagViewConstructor.ts", "../../src/obsidian/implementations/Constructors/Views/getVideoViewConstructor.ts", "../../src/obsidian/implementations/Functions/createTFileInstance.ts", "../../src/obsidian/implementations/Utils/PathUtils.ts", "../../src/obsidian/implementations/Functions/createTFolderInstance.ts", "../../src/obsidian/implementations/TypeGuards/isReferenceCache.ts", "../../src/obsidian/implementations/TypeGuards/isEmbedCache.ts", "../../src/obsidian/implementations/TypeGuards/isFrontmatterLinkCache.ts", "../../src/obsidian/implementations/TypeGuards/isLinkCache.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * from './Classes/CustomArrayDictImpl.ts';\nexport * from './Constants/FileExtension.ts';\nexport * from './Constants/InternalPluginName.ts';\nexport * from './Constants/ViewType.ts';\nexport * from './Constructors/getAppConstructor.ts';\nexport * from './Constructors/getInternalPluginConstructor.ts';\nexport * from './Constructors/getInternalPluginsConstructor.ts';\nexport * from './Constructors/getTFileConstructor.ts';\nexport * from './Constructors/getTFolderConstructor.ts';\nexport * from './Constructors/Views/getAllPropertiesViewConstructor.ts';\nexport * from './Constructors/Views/getAudioViewConstructor.ts';\nexport * from './Constructors/Views/getBacklinkViewConstructor.ts';\nexport * from './Constructors/Views/getBookmarksViewConstructor.ts';\nexport * from './Constructors/Views/getBrowserHistoryViewConstructor.ts';\nexport * from './Constructors/Views/getBrowserViewConstructor.ts';\nexport * from './Constructors/Views/getCanvasViewConstructor.ts';\nexport * from './Constructors/Views/getEmptyViewConstructor.ts';\nexport * from './Constructors/Views/getFileExplorerViewConstructor.ts';\nexport * from './Constructors/Views/getFilePropertiesViewConstructor.ts';\nexport * from './Constructors/Views/getGraphViewConstructor.ts';\nexport * from './Constructors/Views/getImageViewConstructor.ts';\nexport * from './Constructors/Views/getLocalGraphViewConstructor.ts';\nexport * from './Constructors/Views/getMarkdownViewConstructor.ts';\nexport * from './Constructors/Views/getOutgoingLinkViewConstructor.ts';\nexport * from './Constructors/Views/getOutlineViewConstructor.ts';\nexport * from './Constructors/Views/getPdfViewConstructor.ts';\nexport * from './Constructors/Views/getReleaseNotesViewConstructor.ts';\nexport * from './Constructors/Views/getSearchViewConstructor.ts';\nexport * from './Constructors/Views/getSyncViewConstructor.ts';\nexport * from './Constructors/Views/getTagViewConstructor.ts';\nexport * from './Constructors/Views/getVideoViewConstructor.ts';\nexport * from './Constructors/Views/getViewConstructorByViewType.ts';\nexport * from './Functions/createTFileInstance.ts';\nexport * from './Functions/createTFolderInstance.ts';\nexport * from './TypeGuards/isEmbedCache.ts';\nexport * from './TypeGuards/isFrontmatterLinkCache.ts';\nexport * from './TypeGuards/isLinkCache.ts';\nexport * from './TypeGuards/isReferenceCache.ts';\nexport * from './Utils/PathUtils.ts';\nexport * from '../../index.js';\n", "import type { CustomArrayDict } from '../../internals/CustomArrayDict.d.ts';\n\n/** @public */\nexport class CustomArrayDictImpl<T> implements CustomArrayDict<T> {\n    public data: Map<string, T[]> = new Map();\n\n    public add(key: string, value: T): void {\n        let values = this.get(key);\n        if (!values) {\n            values = [];\n            this.data.set(key, values);\n        }\n\n        if (!values.includes(value)) {\n            values.push(value);\n        }\n    }\n\n    public remove(key: string, value: T): void {\n        const values = this.get(key);\n        if (!values) {\n            return;\n        }\n        values.remove(value);\n\n        if (values.length === 0) {\n            this.clear(key);\n        }\n    }\n\n    public get(key: string): T[] | null {\n        return this.data.get(key) || null;\n    }\n\n    public keys(): string[] {\n        return Array.from(this.data.keys());\n    }\n\n    public clear(key: string): void {\n        this.data.delete(key);\n    }\n\n    public clearAll(): void {\n        this.data.clear();\n    }\n\n    public contains(key: string, value: T): boolean {\n        return !!this.get(key)?.contains(value);\n    }\n\n    public count(): number {\n        let ans = 0;\n        for (const key in this.keys()) {\n            ans += this.get(key)?.length ?? 0;\n        }\n\n        return ans;\n    }\n}\n", "/** @public */\nexport const FileExtension = {\n    _3gp: '3gp',\n    avif: 'avif',\n    bmp: 'bmp',\n    canvas: 'canvas',\n    flac: 'flac',\n    gif: 'gif',\n    jpeg: 'jpeg',\n    jpg: 'jpg',\n    m4a: 'm4a',\n    md: 'md',\n    mkv: 'mkv',\n    mov: 'mov',\n    mp3: 'mp3',\n    mp4: 'mp4',\n    oga: 'oga',\n    ogg: 'ogg',\n    ogv: 'ogv',\n    opus: 'opus',\n    pdf: 'pdf',\n    png: 'png',\n    svg: 'svg',\n    wav: 'wav',\n    webm: 'webm',\n    webp: 'webp'\n} as const;\n", "/** @public */\nexport const InternalPluginName = {\n    /**\n     * Plugin name in UI: Audio recorder\n     */\n    AudioRecorder: 'audio-recorder',\n    /**\n     * Plugin name in UI: Backlinks\n     */\n    Backlink: 'backlink',\n    /**\n     * Plugin name in UI: Bookmarks\n     */\n    Bookmarks: 'bookmarks',\n    /**\n     * Plugin name in UI: Web viewer\n     */\n    Browser: 'browser',\n    /**\n     * Plugin name in UI: Canvas\n     */\n    Canvas: 'canvas',\n    /**\n     * Plugin name in UI: Command palette\n     */\n    CommandPalette: 'command-palette',\n    /**\n     * Plugin name in UI: Daily notes\n     */\n    DailyNotes: 'daily-notes',\n    /**\n     * Plugin name in UI: (hidden)\n     */\n    EditorStatus: 'editor-status',\n    /**\n     * Plugin name in UI: Files\n     */\n    FileExplorer: 'file-explorer',\n    /**\n     * Plugin name in UI: File recovery\n     */\n    FileRecovery: 'file-recovery',\n    /**\n     * Plugin name in UI: Search\n     */\n    GlobalSearch: 'global-search',\n    /**\n     * Plugin name in UI: Graph view\n     */\n    Graph: 'graph',\n    /**\n     * Plugin name in UI: Format converter\n     */\n    MarkdownImporter: 'markdown-importer',\n    /**\n     * Plugin name in UI: Note composer\n     */\n    NoteComposer: 'note-composer',\n    /**\n     * Plugin name in UI: Outgoing links\n     */\n    OutgoingLink: 'outgoing-link',\n    /**\n     * Plugin name in UI: Outline\n     */\n    Outline: 'outline',\n    /**\n     * Plugin name in UI: Page preview\n     */\n    PagePreview: 'page-preview',\n    /**\n     * Plugin name in UI: Properties view\n     */\n    Properties: 'properties',\n    /**\n     * Plugin name in UI: Publish\n     */\n    Publish: 'publish',\n    /**\n     * Plugin name in UI: Random note\n     */\n    RandomNote: 'random-note',\n    /**\n     * Plugin name in UI: Slash commands\n     */\n    SlashCommand: 'slash-command',\n    /**\n     * Plugin name in UI: Slides\n     */\n    Slides: 'slides',\n    /**\n     * Plugin name in UI: Quick Switcher\n     */\n    Switcher: 'switcher',\n    /**\n     * Plugin name in UI: Sync\n     */\n    Sync: 'sync',\n    /**\n     * Plugin name in UI: Tags view\n     */\n    TagPane: 'tag-pane',\n    /**\n     * Plugin name in UI: Templates\n     */\n    Templates: 'templates',\n    /**\n     * Plugin name in UI: Word count\n     */\n    WordCount: 'word-count',\n    /**\n     * Plugin name in UI: Workspaces\n     */\n    Workspaces: 'workspaces',\n    /**\n     * Plugin name in UI: Unique note creator\n     */\n    ZkPrefixer: 'zk-prefixer'\n} as const;\n", "import { InternalPluginName } from './InternalPluginName.ts';\n\n/** @public */\nexport const ViewType = {\n    AllProperties: 'all-properties',\n    Audio: 'audio',\n    Backlink: InternalPluginName.Backlink,\n    Bookmarks: InternalPluginName.Bookmarks,\n    Browser: 'browser',\n    BrowserHistory: 'browser-history',\n    Canvas: InternalPluginName.Canvas,\n    Empty: 'empty',\n    FileExplorer: InternalPluginName.FileExplorer,\n    FileProperties: 'file-properties',\n    Graph: InternalPluginName.Graph,\n    Image: 'image',\n    LocalGraph: 'localgraph',\n    Markdown: 'markdown',\n    OutgoingLink: InternalPluginName.OutgoingLink,\n    Outline: InternalPluginName.Outline,\n    Pdf: 'pdf',\n    ReleaseNotes: 'release-notes',\n    Search: 'search',\n    Sync: 'sync',\n    Tag: 'tag',\n    Video: 'video'\n} as const;\n", "import {\n    App\n} from 'obsidian';\nimport type { AppConstructor } from '../../internals/Constructors/AppConstructor.ts';\n\n/**\n * Get the App constructor.\n *\n * @returns The App constructor.\n * @public\n */\nexport function getAppConstructor(): AppConstructor {\n    return App as AppConstructor;\n}\n", "import type { App } from 'obsidian';\nimport type { InternalPluginConstructor } from '../../internals/Constructors/InternalPluginConstructor.ts';\n\n/**\n * Get the InternalPlugin constructor.\n *\n * @param app - The app instance.\n * @returns The InternalPlugin constructor.\n * @public\n */\nexport function getInternalPluginConstructor<Instance>(app: App): InternalPluginConstructor<Instance> {\n    const anyPlugin = Object.values(app.internalPlugins.plugins)[0];\n    if (!anyPlugin) {\n        throw new Error('No internal plugin found');\n    }\n    return anyPlugin.constructor as InternalPluginConstructor<Instance>;\n}\n", "import type { App } from 'obsidian';\nimport type { InternalPluginsConstructor } from '../../internals/Constructors/InternalPluginsConstructor.ts';\n\n/**\n * Get the InternalPlugins constructor.\n *\n * @param app - The app instance.\n * @returns The InternalPlugins constructor.\n * @public\n */\nexport function getInternalPluginsConstructor(app: App): InternalPluginsConstructor {\n    return app.internalPlugins.constructor as InternalPluginsConstructor;\n}\n", "import {\n    TFile\n} from 'obsidian';\nimport type { TFileConstructor } from '../../internals/Constructors/TFileConstructor.ts';\n\n/**\n * Get the TFile constructor.\n *\n * @returns The TFile constructor.\n * @public\n */\nexport function getTFileConstructor(): TFileConstructor {\n    return TFile as TFileConstructor;\n}\n", "import {\n    TFolder\n} from 'obsidian';\nimport type { TFolderConstructor } from '../../internals/Constructors/TFolderConstructor.ts';\n\n/**\n * Get the TFolder constructor.\n *\n * @returns The TFolder constructor.\n * @public\n */\nexport function getTFolderConstructor(): TFolderConstructor {\n    return TFolder as TFolderConstructor;\n}\n", "import type {\n    App,\n    Constructor,\n    View\n} from 'obsidian';\n\n/**\n * Get the view constructor by view type.\n *\n * @param app - The app.\n * @param viewType - The view type.\n * @returns The view constructor.\n * @public\n */\nexport function getViewConstructorByViewType<TView extends View = View>(\n    app: App,\n    viewType: string\n): Constructor<TView> {\n    const leaf = app.workspace.createLeafInTabGroup();\n    try {\n        const viewCreator = app.viewRegistry.getViewCreatorByType(viewType);\n        if (!viewCreator) {\n            throw new Error('View creator not found');\n        }\n        const view = viewCreator(leaf);\n        return view.constructor as Constructor<TView>;\n    } finally {\n        leaf.detach();\n    }\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { AllPropertiesView } from '../../../internals/InternalPlugins/Properties/AllPropertiesView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the AllPropertiesView constructor.\n *\n * @returns The AllPropertiesView constructor.\n * @public\n */\nexport function getAllPropertiesViewConstructor(app: App): TypedViewConstructor<AllPropertiesView> {\n    return getViewConstructorByViewType(app, ViewType.AllProperties) as TypedViewConstructor<AllPropertiesView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { AudioView } from '../../../internals/Views/AudioView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the AudioView constructor.\n *\n * @returns The AudioView constructor.\n * @public\n */\nexport function getAudioViewConstructor(app: App): TypedViewConstructor<AudioView> {\n    return getViewConstructorByViewType(app, ViewType.Audio) as TypedViewConstructor<AudioView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { BacklinkView } from '../../../internals/InternalPlugins/Backlink/BacklinkView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the BacklinkView constructor.\n *\n * @returns The BacklinkView constructor.\n * @public\n */\nexport function getBacklinkViewConstructor(app: App): TypedViewConstructor<BacklinkView> {\n    return getViewConstructorByViewType(app, ViewType.Backlink) as TypedViewConstructor<BacklinkView>;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type { BookmarksViewConstructor } from '../../../internals/Constructors/Views/BookmarksViewConstructor.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the BookmarksView constructor.\n *\n * @returns The BookmarksView constructor.\n * @public\n */\nexport function getBookmarksViewConstructor(app: App): BookmarksViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.Bookmarks) as BookmarksViewConstructor;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type {\n    BrowserHistoryViewConstructor\n} from '../../../internals/Constructors/Views/BrowserHistoryViewConstructor.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the BrowserHistoryView constructor.\n *\n * @returns The BrowserHistoryView constructor.\n * @public\n */\nexport function getBrowserHistoryViewConstructor(app: App): BrowserHistoryViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.BrowserHistory) as BrowserHistoryViewConstructor;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type { BrowserViewConstructor } from '../../../internals/Constructors/Views/BrowserViewConstructor.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the BrowserView constructor.\n *\n * @returns The BrowserView constructor.\n * @public\n */\nexport function getBrowserViewConstructor(app: App): BrowserViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.Browser) as BrowserViewConstructor;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type { CanvasViewConstructor } from '../../../internals/Constructors/Views/CanvasViewConstructor.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the CanvasView constructor.\n *\n * @returns The CanvasView constructor.\n * @public\n */\nexport function getCanvasViewConstructor(app: App): CanvasViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.Canvas) as CanvasViewConstructor;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { EmptyView } from '../../../internals/Views/EmptyView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the EmptyView constructor.\n *\n * @returns The EmptyView constructor.\n * @public\n */\nexport function getEmptyViewConstructor(app: App): TypedViewConstructor<EmptyView> {\n    return getViewConstructorByViewType(app, ViewType.Empty) as TypedViewConstructor<EmptyView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { FileExplorerView } from '../../../internals/InternalPlugins/FileExplorer/FileExplorerView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the FileExplorerView constructor.\n *\n * @returns The FileExplorerView constructor.\n * @public\n */\nexport function getFileExplorerViewConstructor(app: App): TypedViewConstructor<FileExplorerView> {\n    return getViewConstructorByViewType(app, ViewType.FileExplorer) as TypedViewConstructor<FileExplorerView>;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type {\n    FilePropertiesViewConstructor\n} from '../../../internals/Constructors/Views/FilePropertiesViewConstructor.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the FilePropertiesView constructor.\n *\n * @returns The FilePropertiesView constructor.\n * @public\n */\nexport function getFilePropertiesViewConstructor(app: App): FilePropertiesViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.FileProperties) as FilePropertiesViewConstructor;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { GraphView } from '../../../internals/InternalPlugins/Graph/GraphView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the GraphView constructor.\n *\n * @returns The GraphView constructor.\n * @public\n */\nexport function getGraphViewConstructor(app: App): TypedViewConstructor<GraphView> {\n    return getViewConstructorByViewType(app, ViewType.Graph) as TypedViewConstructor<GraphView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { ImageView } from '../../../internals/Views/ImageView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the ImageView constructor.\n *\n * @returns The ImageView constructor.\n * @public\n */\nexport function getImageViewConstructor(app: App): TypedViewConstructor<ImageView> {\n    return getViewConstructorByViewType(app, ViewType.Image) as TypedViewConstructor<ImageView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { LocalGraphView } from '../../../internals/InternalPlugins/Graph/LocalGraphView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the LocalGraphView constructor.\n *\n * @returns The LocalGraphView constructor.\n * @public\n */\nexport function getLocalGraphViewConstructor(app: App): TypedViewConstructor<LocalGraphView> {\n    return getViewConstructorByViewType(app, ViewType.LocalGraph) as TypedViewConstructor<LocalGraphView>;\n}\n", "import type {\n    App,\n    MarkdownView\n} from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the MarkdownView constructor.\n *\n * @returns The MarkdownView constructor.\n * @public\n */\nexport function getMarkdownViewConstructor(app: App): TypedViewConstructor<MarkdownView> {\n    return getViewConstructorByViewType(app, ViewType.Markdown) as TypedViewConstructor<MarkdownView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { OutgoingLinkView } from '../../../internals/InternalPlugins/OutgoingLink/OutgoingLinkView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the OutgoingLinkView constructor.\n *\n * @returns The OutgoingLinkView constructor.\n * @public\n */\nexport function getOutgoingLinkViewConstructor(app: App): TypedViewConstructor<OutgoingLinkView> {\n    return getViewConstructorByViewType(app, ViewType.OutgoingLink) as TypedViewConstructor<OutgoingLinkView>;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type { OutlineViewConstructor } from '../../../internals/Constructors/Views/OutlineViewConstructor.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the OutlineView constructor.\n *\n * @returns The OutlineView constructor.\n * @public\n */\nexport function getOutlineViewConstructor(app: App): OutlineViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.Outline) as OutlineViewConstructor;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { PdfView } from '../../../internals/Views/PdfView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the PdfView constructor.\n *\n * @returns The PdfView constructor.\n * @public\n */\nexport function getPdfViewConstructor(app: App): TypedViewConstructor<PdfView> {\n    return getViewConstructorByViewType(app, ViewType.Pdf) as TypedViewConstructor<PdfView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { ReleaseNotesView } from '../../../internals/Views/ReleaseNotesView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the ReleaseNotesView constructor.\n *\n * @returns The ReleaseNotesView constructor.\n * @public\n */\nexport function getReleaseNotesViewConstructor(app: App): TypedViewConstructor<ReleaseNotesView> {\n    return getViewConstructorByViewType(app, ViewType.ReleaseNotes) as TypedViewConstructor<ReleaseNotesView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { SearchView } from '../../../internals/InternalPlugins/GlobalSearch/SearchView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the SearchView constructor.\n *\n * @returns The SearchView constructor.\n * @public\n */\nexport function getSearchViewConstructor(app: App): TypedViewConstructor<SearchView> {\n    return getViewConstructorByViewType(app, ViewType.Search) as TypedViewConstructor<SearchView>;\n}\n", "import type {\n    App\n} from 'obsidian';\nimport type { SyncViewConstructor } from '../../../internals/Constructors/Views/SyncViewConstructor.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the SyncView constructor.\n *\n * @returns The SyncView constructor.\n * @public\n */\nexport function getSyncViewConstructor(app: App): SyncViewConstructor {\n    return getViewConstructorByViewType(app, ViewType.Sync) as SyncViewConstructor;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { TagView } from '../../../internals/Views/TagView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the TagView constructor.\n *\n * @returns The TagView constructor.\n * @public\n */\nexport function getTagViewConstructor(app: App): TypedViewConstructor<TagView> {\n    return getViewConstructorByViewType(app, ViewType.Tag) as TypedViewConstructor<TagView>;\n}\n", "import type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { VideoView } from '../../../internals/Views/VideoView.d.ts';\nimport { ViewType } from '../../Constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the VideoView constructor.\n *\n * @returns The VideoView constructor.\n * @public\n */\nexport function getVideoViewConstructor(app: App): TypedViewConstructor<VideoView> {\n    return getViewConstructorByViewType(app, ViewType.Video) as TypedViewConstructor<VideoView>;\n}\n", "import {\n    type App,\n    TFile\n} from 'obsidian';\nimport { getTFileConstructor } from '../Constructors/getTFileConstructor.ts';\nimport { parentFolderPath } from '../Utils/PathUtils.ts';\nimport { createTFolderInstance } from './createTFolderInstance.ts';\n\n/**\n * Creates and properly initializes the instance of TFile even the underlying file does not exist.\n * This doesn't create the missing file on the file system.\n * @public\n */\nexport function createTFileInstance(app: App, path: string): TFile {\n    let file = app.vault.getFileByPath(path);\n    if (file) {\n        return file;\n    }\n\n    file = new (getTFileConstructor())(app.vault, path);\n    file.parent = createTFolderInstance(app, parentFolderPath(path));\n    file.deleted = true;\n    return file;\n}\n", "/**\n * Get the parent folder path of a given path.\n *\n * @param path - The path to get the parent folder path of.\n * @returns The parent folder path.\n * @public\n */\nexport function parentFolderPath(path: string): string {\n    return path.replace(/\\/?[^\\/]*$/, '') || '/';\n}\n", "import {\n    type App,\n    TFolder\n} from 'obsidian';\nimport { getTFolderConstructor } from '../Constructors/getTFolderConstructor.ts';\nimport { parentFolderPath } from '../Utils/PathUtils.ts';\n\n/**\n * Creates and properly initializes the instance of TFolder even the underlying folder does not exist.\n * This doesn't create the missing folder on the file system.\n * @public\n */\nexport function createTFolderInstance(app: App, path: string): TFolder {\n    let folder = app.vault.getFolderByPath(path);\n    if (folder) {\n        return folder;\n    }\n\n    folder = new (getTFolderConstructor())(app.vault, path);\n    folder.parent = createTFolderInstance(app, parentFolderPath(path));\n    folder.deleted = true;\n    return folder;\n}\n", "import type {\n    Reference,\n    ReferenceCache\n} from 'obsidian';\n\n/**\n * Check if the reference is a reference cache.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a reference cache.\n * @public\n */\nexport function isReferenceCache(reference: Reference): reference is ReferenceCache {\n    return !!(reference as Partial<ReferenceCache>).position;\n}\n", "import type {\n    EmbedCache,\n    Reference\n} from 'obsidian';\nimport { isReferenceCache } from './isReferenceCache.ts';\n\n/**\n * Check if the reference is an embed cache.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is an embed cache.\n * @public\n */\nexport function isEmbedCache(reference: Reference): reference is EmbedCache {\n    return isReferenceCache(reference) && reference.original[0] === '!';\n}\n", "import type {\n    FrontmatterLinkCache,\n    Reference\n} from 'obsidian';\n\n/**\n * Check if the reference is a frontmatter link cache.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a frontmatter link cache.\n * @public\n */\nexport function isFrontmatterLinkCache(reference: Reference): reference is FrontmatterLinkCache {\n    return !!(reference as Partial<FrontmatterLinkCache>).key;\n}\n", "import type {\n    LinkCache,\n    Reference\n} from 'obsidian';\nimport { isReferenceCache } from './isReferenceCache.ts';\n\n/**\n * Check if the reference is a link cache.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a link cache.\n * @public\n */\nexport function isLinkCache(reference: Reference): reference is LinkCache {\n    return isReferenceCache(reference) && reference.original[0] !== '!';\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACGO,IAAM,sBAAN,MAA2D;AAAA,EACvD,OAAyB,oBAAI,IAAI;AAAA,EAEjC,IAAI,KAAa,OAAgB;AACpC,QAAI,SAAS,KAAK,IAAI,GAAG;AACzB,QAAI,CAAC,QAAQ;AACT,eAAS,CAAC;AACV,WAAK,KAAK,IAAI,KAAK,MAAM;AAAA,IAC7B;AAEA,QAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AACzB,aAAO,KAAK,KAAK;AAAA,IACrB;AAAA,EACJ;AAAA,EAEO,OAAO,KAAa,OAAgB;AACvC,UAAM,SAAS,KAAK,IAAI,GAAG;AAC3B,QAAI,CAAC,QAAQ;AACT;AAAA,IACJ;AACA,WAAO,OAAO,KAAK;AAEnB,QAAI,OAAO,WAAW,GAAG;AACrB,WAAK,MAAM,GAAG;AAAA,IAClB;AAAA,EACJ;AAAA,EAEO,IAAI,KAAyB;AAChC,WAAO,KAAK,KAAK,IAAI,GAAG,KAAK;AAAA,EACjC;AAAA,EAEO,OAAiB;AACpB,WAAO,MAAM,KAAK,KAAK,KAAK,KAAK,CAAC;AAAA,EACtC;AAAA,EAEO,MAAM,KAAmB;AAC5B,SAAK,KAAK,OAAO,GAAG;AAAA,EACxB;AAAA,EAEO,WAAiB;AACpB,SAAK,KAAK,MAAM;AAAA,EACpB;AAAA,EAEO,SAAS,KAAa,OAAmB;AAC5C,WAAO,CAAC,CAAC,KAAK,IAAI,GAAG,GAAG,SAAS,KAAK;AAAA,EAC1C;AAAA,EAEO,QAAgB;AACnB,QAAI,MAAM;AACV,eAAW,OAAO,KAAK,KAAK,GAAG;AAC3B,aAAO,KAAK,IAAI,GAAG,GAAG,UAAU;AAAA,IACpC;AAEA,WAAO;AAAA,EACX;AACJ;;;ACzDO,IAAM,gBAAgB;AAAA,EACzB,MAAM;AAAA,EACN,MAAM;AAAA,EACN,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,KAAK;AAAA,EACL,MAAM;AAAA,EACN,MAAM;AACV;;;ACzBO,IAAM,qBAAqB;AAAA;AAAA;AAAA;AAAA,EAI9B,eAAe;AAAA;AAAA;AAAA;AAAA,EAIf,UAAU;AAAA;AAAA;AAAA;AAAA,EAIV,WAAW;AAAA;AAAA;AAAA;AAAA,EAIX,SAAS;AAAA;AAAA;AAAA;AAAA,EAIT,QAAQ;AAAA;AAAA;AAAA;AAAA,EAIR,gBAAgB;AAAA;AAAA;AAAA;AAAA,EAIhB,YAAY;AAAA;AAAA;AAAA;AAAA,EAIZ,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,OAAO;AAAA;AAAA;AAAA;AAAA,EAIP,kBAAkB;AAAA;AAAA;AAAA;AAAA,EAIlB,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,SAAS;AAAA;AAAA;AAAA;AAAA,EAIT,aAAa;AAAA;AAAA;AAAA;AAAA,EAIb,YAAY;AAAA;AAAA;AAAA;AAAA,EAIZ,SAAS;AAAA;AAAA;AAAA;AAAA,EAIT,YAAY;AAAA;AAAA;AAAA;AAAA,EAIZ,cAAc;AAAA;AAAA;AAAA;AAAA,EAId,QAAQ;AAAA;AAAA;AAAA;AAAA,EAIR,UAAU;AAAA;AAAA;AAAA;AAAA,EAIV,MAAM;AAAA;AAAA;AAAA;AAAA,EAIN,SAAS;AAAA;AAAA;AAAA;AAAA,EAIT,WAAW;AAAA;AAAA;AAAA;AAAA,EAIX,WAAW;AAAA;AAAA;AAAA;AAAA,EAIX,YAAY;AAAA;AAAA;AAAA;AAAA,EAIZ,YAAY;AAChB;;;ACnHO,IAAM,WAAW;AAAA,EACpB,eAAe;AAAA,EACf,OAAO;AAAA,EACP,UAAU,mBAAmB;AAAA,EAC7B,WAAW,mBAAmB;AAAA,EAC9B,SAAS;AAAA,EACT,gBAAgB;AAAA,EAChB,QAAQ,mBAAmB;AAAA,EAC3B,OAAO;AAAA,EACP,cAAc,mBAAmB;AAAA,EACjC,gBAAgB;AAAA,EAChB,OAAO,mBAAmB;AAAA,EAC1B,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,cAAc,mBAAmB;AAAA,EACjC,SAAS,mBAAmB;AAAA,EAC5B,KAAK;AAAA,EACL,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,KAAK;AAAA,EACL,OAAO;AACX;;;AC1BA,sBAEO;AASA,SAAS,oBAAoC;AAChD,SAAO;AACX;;;ACHO,SAAS,6BAAuC,KAA+C;AAClG,QAAM,YAAY,OAAO,OAAO,IAAI,gBAAgB,OAAO,EAAE,CAAC;AAC9D,MAAI,CAAC,WAAW;AACZ,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC9C;AACA,SAAO,UAAU;AACrB;;;ACNO,SAAS,8BAA8B,KAAsC;AAChF,SAAO,IAAI,gBAAgB;AAC/B;;;ACZA,IAAAA,mBAEO;AASA,SAAS,sBAAwC;AACpD,SAAO;AACX;;;ACbA,IAAAC,mBAEO;AASA,SAAS,wBAA4C;AACxD,SAAO;AACX;;;ACCO,SAAS,6BACZ,KACA,UACkB;AAClB,QAAM,OAAO,IAAI,UAAU,qBAAqB;AAChD,MAAI;AACA,UAAM,cAAc,IAAI,aAAa,qBAAqB,QAAQ;AAClE,QAAI,CAAC,aAAa;AACd,YAAM,IAAI,MAAM,wBAAwB;AAAA,IAC5C;AACA,UAAM,OAAO,YAAY,IAAI;AAC7B,WAAO,KAAK;AAAA,EAChB,UAAE;AACE,SAAK,OAAO;AAAA,EAChB;AACJ;;;ACjBO,SAAS,gCAAgC,KAAmD;AAC/F,SAAO,6BAA6B,KAAK,SAAS,aAAa;AACnE;;;ACFO,SAAS,wBAAwB,KAA2C;AAC/E,SAAO,6BAA6B,KAAK,SAAS,KAAK;AAC3D;;;ACFO,SAAS,2BAA2B,KAA8C;AACrF,SAAO,6BAA6B,KAAK,SAAS,QAAQ;AAC9D;;;ACDO,SAAS,4BAA4B,KAAoC;AAC5E,SAAO,6BAA6B,KAAK,SAAS,SAAS;AAC/D;;;ACAO,SAAS,iCAAiC,KAAyC;AACtF,SAAO,6BAA6B,KAAK,SAAS,cAAc;AACpE;;;ACJO,SAAS,0BAA0B,KAAkC;AACxE,SAAO,6BAA6B,KAAK,SAAS,OAAO;AAC7D;;;ACFO,SAAS,yBAAyB,KAAiC;AACtE,SAAO,6BAA6B,KAAK,SAAS,MAAM;AAC5D;;;ACHO,SAAS,wBAAwB,KAA2C;AAC/E,SAAO,6BAA6B,KAAK,SAAS,KAAK;AAC3D;;;ACFO,SAAS,+BAA+B,KAAkD;AAC7F,SAAO,6BAA6B,KAAK,SAAS,YAAY;AAClE;;;ACCO,SAAS,iCAAiC,KAAyC;AACtF,SAAO,6BAA6B,KAAK,SAAS,cAAc;AACpE;;;ACLO,SAAS,wBAAwB,KAA2C;AAC/E,SAAO,6BAA6B,KAAK,SAAS,KAAK;AAC3D;;;ACFO,SAAS,wBAAwB,KAA2C;AAC/E,SAAO,6BAA6B,KAAK,SAAS,KAAK;AAC3D;;;ACFO,SAAS,6BAA6B,KAAgD;AACzF,SAAO,6BAA6B,KAAK,SAAS,UAAU;AAChE;;;ACAO,SAAS,2BAA2B,KAA8C;AACrF,SAAO,6BAA6B,KAAK,SAAS,QAAQ;AAC9D;;;ACJO,SAAS,+BAA+B,KAAkD;AAC7F,SAAO,6BAA6B,KAAK,SAAS,YAAY;AAClE;;;ACDO,SAAS,0BAA0B,KAAkC;AACxE,SAAO,6BAA6B,KAAK,SAAS,OAAO;AAC7D;;;ACHO,SAAS,sBAAsB,KAAyC;AAC3E,SAAO,6BAA6B,KAAK,SAAS,GAAG;AACzD;;;ACFO,SAAS,+BAA+B,KAAkD;AAC7F,SAAO,6BAA6B,KAAK,SAAS,YAAY;AAClE;;;ACFO,SAAS,yBAAyB,KAA4C;AACjF,SAAO,6BAA6B,KAAK,SAAS,MAAM;AAC5D;;;ACDO,SAAS,uBAAuB,KAA+B;AAClE,SAAO,6BAA6B,KAAK,SAAS,IAAI;AAC1D;;;ACHO,SAAS,sBAAsB,KAAyC;AAC3E,SAAO,6BAA6B,KAAK,SAAS,GAAG;AACzD;;;ACFO,SAAS,wBAAwB,KAA2C;AAC/E,SAAO,6BAA6B,KAAK,SAAS,KAAK;AAC3D;;;ACdA,IAAAC,mBAGO;;;ACIA,SAAS,iBAAiB,MAAsB;AACnD,SAAO,KAAK,QAAQ,cAAc,EAAE,KAAK;AAC7C;;;ACTA,IAAAC,mBAGO;AASA,SAAS,sBAAsB,KAAU,MAAuB;AACnE,MAAI,SAAS,IAAI,MAAM,gBAAgB,IAAI;AAC3C,MAAI,QAAQ;AACR,WAAO;AAAA,EACX;AAEA,WAAS,KAAK,sBAAsB,GAAG,IAAI,OAAO,IAAI;AACtD,SAAO,SAAS,sBAAsB,KAAK,iBAAiB,IAAI,CAAC;AACjE,SAAO,UAAU;AACjB,SAAO;AACX;;;AFTO,SAAS,oBAAoB,KAAU,MAAqB;AAC/D,MAAI,OAAO,IAAI,MAAM,cAAc,IAAI;AACvC,MAAI,MAAM;AACN,WAAO;AAAA,EACX;AAEA,SAAO,KAAK,oBAAoB,GAAG,IAAI,OAAO,IAAI;AAClD,OAAK,SAAS,sBAAsB,KAAK,iBAAiB,IAAI,CAAC;AAC/D,OAAK,UAAU;AACf,SAAO;AACX;;;AGXO,SAAS,iBAAiB,WAAmD;AAChF,SAAO,CAAC,CAAE,UAAsC;AACpD;;;ACDO,SAAS,aAAa,WAA+C;AACxE,SAAO,iBAAiB,SAAS,KAAK,UAAU,SAAS,CAAC,MAAM;AACpE;;;ACHO,SAAS,uBAAuB,WAAyD;AAC5F,SAAO,CAAC,CAAE,UAA4C;AAC1D;;;ACDO,SAAS,YAAY,WAA8C;AACtE,SAAO,iBAAiB,SAAS,KAAK,UAAU,SAAS,CAAC,MAAM;AACpE;",
  "names": ["import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian"]
}


package/dist/esm/implementations.d.mts

@@ -0,0 +1 @@
+export * from '../cjs/implementations.cjs';