obsidian-typings 2.4.0 → 2.6.0

package/dist/implementations.cjs

@@ -25,14 +25,39 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var implementations_exports = {};
 __export(implementations_exports, {
   CustomArrayDictImpl: () => CustomArrayDictImpl,
+  FileExtension: () => FileExtension,
   InternalPluginName: () => InternalPluginName,
-  constructApp: () => constructApp,
-  constructInternalPlugin: () => constructInternalPlugin,
-  constructInternalPlugins: () => constructInternalPlugins,
-  constructTFile: () => constructTFile,
-  constructTFolder: () => constructTFolder,
+  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,
@@ -41,6 +66,47 @@ __export(implementations_exports, {
 });
 module.exports = __toCommonJS(implementations_exports);
 
+// src/obsidian/implementations/Constructors/getTFolderConstructor.ts
+var import_obsidian = require("obsidian");
+function getTFolderConstructor() {
+  return import_obsidian.TFolder;
+}
+
+// src/obsidian/implementations/Utils/PathUtils.ts
+function parentFolderPath(path) {
+  return path.replace(/\/?[^\/]*$/, "") || "/";
+}
+
+// src/obsidian/implementations/Functions/createTFolderInstance.ts
+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/Constructors/getTFileConstructor.ts
+var import_obsidian2 = require("obsidian");
+function getTFileConstructor() {
+  return import_obsidian2.TFile;
+}
+
+// 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;
@@ -61,56 +127,7 @@ function isLinkCache(reference) {
   return isReferenceCache(reference) && reference.original[0] !== "!";
 }
 
-// src/obsidian/implementations/Constructors/constructTFolder.ts
-var import_obsidian = require("obsidian");
-function constructTFolder(vault, path) {
-  return new import_obsidian.TFolder(vault, path);
-}
-
-// src/obsidian/implementations/Constructors/constructInternalPlugins.ts
-function constructInternalPlugins(app) {
-  return new app.internalPlugins.constructor(app);
-}
-
-// src/obsidian/implementations/Constructors/constructInternalPlugin.ts
-function constructInternalPlugin(app, instance, internalPlugins) {
-  const anyPlugin = Object.values(app.internalPlugins.plugins)[0];
-  if (!anyPlugin) {
-    throw new Error("No internal plugin found");
-  }
-  return new anyPlugin.constructor(app, instance, internalPlugins);
-}
-
-// src/obsidian/implementations/Constructors/constructApp.ts
-var import_obsidian2 = require("obsidian");
-function constructApp(adapter, appId) {
-  return new import_obsidian2.App(adapter, appId);
-}
-
-// src/obsidian/implementations/Constructors/constructTFile.ts
-var import_obsidian3 = require("obsidian");
-function constructTFile(vault, path) {
-  return new import_obsidian3.TFile(vault, path);
-}
-
-// src/obsidian/implementations/PathUtils.ts
-function parentFolderPath(path) {
-  return path.replace(/\/?[^\/]*$/, "") || "/";
-}
-
-// src/obsidian/implementations/createTFolderInstance.ts
-function createTFolderInstance(vault, path) {
-  let folder = vault.getFolderByPath(path);
-  if (folder) {
-    return folder;
-  }
-  folder = constructTFolder(vault, path);
-  folder.parent = createTFolderInstance(vault, parentFolderPath(path));
-  folder.deleted = true;
-  return folder;
-}
-
-// src/obsidian/implementations/CustomArrayDictImpl.ts
+// src/obsidian/implementations/Classes/CustomArrayDictImpl.ts
 var CustomArrayDictImpl = class {
   data = /* @__PURE__ */ new Map();
   add(key, value) {
@@ -157,47 +174,323 @@ var CustomArrayDictImpl = class {
   }
 };
 
-// src/obsidian/implementations/InternalPluginName.ts
+// 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
+   * @remark Currently disabled
+   */
+  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/createTFileInstance.ts
-function createTFileInstance(vault, path) {
-  let file = vault.getFileByPath(path);
-  if (file) {
-    return file;
+// 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/getInternalPluginConstructor.ts
+function getInternalPluginConstructor(app) {
+  const anyPlugin = Object.values(app.internalPlugins.plugins)[0];
+  if (!anyPlugin) {
+    throw new Error("No internal plugin found");
   }
-  file = constructTFile(vault, path);
-  file.parent = createTFolderInstance(vault, parentFolderPath(path));
-  file.deleted = true;
-  return file;
+  return anyPlugin.constructor;
+}
+
+// src/obsidian/implementations/Constructors/getInternalPluginsConstructor.ts
+function getInternalPluginsConstructor(app) {
+  return app.internalPlugins.constructor;
+}
+
+// src/obsidian/implementations/Constructors/getAppConstructor.ts
+var import_obsidian3 = require("obsidian");
+function getAppConstructor() {
+  return import_obsidian3.App;
+}
+
+// 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/getOutlineViewConstructor.ts
+function getOutlineViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Outline);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBrowserViewConstructor.ts
+function getBrowserViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Browser);
+}
+
+// src/obsidian/implementations/Constructors/Views/getReleaseNotesViewConstructor.ts
+function getReleaseNotesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.ReleaseNotes);
+}
+
+// src/obsidian/implementations/Constructors/Views/getPdfViewConstructor.ts
+function getPdfViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Pdf);
+}
+
+// src/obsidian/implementations/Constructors/Views/getSyncViewConstructor.ts
+function getSyncViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Sync);
+}
+
+// src/obsidian/implementations/Constructors/Views/getOutgoingLinkViewConstructor.ts
+function getOutgoingLinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.OutgoingLink);
+}
+
+// src/obsidian/implementations/Constructors/Views/getCanvasViewConstructor.ts
+function getCanvasViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Canvas);
+}
+
+// src/obsidian/implementations/Constructors/Views/getTagViewConstructor.ts
+function getTagViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Tag);
+}
+
+// src/obsidian/implementations/Constructors/Views/getAudioViewConstructor.ts
+function getAudioViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Audio);
+}
+
+// src/obsidian/implementations/Constructors/Views/getLocalGraphViewConstructor.ts
+function getLocalGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.LocalGraph);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBacklinkViewConstructor.ts
+function getBacklinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Backlink);
+}
+
+// src/obsidian/implementations/Constructors/Views/getFileExplorerViewConstructor.ts
+function getFileExplorerViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileExplorer);
+}
+
+// src/obsidian/implementations/Constructors/Views/getSearchViewConstructor.ts
+function getSearchViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Search);
+}
+
+// src/obsidian/implementations/Constructors/Views/getVideoViewConstructor.ts
+function getVideoViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Video);
+}
+
+// src/obsidian/implementations/Constructors/Views/getImageViewConstructor.ts
+function getImageViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Image);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBrowserHistoryViewConstructor.ts
+function getBrowserHistoryViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.BrowserHistory);
+}
+
+// src/obsidian/implementations/Constructors/Views/getEmptyViewConstructor.ts
+function getEmptyViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Empty);
+}
+
+// src/obsidian/implementations/Constructors/Views/getGraphViewConstructor.ts
+function getGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Graph);
+}
+
+// src/obsidian/implementations/Constructors/Views/getFilePropertiesViewConstructor.ts
+function getFilePropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileProperties);
+}
+
+// src/obsidian/implementations/Constructors/Views/getBookmarksViewConstructor.ts
+function getBookmarksViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Bookmarks);
+}
+
+// src/obsidian/implementations/Constructors/Views/getMarkdownViewConstructor.ts
+function getMarkdownViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Markdown);
+}
+
+// src/obsidian/implementations/Constructors/Views/getAllPropertiesViewConstructor.ts
+function getAllPropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.AllProperties);
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/obsidian/implementations/index.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", "../src/obsidian/implementations/Constructors/constructTFolder.ts", "../src/obsidian/implementations/Constructors/constructInternalPlugins.ts", "../src/obsidian/implementations/Constructors/constructInternalPlugin.ts", "../src/obsidian/implementations/Constructors/constructApp.ts", "../src/obsidian/implementations/Constructors/constructTFile.ts", "../src/obsidian/implementations/PathUtils.ts", "../src/obsidian/implementations/createTFolderInstance.ts", "../src/obsidian/implementations/CustomArrayDictImpl.ts", "../src/obsidian/implementations/InternalPluginName.ts", "../src/obsidian/implementations/createTFileInstance.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * from './TypeGuards/isEmbedCache.js';\nexport * from './TypeGuards/isFrontmatterLinkCache.js';\nexport * from './TypeGuards/isReferenceCache.js';\nexport * from './TypeGuards/isLinkCache.js';\nexport * from './Constructors/constructTFolder.js';\nexport * from './Constructors/constructInternalPlugins.js';\nexport * from './Constructors/constructInternalPlugin.js';\nexport * from './Constructors/constructApp.js';\nexport * from './Constructors/constructTFile.js';\nexport * from './PathUtils.js';\nexport * from './createTFolderInstance.js';\nexport * from './CustomArrayDictImpl.js';\nexport * from './InternalPluginName.js';\nexport * from './createTFileInstance.js';\nimport '../../index.js';\n", "import type {\n    Reference,\n    ReferenceCache\n} from 'obsidian';\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\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\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\nexport function isLinkCache(reference: Reference): reference is LinkCache {\n    return isReferenceCache(reference) && reference.original[0] !== '!';\n}\n", "import {\n    TFolder,\n    type Vault\n} from 'obsidian';\n\ntype TFolderConstructor = new(vault: Vault, path: string) => TFolder;\n\n/**\n * Constructs a new TFolder instance.\n *\n * @param vault - The vault to which the folder belongs.\n * @param path - The path of the folder.\n * @returns The constructed TFolder instance.\n */\nexport function constructTFolder(vault: Vault, path: string): TFolder {\n    return new (TFolder as TFolderConstructor)(vault, path);\n}\n", "import type { App } from 'obsidian';\nimport type { InternalPlugins } from '../../internals/InternalPlugin/InternalPlugins.js';\n\ntype InternalPluginsConstructor = new(app: App) => InternalPlugins;\n\n/**\n * Constructs a new InternalPlugins instance.\n *\n * @param app - The app instance.\n * @returns The constructed InternalPlugins instance.\n */\nexport function constructInternalPlugins(app: App): InternalPlugins {\n    return new (app.internalPlugins.constructor as InternalPluginsConstructor)(app);\n}\n", "import type { App } from 'obsidian';\nimport type { InternalPlugin } from '../../internals/InternalPlugin/InternalPlugin.js';\nimport type { InternalPlugins } from '../../internals/InternalPlugin/InternalPlugins.js';\n\ntype InternalPluginConstructor<Instance> = new(\n    app: App,\n    instance: Instance,\n    internalPlugins: InternalPlugins\n) => InternalPlugin<Instance>;\n\n/**\n * Constructs a new InternalPlugin instance.\n *\n * @param app - The app instance.\n * @param instance - The instance of the plugin.\n * @param internalPlugins - The internal plugins instance.\n * @returns The constructed InternalPlugin instance.\n */\nexport function constructInternalPlugin<Instance>(\n    app: App,\n    instance: Instance,\n    internalPlugins: InternalPlugins\n): InternalPlugin<Instance> {\n    const anyPlugin = Object.values(app.internalPlugins.plugins)[0];\n    if (!anyPlugin) {\n        throw new Error('No internal plugin found');\n    }\n    return new (anyPlugin.constructor as InternalPluginConstructor<Instance>)(app, instance, internalPlugins);\n}\n", "import {\n    App,\n    type DataAdapter\n} from 'obsidian';\n\ntype AppConstructor = new(adapter: DataAdapter, appId: string) => App;\n\n/**\n * Constructs a new App instance.\n *\n * @param adapter - The data adapter to use.\n * @param appId - The ID of the app.\n * @returns The constructed App instance.\n */\nexport function constructApp(adapter: DataAdapter, appId: string): App {\n    return new (App as AppConstructor)(adapter, appId);\n}\n", "import {\n    TFile,\n    type Vault\n} from 'obsidian';\n\ntype TFileConstructor = new(vault: Vault, path: string) => TFile;\n\n/**\n * Constructs a new TFile instance.\n *\n * @param vault - The vault to which the file belongs.\n * @param path - The path of the file.\n * @returns The constructed TFile instance.\n */\nexport function constructTFile(vault: Vault, path: string): TFile {\n    return new (TFile as TFileConstructor)(vault, path);\n}\n", "export function parentFolderPath(path: string): string {\n    return path.replace(/\\/?[^\\/]*$/, '') || '/';\n}\n", "import {\n    TFolder,\n    type Vault\n} from 'obsidian';\nimport { constructTFolder } from './Constructors/constructTFolder.ts';\nimport { parentFolderPath } from './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 */\nexport function createTFolderInstance(vault: Vault, path: string): TFolder {\n    let folder = vault.getFolderByPath(path);\n    if (folder) {\n        return folder;\n    }\n\n    folder = constructTFolder(vault, path);\n    folder.parent = createTFolderInstance(vault, parentFolderPath(path));\n    folder.deleted = true;\n    return folder;\n}\n", "import type { CustomArrayDict } from '../internals/CustomArrayDict.js';\n\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", "export const InternalPluginName = {\n    AudioRecorder: 'audio-recorder',\n    Backlink: 'backlink',\n    Bookmarks: 'bookmarks',\n    Canvas: 'canvas',\n    CommandPalette: 'command-palette',\n    DailyNotes: 'daily-notes',\n    EditorStatus: 'editor-status',\n    FileExplorer: 'file-explorer',\n    FileRecovery: 'file-recovery',\n    GlobalSearch: 'global-search',\n    Graph: 'graph',\n    MarkdownImporter: 'markdown-importer',\n    NoteComposer: 'note-composer',\n    OutgoingLink: 'outgoing-link',\n    Outline: 'outline',\n    PagePreview: 'page-preview',\n    Properties: 'properties',\n    Publish: 'publish',\n    RandomNote: 'random-note',\n    SlashCommand: 'slash-command',\n    Slides: 'slides',\n    Switcher: 'switcher',\n    Sync: 'sync',\n    TagPane: 'tag-pane',\n    Templates: 'templates',\n    WordCount: 'word-count',\n    Workspaces: 'workspaces',\n    ZkPrefixer: 'zk-prefixer'\n} as const;\n", "import {\n    TFile,\n    type Vault\n} from 'obsidian';\nimport { constructTFile } from './Constructors/constructTFile.ts';\nimport { createTFolderInstance } from './createTFolderInstance.ts';\nimport { parentFolderPath } from './PathUtils.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 */\nexport function createTFileInstance(vault: Vault, path: string): TFile {\n    let file = vault.getFileByPath(path);\n    if (file) {\n        return file;\n    }\n\n    file = constructTFile(vault, path);\n    file.parent = createTFolderInstance(vault, parentFolderPath(path));\n    file.deleted = true;\n    return file;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKO,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;;;ACRA,sBAGO;AAWA,SAAS,iBAAiB,OAAc,MAAuB;AAClE,SAAO,IAAK,wBAA+B,OAAO,IAAI;AAC1D;;;ACLO,SAAS,yBAAyB,KAA2B;AAChE,SAAO,IAAK,IAAI,gBAAgB,YAA2C,GAAG;AAClF;;;ACKO,SAAS,wBACZ,KACA,UACA,iBACwB;AACxB,QAAM,YAAY,OAAO,OAAO,IAAI,gBAAgB,OAAO,EAAE,CAAC;AAC9D,MAAI,CAAC,WAAW;AACZ,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC9C;AACA,SAAO,IAAK,UAAU,YAAoD,KAAK,UAAU,eAAe;AAC5G;;;AC5BA,IAAAA,mBAGO;AAWA,SAAS,aAAa,SAAsB,OAAoB;AACnE,SAAO,IAAK,qBAAuB,SAAS,KAAK;AACrD;;;AChBA,IAAAC,mBAGO;AAWA,SAAS,eAAe,OAAc,MAAqB;AAC9D,SAAO,IAAK,uBAA2B,OAAO,IAAI;AACtD;;;AChBO,SAAS,iBAAiB,MAAsB;AACnD,SAAO,KAAK,QAAQ,cAAc,EAAE,KAAK;AAC7C;;;ACSO,SAAS,sBAAsB,OAAc,MAAuB;AACvE,MAAI,SAAS,MAAM,gBAAgB,IAAI;AACvC,MAAI,QAAQ;AACR,WAAO;AAAA,EACX;AAEA,WAAS,iBAAiB,OAAO,IAAI;AACrC,SAAO,SAAS,sBAAsB,OAAO,iBAAiB,IAAI,CAAC;AACnE,SAAO,UAAU;AACjB,SAAO;AACX;;;ACnBO,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,qBAAqB;AAAA,EAC9B,eAAe;AAAA,EACf,UAAU;AAAA,EACV,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,OAAO;AAAA,EACP,kBAAkB;AAAA,EAClB,cAAc;AAAA,EACd,cAAc;AAAA,EACd,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,MAAM;AAAA,EACN,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,YAAY;AAChB;;;ACjBO,SAAS,oBAAoB,OAAc,MAAqB;AACnE,MAAI,OAAO,MAAM,cAAc,IAAI;AACnC,MAAI,MAAM;AACN,WAAO;AAAA,EACX;AAEA,SAAO,eAAe,OAAO,IAAI;AACjC,OAAK,SAAS,sBAAsB,OAAO,iBAAiB,IAAI,CAAC;AACjE,OAAK,UAAU;AACf,SAAO;AACX;",
  "names": ["import_obsidian", "import_obsidian"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/obsidian/implementations/index.ts", "../src/obsidian/implementations/Constructors/getTFolderConstructor.ts", "../src/obsidian/implementations/Utils/PathUtils.ts", "../src/obsidian/implementations/Functions/createTFolderInstance.ts", "../src/obsidian/implementations/Constructors/getTFileConstructor.ts", "../src/obsidian/implementations/Functions/createTFileInstance.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", "../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/getInternalPluginConstructor.ts", "../src/obsidian/implementations/Constructors/getInternalPluginsConstructor.ts", "../src/obsidian/implementations/Constructors/getAppConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getViewConstructorByViewType.ts", "../src/obsidian/implementations/Constructors/Views/getOutlineViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getBrowserViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getReleaseNotesViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getPdfViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getSyncViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getOutgoingLinkViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getCanvasViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getTagViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getAudioViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getLocalGraphViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getBacklinkViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getFileExplorerViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getSearchViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getVideoViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getImageViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getBrowserHistoryViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getEmptyViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getGraphViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getFilePropertiesViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getBookmarksViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getMarkdownViewConstructor.ts", "../src/obsidian/implementations/Constructors/Views/getAllPropertiesViewConstructor.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * from './Functions/createTFolderInstance.js';\nexport * from './Functions/createTFileInstance.js';\nexport * from './TypeGuards/isEmbedCache.js';\nexport * from './TypeGuards/isFrontmatterLinkCache.js';\nexport * from './TypeGuards/isReferenceCache.js';\nexport * from './TypeGuards/isLinkCache.js';\nexport * from './Utils/PathUtils.js';\nexport * from './Classes/CustomArrayDictImpl.js';\nexport * from './Constants/FileExtension.js';\nexport * from './Constants/ViewType.js';\nexport * from './Constants/InternalPluginName.js';\nexport * from './Constructors/getInternalPluginConstructor.js';\nexport * from './Constructors/getInternalPluginsConstructor.js';\nexport * from './Constructors/getTFolderConstructor.js';\nexport * from './Constructors/getAppConstructor.js';\nexport * from './Constructors/getTFileConstructor.js';\nexport * from './Constructors/Views/getOutlineViewConstructor.js';\nexport * from './Constructors/Views/getBrowserViewConstructor.js';\nexport * from './Constructors/Views/getReleaseNotesViewConstructor.js';\nexport * from './Constructors/Views/getPdfViewConstructor.js';\nexport * from './Constructors/Views/getViewConstructorByViewType.js';\nexport * from './Constructors/Views/getSyncViewConstructor.js';\nexport * from './Constructors/Views/getOutgoingLinkViewConstructor.js';\nexport * from './Constructors/Views/getCanvasViewConstructor.js';\nexport * from './Constructors/Views/getTagViewConstructor.js';\nexport * from './Constructors/Views/getAudioViewConstructor.js';\nexport * from './Constructors/Views/getLocalGraphViewConstructor.js';\nexport * from './Constructors/Views/getBacklinkViewConstructor.js';\nexport * from './Constructors/Views/getFileExplorerViewConstructor.js';\nexport * from './Constructors/Views/getSearchViewConstructor.js';\nexport * from './Constructors/Views/getVideoViewConstructor.js';\nexport * from './Constructors/Views/getImageViewConstructor.js';\nexport * from './Constructors/Views/getBrowserHistoryViewConstructor.js';\nexport * from './Constructors/Views/getEmptyViewConstructor.js';\nexport * from './Constructors/Views/getGraphViewConstructor.js';\nexport * from './Constructors/Views/getFilePropertiesViewConstructor.js';\nexport * from './Constructors/Views/getBookmarksViewConstructor.js';\nexport * from './Constructors/Views/getMarkdownViewConstructor.js';\nexport * from './Constructors/Views/getAllPropertiesViewConstructor.js';\nimport '../../index.js';\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", "/**\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.js';\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 {\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    type App,\n    TFile\n} from 'obsidian';\nimport { getTFileConstructor } from '../Constructors/getTFileConstructor.ts';\nimport { parentFolderPath } from '../Utils/PathUtils.js';\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", "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", "import type { CustomArrayDict } from '../../internals/CustomArrayDict.js';\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     * @remark Currently disabled\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.js';\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 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    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 {\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 {\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 {\n    App\n} from 'obsidian';\nimport type { BrowserViewConstructor } from '../../../internals/Constructors/Views/BrowserViewConstructor.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { ReleaseNotesView } from '../../../internals/Views/ReleaseNotesView.js';\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 { PdfView } from '../../../internals/Views/PdfView.js';\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 {\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 { OutgoingLinkView } from '../../../internals/InternalPlugins/OutgoingLink/OutgoingLinkView.js';\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 { CanvasViewConstructor } from '../../../internals/Constructors/Views/CanvasViewConstructor.js';\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 { TagView } from '../../../internals/Views/TagView.js';\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 { AudioView } from '../../../internals/Views/AudioView.js';\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 { LocalGraphView } from '../../../internals/InternalPlugins/Graph/LocalGraphView.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { BacklinkView } from '../../../internals/InternalPlugins/Backlink/BacklinkView.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { FileExplorerView } from '../../../internals/InternalPlugins/FileExplorer/FileExplorerView.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { SearchView } from '../../../internals/InternalPlugins/GlobalSearch/SearchView.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { VideoView } from '../../../internals/Views/VideoView.js';\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 type { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { ImageView } from '../../../internals/Views/ImageView.js';\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 {\n    App\n} from 'obsidian';\nimport type {\n    BrowserHistoryViewConstructor\n} from '../../../internals/Constructors/Views/BrowserHistoryViewConstructor.js';\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 { App } from 'obsidian';\nimport type { TypedViewConstructor } from '../../../internals/Constructors/Views/TypedViewConstructor.ts';\nimport type { EmptyView } from '../../../internals/Views/EmptyView.js';\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 { GraphView } from '../../../internals/InternalPlugins/Graph/GraphView.js';\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 {\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 {\n    App\n} from 'obsidian';\nimport type { BookmarksViewConstructor } from '../../../internals/Constructors/Views/BookmarksViewConstructor.js';\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    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 { AllPropertiesView } from '../../../internals/InternalPlugins/Properties/AllPropertiesView.js';\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"],
  "mappings": "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",
  "names": ["import_obsidian", "import_obsidian"]
}
