@obsidian-typings/obsidian-catalyst-1.13.2 1.1.0

package/dist/esm/implementations.mjs

@@ -0,0 +1,1379 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+*/
+
+
+// src/obsidian/implementations/classes/CustomArrayDictImpl.ts
+var CustomArrayDictImpl = class {
+  /**
+   * Internal map storing key-to-array mappings.
+   */
+  data = /* @__PURE__ */ new Map();
+  /**
+   * Add a value to the array associated with the given key.
+   *
+   * @param key - The key.
+   * @param value - The value to add.
+   */
+  add(key, value) {
+    let values = this.get(key);
+    if (!values) {
+      values = [];
+      this.data.set(key, values);
+    }
+    if (!values.includes(value)) {
+      values.push(value);
+    }
+  }
+  /**
+   * Remove all values for the given key.
+   *
+   * @param key - The key to clear.
+   */
+  clear(key) {
+    this.data.delete(key);
+  }
+  /**
+   * Remove all keys and their values.
+   */
+  clearAll() {
+    this.data.clear();
+  }
+  /**
+   * Check whether the array for the given key contains the specified value.
+   *
+   * @param key - The key.
+   * @param value - The value to check.
+   * @returns Whether the value exists.
+   */
+  contains(key, value) {
+    return !!this.get(key)?.contains(value);
+  }
+  /**
+   * Get the total number of values across all keys.
+   *
+   * @returns Total value count.
+   */
+  count() {
+    let ans = 0;
+    for (const key of this.keys()) {
+      ans += this.get(key)?.length ?? 0;
+    }
+    return ans;
+  }
+  /**
+   * Get the array of values for the given key, or `null` if not found.
+   *
+   * @param key - The key.
+   * @returns Array of values, or `null`.
+   */
+  get(key) {
+    return this.data.get(key) || null;
+  }
+  /**
+   * Get all keys in the dictionary.
+   *
+   * @returns Array of keys.
+   */
+  keys() {
+    return Array.from(this.data.keys());
+  }
+  /**
+   * Remove a specific value from the array associated with the given key.
+   *
+   * @param key - The key.
+   * @param value - The value to remove.
+   */
+  remove(key, value) {
+    const values = this.get(key);
+    if (!values) {
+      return;
+    }
+    values.remove(value);
+    if (values.length === 0) {
+      this.clear(key);
+    }
+  }
+};
+
+// 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: Bases.
+   */
+  Bases: "bases",
+  /**
+   * Plugin name in UI: Bookmarks.
+   */
+  Bookmarks: "bookmarks",
+  /**
+   * 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: Footnotes.
+   */
+  Footnotes: "footnotes",
+  /**
+   * 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: Web viewer.
+   */
+  Webviewer: "webviewer",
+  /**
+   * 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,
+  Bases: InternalPluginName.Bases,
+  Bookmarks: InternalPluginName.Bookmarks,
+  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",
+  Table: "table",
+  Tag: "tag",
+  Video: "video",
+  Webviewer: "webviewer",
+  WebviewerHistory: "webviewer-history"
+};
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesEntryConstructor.ts
+import { BasesEntry } from "obsidian";
+function getBasesEntryConstructor() {
+  return BasesEntry;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesEntryGroupConstructor.ts
+import { BasesEntryGroup } from "obsidian";
+function getBasesEntryGroupConstructor() {
+  return BasesEntryGroup;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesQueryResultConstructor.ts
+import { BasesQueryResult } from "obsidian";
+function getBasesQueryResultConstructor() {
+  return BasesQueryResult;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesViewConfigConstructor.ts
+import { BasesViewConfig } from "obsidian";
+function getBasesViewConfigConstructor() {
+  return BasesViewConfig;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getQueryControllerConstructor.ts
+import { QueryController } from "obsidian";
+function getQueryControllerConstructor() {
+  return QueryController;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getAppConstructor.ts
+import { App } from "obsidian";
+function getAppConstructor() {
+  return App;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getCapacitorAdapterConstructor.ts
+import { CapacitorAdapter } from "obsidian";
+function getCapacitorAdapterConstructor() {
+  return CapacitorAdapter;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getConfirmationModalConstructor.ts
+import { ConfirmationModal } from "obsidian";
+function getConfirmationModalConstructor() {
+  return ConfirmationModal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getEditorConstructor.ts
+import { Editor } from "obsidian";
+function getEditorConstructor() {
+  return Editor;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getEventsConstructor.ts
+import { Events } from "obsidian";
+function getEventsConstructor() {
+  return Events;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFileManagerConstructor.ts
+import { FileManager } from "obsidian";
+function getFileManagerConstructor() {
+  return FileManager;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFileSystemAdapterConstructor.ts
+import { FileSystemAdapter } from "obsidian";
+function getFileSystemAdapterConstructor() {
+  return FileSystemAdapter;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFuzzySuggestModalConstructor.ts
+import { FuzzySuggestModal } from "obsidian";
+function getFuzzySuggestModalConstructor() {
+  return FuzzySuggestModal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getHoverPopoverConstructor.ts
+import { HoverPopover } from "obsidian";
+function getHoverPopoverConstructor() {
+  return HoverPopover;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getKeymapConstructor.ts
+import { Keymap } from "obsidian";
+function getKeymapConstructor() {
+  return Keymap;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewRendererConstructor.ts
+import { MarkdownPreviewRenderer } from "obsidian";
+function getMarkdownPreviewRendererConstructor() {
+  return MarkdownPreviewRenderer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewViewConstructor.ts
+import { MarkdownPreviewView } from "obsidian";
+function getMarkdownPreviewViewConstructor() {
+  return MarkdownPreviewView;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownRenderChildConstructor.ts
+import { MarkdownRenderChild } from "obsidian";
+function getMarkdownRenderChildConstructor() {
+  return MarkdownRenderChild;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownRendererConstructor.ts
+import { MarkdownRenderer } from "obsidian";
+function getMarkdownRendererConstructor() {
+  return MarkdownRenderer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuConstructor.ts
+import { Menu } from "obsidian";
+function getMenuConstructor() {
+  return Menu;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuItemConstructor.ts
+import { MenuItem } from "obsidian";
+function getMenuItemConstructor() {
+  return MenuItem;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuSeparatorConstructor.ts
+import { MenuSeparator } from "obsidian";
+function getMenuSeparatorConstructor() {
+  return MenuSeparator;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMetadataCacheConstructor.ts
+import { MetadataCache } from "obsidian";
+function getMetadataCacheConstructor() {
+  return MetadataCache;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getModalConstructor.ts
+import { Modal } from "obsidian";
+function getModalConstructor() {
+  return Modal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getNoticeConstructor.ts
+import { Notice } from "obsidian";
+function getNoticeConstructor() {
+  return Notice;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getRenderContextConstructor.ts
+import { RenderContext } from "obsidian";
+function getRenderContextConstructor() {
+  return RenderContext;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getScopeConstructor.ts
+import { Scope } from "obsidian";
+function getScopeConstructor() {
+  return Scope;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSecretStorageConstructor.ts
+import { SecretStorage } from "obsidian";
+function getSecretStorageConstructor() {
+  return SecretStorage;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingConstructor.ts
+import { Setting } from "obsidian";
+function getSettingConstructor() {
+  return Setting;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingGroupConstructor.ts
+import { SettingGroup } from "obsidian";
+function getSettingGroupConstructor() {
+  return SettingGroup;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingPageConstructor.ts
+import { SettingPage } from "obsidian";
+function getSettingPageConstructor() {
+  return SettingPage;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingTabConstructor.ts
+import { SettingTab } from "obsidian";
+function getSettingTabConstructor() {
+  return SettingTab;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTAbstractFileConstructor.ts
+import { TAbstractFile } from "obsidian";
+function getTAbstractFileConstructor() {
+  return TAbstractFile;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTasksConstructor.ts
+import { Tasks } from "obsidian";
+function getTasksConstructor() {
+  return Tasks;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTFileConstructor.ts
+import { TFile } from "obsidian";
+function getTFileConstructor() {
+  return TFile;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTFolderConstructor.ts
+import { TFolder } from "obsidian";
+function getTFolderConstructor() {
+  return TFolder;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getVaultConstructor.ts
+import { Vault } from "obsidian";
+function getVaultConstructor() {
+  return Vault;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceConstructor.ts
+import { Workspace } from "obsidian";
+function getWorkspaceConstructor() {
+  return Workspace;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceContainerConstructor.ts
+import { WorkspaceContainer } from "obsidian";
+function getWorkspaceContainerConstructor() {
+  return WorkspaceContainer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceFloatingConstructor.ts
+import { WorkspaceFloating } from "obsidian";
+function getWorkspaceFloatingConstructor() {
+  return WorkspaceFloating;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceItemConstructor.ts
+import { WorkspaceItem } from "obsidian";
+function getWorkspaceItemConstructor() {
+  return WorkspaceItem;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceLeafConstructor.ts
+import { WorkspaceLeaf } from "obsidian";
+function getWorkspaceLeafConstructor() {
+  return WorkspaceLeaf;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceMobileDrawerConstructor.ts
+import { WorkspaceMobileDrawer } from "obsidian";
+function getWorkspaceMobileDrawerConstructor() {
+  return WorkspaceMobileDrawer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceParentConstructor.ts
+import { WorkspaceParent } from "obsidian";
+function getWorkspaceParentConstructor() {
+  return WorkspaceParent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceRibbonConstructor.ts
+import { WorkspaceRibbon } from "obsidian";
+function getWorkspaceRibbonConstructor() {
+  return WorkspaceRibbon;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceRootConstructor.ts
+import { WorkspaceRoot } from "obsidian";
+function getWorkspaceRootConstructor() {
+  return WorkspaceRoot;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceSidedockConstructor.ts
+import { WorkspaceSidedock } from "obsidian";
+function getWorkspaceSidedockConstructor() {
+  return WorkspaceSidedock;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceSplitConstructor.ts
+import { WorkspaceSplit } from "obsidian";
+function getWorkspaceSplitConstructor() {
+  return WorkspaceSplit;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceTabsConstructor.ts
+import { WorkspaceTabs } from "obsidian";
+function getWorkspaceTabsConstructor() {
+  return WorkspaceTabs;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceWindowConstructor.ts
+import { WorkspaceWindow } from "obsidian";
+function getWorkspaceWindowConstructor() {
+  return WorkspaceWindow;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getAbstractTextComponentConstructor.ts
+import { AbstractTextComponent } from "obsidian";
+function getAbstractTextComponentConstructor() {
+  return AbstractTextComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getBaseComponentConstructor.ts
+import { BaseComponent } from "obsidian";
+function getBaseComponentConstructor() {
+  return BaseComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getButtonComponentConstructor.ts
+import { ButtonComponent } from "obsidian";
+function getButtonComponentConstructor() {
+  return ButtonComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getColorComponentConstructor.ts
+import { ColorComponent } from "obsidian";
+function getColorComponentConstructor() {
+  return ColorComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getComponentConstructor.ts
+import { Component } from "obsidian";
+function getComponentConstructor() {
+  return Component;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getConfirmationButtonConstructor.ts
+import { ConfirmationButton } from "obsidian";
+function getConfirmationButtonConstructor() {
+  return ConfirmationButton;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDisplayValueComponentConstructor.ts
+import { DisplayValueComponent } from "obsidian";
+function getDisplayValueComponentConstructor() {
+  return DisplayValueComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDropdownComponentConstructor.ts
+import { DropdownComponent } from "obsidian";
+function getDropdownComponentConstructor() {
+  return DropdownComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getExtraButtonComponentConstructor.ts
+import { ExtraButtonComponent } from "obsidian";
+function getExtraButtonComponentConstructor() {
+  return ExtraButtonComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getMomentFormatComponentConstructor.ts
+import { MomentFormatComponent } from "obsidian";
+function getMomentFormatComponentConstructor() {
+  return MomentFormatComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getProgressBarComponentConstructor.ts
+import { ProgressBarComponent } from "obsidian";
+function getProgressBarComponentConstructor() {
+  return ProgressBarComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSearchComponentConstructor.ts
+import { SearchComponent } from "obsidian";
+function getSearchComponentConstructor() {
+  return SearchComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSecretComponentConstructor.ts
+import { SecretComponent } from "obsidian";
+function getSecretComponentConstructor() {
+  return SecretComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSliderComponentConstructor.ts
+import { SliderComponent } from "obsidian";
+function getSliderComponentConstructor() {
+  return SliderComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextAreaComponentConstructor.ts
+import { TextAreaComponent } from "obsidian";
+function getTextAreaComponentConstructor() {
+  return TextAreaComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextComponentConstructor.ts
+import { TextComponent } from "obsidian";
+function getTextComponentConstructor() {
+  return TextComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getToggleComponentConstructor.ts
+import { ToggleComponent } from "obsidian";
+function getToggleComponentConstructor() {
+  return ToggleComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getValueComponentConstructor.ts
+import { ValueComponent } from "obsidian";
+function getValueComponentConstructor() {
+  return ValueComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getBooleanValueConstructor.ts
+import { BooleanValue } from "obsidian";
+function getBooleanValueConstructor() {
+  return BooleanValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getDateValueConstructor.ts
+import { DateValue } from "obsidian";
+function getDateValueConstructor() {
+  return DateValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getDurationValueConstructor.ts
+import { DurationValue } from "obsidian";
+function getDurationValueConstructor() {
+  return DurationValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getFileValueConstructor.ts
+import { FileValue } from "obsidian";
+function getFileValueConstructor() {
+  return FileValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getHTMLValueConstructor.ts
+import { HTMLValue } from "obsidian";
+function getHTMLValueConstructor() {
+  return HTMLValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getIconValueConstructor.ts
+import { IconValue } from "obsidian";
+function getIconValueConstructor() {
+  return IconValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getImageValueConstructor.ts
+import { ImageValue } from "obsidian";
+function getImageValueConstructor() {
+  return ImageValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getLinkValueConstructor.ts
+import { LinkValue } from "obsidian";
+function getLinkValueConstructor() {
+  return LinkValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getListValueConstructor.ts
+import { ListValue } from "obsidian";
+function getListValueConstructor() {
+  return ListValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNotNullValueConstructor.ts
+import { NotNullValue } from "obsidian";
+function getNotNullValueConstructor() {
+  return NotNullValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNullValueConstructor.ts
+import { NullValue } from "obsidian";
+function getNullValueConstructor() {
+  return NullValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNumberValueConstructor.ts
+import { NumberValue } from "obsidian";
+function getNumberValueConstructor() {
+  return NumberValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getObjectValueConstructor.ts
+import { ObjectValue } from "obsidian";
+function getObjectValueConstructor() {
+  return ObjectValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getRegExpValueConstructor.ts
+import { RegExpValue } from "obsidian";
+function getRegExpValueConstructor() {
+  return RegExpValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getRelativeDateValueConstructor.ts
+import { RelativeDateValue } from "obsidian";
+function getRelativeDateValueConstructor() {
+  return RelativeDateValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getStringValueConstructor.ts
+import { StringValue } from "obsidian";
+function getStringValueConstructor() {
+  return StringValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getTagValueConstructor.ts
+import { TagValue } from "obsidian";
+function getTagValueConstructor() {
+  return TagValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getUrlValueConstructor.ts
+import { UrlValue } from "obsidian";
+function getUrlValueConstructor() {
+  return UrlValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getValueConstructor.ts
+import { Value } from "obsidian";
+function getValueConstructor() {
+  return Value;
+}
+
+// src/obsidian/implementations/constructors/augmentations/views/getEditableFileViewConstructor.ts
+import { EditableFileView } from "obsidian";
+function getEditableFileViewConstructor() {
+  return EditableFileView;
+}
+
+// src/obsidian/implementations/constructors/augmentations/views/getMarkdownViewConstructor.ts
+import { MarkdownView } from "obsidian";
+function getMarkdownViewConstructor() {
+  return MarkdownView;
+}
+
+// src/obsidian/implementations/constructors/internals/getAppMenuBarManagerConstructor.ts
+function getAppMenuBarManagerConstructor(app) {
+  return app.appMenuBarManager.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getAppSettingConstructor.ts
+function getAppSettingConstructor(app) {
+  return app.setting.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getCliConstructor.ts
+function getCliConstructor(app) {
+  return app.cli.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getCommandsConstructor.ts
+function getCommandsConstructor(app) {
+  return app.commands.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getCustomCSSConstructor.ts
+function getCustomCSSConstructor(app) {
+  return app.customCss.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getDragManagerConstructor.ts
+function getDragManagerConstructor(app) {
+  return app.dragManager.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getEditorSuggestsConstructor.ts
+function getEditorSuggestsConstructor(app) {
+  return app.workspace.editorSuggest.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getEmbedRegistryConstructor.ts
+function getEmbedRegistryConstructor(app) {
+  return app.embedRegistry.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getFoldManagerConstructor.ts
+function getFoldManagerConstructor(app) {
+  return app.foldManager.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getFrameDomConstructor.ts
+function getFrameDomConstructor() {
+  return window.frameDom.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getHotkeyManagerConstructor.ts
+function getHotkeyManagerConstructor(app) {
+  return app.hotkeyManager.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getMetadataTypeManagerConstructor.ts
+function getMetadataTypeManagerConstructor(app) {
+  return app.metadataTypeManager.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getObsidianDOMConstructor.ts
+function getObsidianDOMConstructor(app) {
+  return app.dom.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getPluginsConstructor.ts
+function getPluginsConstructor(app) {
+  return app.plugins.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getRecentFileTrackerConstructor.ts
+function getRecentFileTrackerConstructor(app) {
+  return app.workspace.recentFileTracker.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getShareReceiverConstructor.ts
+function getShareReceiverConstructor(app) {
+  return app.shareReceiver.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getStatusBarConstructor.ts
+function getStatusBarConstructor(app) {
+  return app.statusBar.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getViewRegistryConstructor.ts
+function getViewRegistryConstructor(app) {
+  return app.viewRegistry.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/getWorkspaceLeafHistoryConstructor.ts
+function getWorkspaceLeafHistoryConstructor(app) {
+  const leaf = app.workspace.getMostRecentLeaf();
+  if (!leaf) {
+    throw new Error("No workspace leaf available to extract WorkspaceLeafHistory constructor");
+  }
+  return leaf.history.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesContextConstructor.ts
+function getBasesContextConstructor(app) {
+  const basesPlugin = app.internalPlugins.getPluginById(InternalPluginName.Bases);
+  if (!basesPlugin) {
+    throw new Error(`The ${InternalPluginName.Bases} plugin is not loaded.`);
+  }
+  const queryControllerConstructor = getQueryControllerConstructor();
+  const queryController = new queryControllerConstructor(app, basesPlugin.instance, createDiv());
+  queryController.query = {};
+  const basesContext = queryController.buildBasesContext();
+  return basesContext.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesQueryConstructor.ts
+import { Component as Component2 } from "obsidian";
+
+// src/obsidian/implementations/functions/getBasesControllerFromRender.ts
+import { MarkdownRenderer as MarkdownRenderer2 } from "obsidian";
+async function getBasesControllerFromRender(app, content, sourcePath, component) {
+  const containerEl = createDiv();
+  containerEl.style.position = "absolute";
+  containerEl.style.left = "-9999px";
+  containerEl.style.width = "600px";
+  document.body.appendChild(containerEl);
+  component.register(() => {
+    containerEl.remove();
+  });
+  await MarkdownRenderer2.render(app, `\`\`\`base
+${content}
+\`\`\`
+`, containerEl, sourcePath, component);
+  const queue = [component];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const node = queue.shift();
+    if (!node || seen.has(node)) {
+      continue;
+    }
+    seen.add(node);
+    if (node.results instanceof Map && "query" in node) {
+      return node;
+    }
+    for (const child of node._children ?? []) {
+      queue.push(child);
+    }
+  }
+  throw new Error("Could not locate the BasesController in the rendered component tree.");
+}
+
+// src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesQueryConstructor.ts
+async function getBasesQueryConstructor(app) {
+  const component = new Component2();
+  try {
+    const controller = await getBasesControllerFromRender(app, "views: []\n", "getBasesQueryConstructor.base", component);
+    const query = controller.query;
+    if (!query) {
+      throw new Error("The rendered base did not produce a query.");
+    }
+    return query.constructor;
+  } finally {
+    component.unload();
+  }
+}
+
+// src/obsidian/implementations/constructors/internals/internal-plugins/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/internals/internal-plugins/getInternalPluginsConstructor.ts
+function getInternalPluginsConstructor(app) {
+  return app.internalPlugins.constructor;
+}
+
+// src/obsidian/implementations/constructors/internals/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/internals/views/getAllPropertiesViewConstructor.ts
+function getAllPropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.AllProperties);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getAudioViewConstructor.ts
+function getAudioViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Audio);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getBacklinkViewConstructor.ts
+function getBacklinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Backlink);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getBasesViewConstructor.ts
+function getBasesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Bases);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getBookmarksViewConstructor.ts
+function getBookmarksViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Bookmarks);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getCanvasViewConstructor.ts
+function getCanvasViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Canvas);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getEmptyViewConstructor.ts
+function getEmptyViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Empty);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getFileExplorerViewConstructor.ts
+function getFileExplorerViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileExplorer);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getFilePropertiesViewConstructor.ts
+function getFilePropertiesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.FileProperties);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getGraphViewConstructor.ts
+function getGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Graph);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getImageViewConstructor.ts
+function getImageViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Image);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getLocalGraphViewConstructor.ts
+function getLocalGraphViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.LocalGraph);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getOutgoingLinkViewConstructor.ts
+function getOutgoingLinkViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.OutgoingLink);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getOutlineViewConstructor.ts
+function getOutlineViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Outline);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getPdfViewConstructor.ts
+function getPdfViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Pdf);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getReleaseNotesViewConstructor.ts
+function getReleaseNotesViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.ReleaseNotes);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getSearchViewConstructor.ts
+function getSearchViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Search);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getSyncViewConstructor.ts
+function getSyncViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Sync);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getTableViewConstructor.ts
+function getTableViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Table);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getTagViewConstructor.ts
+function getTagViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Tag);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getVideoViewConstructor.ts
+function getVideoViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Video);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getWebviewerHistoryViewConstructor.ts
+function getWebviewerHistoryViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.WebviewerHistory);
+}
+
+// src/obsidian/implementations/constructors/internals/views/getWebviewerViewConstructor.ts
+function getWebviewerViewConstructor(app) {
+  return getViewConstructorByViewType(app, ViewType.Webviewer);
+}
+
+// src/obsidian/implementations/constructors/internals/workspace/getWorkspaceProtocolHandlerConstructor.ts
+function getWorkspaceProtocolHandlerConstructor(app) {
+  return app.workspace.protocolHandler.constructor;
+}
+
+// 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/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/functions/evaluateBaseHeadless.ts
+import { Component as Component3 } from "obsidian";
+async function evaluateBaseHeadless(app, content, sourcePath) {
+  const SCAN_POLL_INTERVAL_IN_MILLISECONDS = 50;
+  const SCAN_TIMEOUT_IN_MILLISECONDS = 3e4;
+  const component = new Component3();
+  try {
+    const controller = await getBasesControllerFromRender(app, content, sourcePath, component);
+    const startTime = performance.now();
+    while (controller.initialScan) {
+      if (performance.now() - startTime > SCAN_TIMEOUT_IN_MILLISECONDS) {
+        throw new Error("Timed out waiting for the base initial scan to settle.");
+      }
+      await new Promise((resolve) => {
+        window.setTimeout(resolve, SCAN_POLL_INTERVAL_IN_MILLISECONDS);
+      });
+    }
+    return Array.from(controller.results.values());
+  } finally {
+    component.unload();
+  }
+}
+
+// src/obsidian/implementations/functions/getDataAdapterEx.ts
+function getDataAdapterEx(app) {
+  return app.vault.adapter;
+}
+
+// src/obsidian/implementations/functions/loadMermaid.ts
+import { loadMermaid as loadMermaidOriginal } from "obsidian";
+async function loadMermaid() {
+  return await loadMermaidOriginal();
+}
+
+// src/obsidian/implementations/functions/loadPdfJs.ts
+import { loadPdfJs as loadPdfJsOriginal } from "obsidian";
+async function loadPdfJs() {
+  return await loadPdfJsOriginal();
+}
+
+// src/obsidian/implementations/functions/loadPrism.ts
+import { loadPrism as loadPrismOriginal } from "obsidian";
+async function loadPrism() {
+  return await loadPrismOriginal();
+}
+
+// src/obsidian/implementations/type-guards/isReferenceCache.ts
+function isReferenceCache(reference) {
+  return !!reference.position;
+}
+
+// src/obsidian/implementations/type-guards/isEmbedCache.ts
+function isEmbedCache(reference) {
+  return isReferenceCache(reference) && reference.original[0] === "!";
+}
+
+// src/obsidian/implementations/type-guards/isFrontmatterLinkCache.ts
+function isFrontmatterLinkCache(reference) {
+  return !!reference.key;
+}
+
+// src/obsidian/implementations/type-guards/isLinkCache.ts
+function isLinkCache(reference) {
+  return isReferenceCache(reference) && reference.original[0] !== "!";
+}
+export {
+  CustomArrayDictImpl,
+  FileExtension,
+  InternalPluginName,
+  ViewType,
+  createTFileInstance,
+  createTFolderInstance,
+  evaluateBaseHeadless,
+  getAbstractTextComponentConstructor,
+  getAllPropertiesViewConstructor,
+  getAppConstructor,
+  getAppMenuBarManagerConstructor,
+  getAppSettingConstructor,
+  getAudioViewConstructor,
+  getBacklinkViewConstructor,
+  getBaseComponentConstructor,
+  getBasesContextConstructor,
+  getBasesControllerFromRender,
+  getBasesEntryConstructor,
+  getBasesEntryGroupConstructor,
+  getBasesQueryConstructor,
+  getBasesQueryResultConstructor,
+  getBasesViewConfigConstructor,
+  getBasesViewConstructor,
+  getBookmarksViewConstructor,
+  getBooleanValueConstructor,
+  getButtonComponentConstructor,
+  getCanvasViewConstructor,
+  getCapacitorAdapterConstructor,
+  getCliConstructor,
+  getColorComponentConstructor,
+  getCommandsConstructor,
+  getComponentConstructor,
+  getConfirmationButtonConstructor,
+  getConfirmationModalConstructor,
+  getCustomCSSConstructor,
+  getDataAdapterEx,
+  getDateValueConstructor,
+  getDisplayValueComponentConstructor,
+  getDragManagerConstructor,
+  getDropdownComponentConstructor,
+  getDurationValueConstructor,
+  getEditableFileViewConstructor,
+  getEditorConstructor,
+  getEditorSuggestsConstructor,
+  getEmbedRegistryConstructor,
+  getEmptyViewConstructor,
+  getEventsConstructor,
+  getExtraButtonComponentConstructor,
+  getFileExplorerViewConstructor,
+  getFileManagerConstructor,
+  getFilePropertiesViewConstructor,
+  getFileSystemAdapterConstructor,
+  getFileValueConstructor,
+  getFoldManagerConstructor,
+  getFrameDomConstructor,
+  getFuzzySuggestModalConstructor,
+  getGraphViewConstructor,
+  getHTMLValueConstructor,
+  getHotkeyManagerConstructor,
+  getHoverPopoverConstructor,
+  getIconValueConstructor,
+  getImageValueConstructor,
+  getImageViewConstructor,
+  getInternalPluginConstructor,
+  getInternalPluginsConstructor,
+  getKeymapConstructor,
+  getLinkValueConstructor,
+  getListValueConstructor,
+  getLocalGraphViewConstructor,
+  getMarkdownPreviewRendererConstructor,
+  getMarkdownPreviewViewConstructor,
+  getMarkdownRenderChildConstructor,
+  getMarkdownRendererConstructor,
+  getMarkdownViewConstructor,
+  getMenuConstructor,
+  getMenuItemConstructor,
+  getMenuSeparatorConstructor,
+  getMetadataCacheConstructor,
+  getMetadataTypeManagerConstructor,
+  getModalConstructor,
+  getMomentFormatComponentConstructor,
+  getNotNullValueConstructor,
+  getNoticeConstructor,
+  getNullValueConstructor,
+  getNumberValueConstructor,
+  getObjectValueConstructor,
+  getObsidianDOMConstructor,
+  getOutgoingLinkViewConstructor,
+  getOutlineViewConstructor,
+  getPdfViewConstructor,
+  getPluginsConstructor,
+  getProgressBarComponentConstructor,
+  getQueryControllerConstructor,
+  getRecentFileTrackerConstructor,
+  getRegExpValueConstructor,
+  getRelativeDateValueConstructor,
+  getReleaseNotesViewConstructor,
+  getRenderContextConstructor,
+  getScopeConstructor,
+  getSearchComponentConstructor,
+  getSearchViewConstructor,
+  getSecretComponentConstructor,
+  getSecretStorageConstructor,
+  getSettingConstructor,
+  getSettingGroupConstructor,
+  getSettingPageConstructor,
+  getSettingTabConstructor,
+  getShareReceiverConstructor,
+  getSliderComponentConstructor,
+  getStatusBarConstructor,
+  getStringValueConstructor,
+  getSyncViewConstructor,
+  getTAbstractFileConstructor,
+  getTFileConstructor,
+  getTFolderConstructor,
+  getTableViewConstructor,
+  getTagValueConstructor,
+  getTagViewConstructor,
+  getTasksConstructor,
+  getTextAreaComponentConstructor,
+  getTextComponentConstructor,
+  getToggleComponentConstructor,
+  getUrlValueConstructor,
+  getValueComponentConstructor,
+  getValueConstructor,
+  getVaultConstructor,
+  getVideoViewConstructor,
+  getViewConstructorByViewType,
+  getViewRegistryConstructor,
+  getWebviewerHistoryViewConstructor,
+  getWebviewerViewConstructor,
+  getWorkspaceConstructor,
+  getWorkspaceContainerConstructor,
+  getWorkspaceFloatingConstructor,
+  getWorkspaceItemConstructor,
+  getWorkspaceLeafConstructor,
+  getWorkspaceLeafHistoryConstructor,
+  getWorkspaceMobileDrawerConstructor,
+  getWorkspaceParentConstructor,
+  getWorkspaceProtocolHandlerConstructor,
+  getWorkspaceRibbonConstructor,
+  getWorkspaceRootConstructor,
+  getWorkspaceSidedockConstructor,
+  getWorkspaceSplitConstructor,
+  getWorkspaceTabsConstructor,
+  getWorkspaceWindowConstructor,
+  isEmbedCache,
+  isFrontmatterLinkCache,
+  isLinkCache,
+  isReferenceCache,
+  loadMermaid,
+  loadPdfJs,
+  loadPrism,
+  parentFolderPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../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/augmentations/bases/getBasesEntryConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/bases/getBasesEntryGroupConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/bases/getBasesQueryResultConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/bases/getBasesViewConfigConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/bases/getQueryControllerConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getAppConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getCapacitorAdapterConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getConfirmationModalConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getEditorConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getEventsConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getFileManagerConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getFileSystemAdapterConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getFuzzySuggestModalConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getHoverPopoverConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getKeymapConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewRendererConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewViewConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMarkdownRenderChildConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMarkdownRendererConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMenuConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMenuItemConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMenuSeparatorConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getMetadataCacheConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getModalConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getNoticeConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getRenderContextConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getScopeConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getSecretStorageConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getSettingConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getSettingGroupConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getSettingPageConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getSettingTabConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getTAbstractFileConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getTasksConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getTFileConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getTFolderConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getVaultConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceContainerConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceFloatingConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceItemConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceLeafConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceMobileDrawerConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceParentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceRibbonConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceRootConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceSidedockConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceSplitConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceTabsConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/getWorkspaceWindowConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getAbstractTextComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getBaseComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getButtonComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getColorComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getConfirmationButtonConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDisplayValueComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDropdownComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getExtraButtonComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getMomentFormatComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getProgressBarComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSearchComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSecretComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSliderComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextAreaComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getToggleComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/settings/setting-components/getValueComponentConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getBooleanValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getDateValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getDurationValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getFileValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getHTMLValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getIconValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getImageValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getLinkValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getListValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getNotNullValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getNullValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getNumberValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getObjectValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getRegExpValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getRelativeDateValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getStringValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getTagValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getUrlValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/values/getValueConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/views/getEditableFileViewConstructor.ts", "../../src/obsidian/implementations/constructors/augmentations/views/getMarkdownViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getAppMenuBarManagerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getAppSettingConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getCliConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getCommandsConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getCustomCSSConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getDragManagerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getEditorSuggestsConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getEmbedRegistryConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getFoldManagerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getFrameDomConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getHotkeyManagerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getMetadataTypeManagerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getObsidianDOMConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getPluginsConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getRecentFileTrackerConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getShareReceiverConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getStatusBarConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getViewRegistryConstructor.ts", "../../src/obsidian/implementations/constructors/internals/getWorkspaceLeafHistoryConstructor.ts", "../../src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesContextConstructor.ts", "../../src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesQueryConstructor.ts", "../../src/obsidian/implementations/functions/getBasesControllerFromRender.ts", "../../src/obsidian/implementations/constructors/internals/internal-plugins/getInternalPluginConstructor.ts", "../../src/obsidian/implementations/constructors/internals/internal-plugins/getInternalPluginsConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getViewConstructorByViewType.ts", "../../src/obsidian/implementations/constructors/internals/views/getAllPropertiesViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getAudioViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getBacklinkViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getBasesViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getBookmarksViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getCanvasViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getEmptyViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getFileExplorerViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getFilePropertiesViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getGraphViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getImageViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getLocalGraphViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getOutgoingLinkViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getOutlineViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getPdfViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getReleaseNotesViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getSearchViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getSyncViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getTableViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getTagViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getVideoViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getWebviewerHistoryViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/views/getWebviewerViewConstructor.ts", "../../src/obsidian/implementations/constructors/internals/workspace/getWorkspaceProtocolHandlerConstructor.ts", "../../src/obsidian/implementations/utils/PathUtils.ts", "../../src/obsidian/implementations/functions/createTFolderInstance.ts", "../../src/obsidian/implementations/functions/createTFileInstance.ts", "../../src/obsidian/implementations/functions/evaluateBaseHeadless.ts", "../../src/obsidian/implementations/functions/getDataAdapterEx.ts", "../../src/obsidian/implementations/functions/loadMermaid.ts", "../../src/obsidian/implementations/functions/loadPdfJs.ts", "../../src/obsidian/implementations/functions/loadPrism.ts", "../../src/obsidian/implementations/type-guards/isReferenceCache.ts", "../../src/obsidian/implementations/type-guards/isEmbedCache.ts", "../../src/obsidian/implementations/type-guards/isFrontmatterLinkCache.ts", "../../src/obsidian/implementations/type-guards/isLinkCache.ts"],
  "sourcesContent": ["import type { CustomArrayDict } from '../../internals/collections/CustomArrayDict.d.d.ts';\n\n/**\n * A dictionary that maps string keys to arrays of unique values, implementing {@link CustomArrayDict}.\n *\n * @public\n * @unofficial\n */\nexport class CustomArrayDictImpl<T> implements CustomArrayDict<T> {\n  /**\n   * Internal map storing key-to-array mappings.\n   */\n  public data: Map<string, T[]> = new Map();\n\n  /**\n   * Add a value to the array associated with the given key.\n   *\n   * @param key - The key.\n   * @param value - The value to add.\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  /**\n   * Remove all values for the given key.\n   *\n   * @param key - The key to clear.\n   */\n  public clear(key: string): void {\n    this.data.delete(key);\n  }\n\n  /**\n   * Remove all keys and their values.\n   */\n  public clearAll(): void {\n    this.data.clear();\n  }\n\n  /**\n   * Check whether the array for the given key contains the specified value.\n   *\n   * @param key - The key.\n   * @param value - The value to check.\n   * @returns Whether the value exists.\n   */\n  public contains(key: string, value: T): boolean {\n    return !!this.get(key)?.contains(value);\n  }\n\n  /**\n   * Get the total number of values across all keys.\n   *\n   * @returns Total value count.\n   */\n  public count(): number {\n    let ans = 0;\n    for (const key of this.keys()) {\n      ans += this.get(key)?.length ?? 0;\n    }\n\n    return ans;\n  }\n\n  /**\n   * Get the array of values for the given key, or `null` if not found.\n   *\n   * @param key - The key.\n   * @returns Array of values, or `null`.\n   */\n  public get(key: string): null | T[] {\n    return this.data.get(key) || null;\n  }\n\n  /**\n   * Get all keys in the dictionary.\n   *\n   * @returns Array of keys.\n   */\n  public keys(): string[] {\n    return Array.from(this.data.keys());\n  }\n\n  /**\n   * Remove a specific value from the array associated with the given key.\n   *\n   * @param key - The key.\n   * @param value - The value to remove.\n   */\n  public remove(key: string, value: T): void {\n    const values = this.get(key);\n    if (!values) {\n      return;\n    }\n\n    values.remove(value);\n    if (values.length === 0) {\n      this.clear(key);\n    }\n  }\n}\n", "/**\n * Constant mapping of file extension identifiers recognized and supported by Obsidian.\n *\n * @public\n * @unofficial\n */\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", "/**\n * Constant mapping of internal (core) plugin name identifiers bundled with Obsidian.\n *\n * @public\n * @unofficial\n */\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: Bases.\n   */\n  Bases: 'bases',\n  /**\n   * Plugin name in UI: Bookmarks.\n   */\n  Bookmarks: 'bookmarks',\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: Footnotes.\n   */\n  Footnotes: 'footnotes',\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: Web viewer.\n   */\n  Webviewer: 'webviewer',\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/**\n * Constant mapping of view type identifiers used to open and manage different leaf views in Obsidian.\n *\n * @public\n * @unofficial\n */\nexport const ViewType = {\n  AllProperties: 'all-properties',\n  Audio: 'audio',\n  Backlink: InternalPluginName.Backlink,\n  Bases: InternalPluginName.Bases,\n  Bookmarks: InternalPluginName.Bookmarks,\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  Table: 'table',\n  Tag: 'tag',\n  Video: 'video',\n  Webviewer: 'webviewer',\n  WebviewerHistory: 'webviewer-history'\n} as const;\n", "import { BasesEntry } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BasesEntry} constructor.\n *\n * @returns The {@link obsidian#BasesEntry} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesEntryConstructor(): ExtractConstructor<BasesEntry> {\n  return BasesEntry as ExtractConstructor<BasesEntry>;\n}\n", "import { BasesEntryGroup } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BasesEntryGroup} constructor.\n *\n * @returns The {@link obsidian#BasesEntryGroup} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesEntryGroupConstructor(): ExtractConstructor<BasesEntryGroup> {\n  return BasesEntryGroup as ExtractConstructor<BasesEntryGroup>;\n}\n", "import { BasesQueryResult } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BasesQueryResult} constructor.\n *\n * @returns The {@link obsidian#BasesQueryResult} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesQueryResultConstructor(): ExtractConstructor<BasesQueryResult> {\n  return BasesQueryResult as ExtractConstructor<BasesQueryResult>;\n}\n", "import { BasesViewConfig } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BasesViewConfig} constructor.\n *\n * @returns The {@link obsidian#BasesViewConfig} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesViewConfigConstructor(): ExtractConstructor<BasesViewConfig> {\n  return BasesViewConfig as ExtractConstructor<BasesViewConfig>;\n}\n", "import { QueryController } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#QueryController} constructor.\n *\n * @returns The {@link obsidian#QueryController} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getQueryControllerConstructor(): ExtractConstructor<QueryController> {\n  return QueryController as ExtractConstructor<QueryController>;\n}\n", "import { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#App} constructor.\n *\n * @returns The {@link obsidian#App} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAppConstructor(): ExtractConstructor<App> {\n  return App as ExtractConstructor<App>;\n}\n", "import { CapacitorAdapter } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#CapacitorAdapter} constructor.\n *\n * @returns The {@link obsidian#CapacitorAdapter} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getCapacitorAdapterConstructor(): ExtractConstructor<CapacitorAdapter> {\n  return CapacitorAdapter as ExtractConstructor<CapacitorAdapter>;\n}\n", "import { ConfirmationModal } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ConfirmationModal} constructor.\n *\n * @returns The {@link obsidian#ConfirmationModal} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getConfirmationModalConstructor(): ExtractConstructor<ConfirmationModal> {\n  return ConfirmationModal as ExtractConstructor<ConfirmationModal>;\n}\n", "import { Editor } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Editor} constructor.\n *\n * @returns The {@link obsidian#Editor} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEditorConstructor(): ExtractConstructor<Editor> {\n  return Editor as ExtractConstructor<Editor>;\n}\n", "import { Events } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Events} constructor.\n *\n * @returns The {@link obsidian#Events} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEventsConstructor(): ExtractConstructor<Events> {\n  return Events as ExtractConstructor<Events>;\n}\n", "import { FileManager } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#FileManager} constructor.\n *\n * @returns The {@link obsidian#FileManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFileManagerConstructor(): ExtractConstructor<FileManager> {\n  return FileManager as ExtractConstructor<FileManager>;\n}\n", "import { FileSystemAdapter } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#FileSystemAdapter} constructor.\n *\n * @returns The {@link obsidian#FileSystemAdapter} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFileSystemAdapterConstructor(): ExtractConstructor<FileSystemAdapter> {\n  return FileSystemAdapter as ExtractConstructor<FileSystemAdapter>;\n}\n", "import { FuzzySuggestModal } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#FuzzySuggestModal} constructor.\n *\n * @returns The {@link obsidian#FuzzySuggestModal} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFuzzySuggestModalConstructor(): ExtractConstructor<FuzzySuggestModal<unknown>> {\n  return FuzzySuggestModal as ExtractConstructor<FuzzySuggestModal<unknown>>;\n}\n", "import { HoverPopover } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#HoverPopover} constructor.\n *\n * @returns The {@link obsidian#HoverPopover} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getHoverPopoverConstructor(): ExtractConstructor<HoverPopover> {\n  return HoverPopover as ExtractConstructor<HoverPopover>;\n}\n", "import { Keymap } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Keymap} constructor.\n *\n * @returns The {@link obsidian#Keymap} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getKeymapConstructor(): ExtractConstructor<Keymap> {\n  return Keymap as ExtractConstructor<Keymap>;\n}\n", "import { MarkdownPreviewRenderer } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MarkdownPreviewRenderer} constructor.\n *\n * @returns The {@link obsidian#MarkdownPreviewRenderer} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMarkdownPreviewRendererConstructor(): ExtractConstructor<MarkdownPreviewRenderer> {\n  return MarkdownPreviewRenderer as ExtractConstructor<MarkdownPreviewRenderer>;\n}\n", "import { MarkdownPreviewView } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MarkdownPreviewView} constructor.\n *\n * @returns The {@link obsidian#MarkdownPreviewView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMarkdownPreviewViewConstructor(): ExtractConstructor<MarkdownPreviewView> {\n  return MarkdownPreviewView as unknown as ExtractConstructor<MarkdownPreviewView>;\n}\n", "import { MarkdownRenderChild } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MarkdownRenderChild} constructor.\n *\n * @returns The {@link obsidian#MarkdownRenderChild} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMarkdownRenderChildConstructor(): ExtractConstructor<MarkdownRenderChild> {\n  return MarkdownRenderChild as ExtractConstructor<MarkdownRenderChild>;\n}\n", "import { MarkdownRenderer } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MarkdownRenderer} constructor.\n *\n * @returns The {@link obsidian#MarkdownRenderer} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMarkdownRendererConstructor(): ExtractConstructor<MarkdownRenderer> {\n  return MarkdownRenderer as unknown as ExtractConstructor<MarkdownRenderer>;\n}\n", "import { Menu } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Menu} constructor.\n *\n * @returns The {@link obsidian#Menu} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMenuConstructor(): ExtractConstructor<Menu> {\n  return Menu as ExtractConstructor<Menu>;\n}\n", "import { MenuItem } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MenuItem} constructor.\n *\n * @returns The {@link obsidian#MenuItem} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMenuItemConstructor(): ExtractConstructor<MenuItem> {\n  return MenuItem as unknown as ExtractConstructor<MenuItem>;\n}\n", "import { MenuSeparator } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MenuSeparator} constructor.\n *\n * @returns The {@link obsidian#MenuSeparator} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMenuSeparatorConstructor(): ExtractConstructor<MenuSeparator> {\n  return MenuSeparator as ExtractConstructor<MenuSeparator>;\n}\n", "import { MetadataCache } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MetadataCache} constructor.\n *\n * @returns The {@link obsidian#MetadataCache} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMetadataCacheConstructor(): ExtractConstructor<MetadataCache> {\n  return MetadataCache as ExtractConstructor<MetadataCache>;\n}\n", "import { Modal } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Modal} constructor.\n *\n * @returns The {@link obsidian#Modal} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getModalConstructor(): ExtractConstructor<Modal> {\n  return Modal as ExtractConstructor<Modal>;\n}\n", "import { Notice } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Notice} constructor.\n *\n * @returns The {@link obsidian#Notice} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getNoticeConstructor(): ExtractConstructor<Notice> {\n  return Notice as ExtractConstructor<Notice>;\n}\n", "import { RenderContext } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#RenderContext} constructor.\n *\n * @returns The {@link obsidian#RenderContext} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getRenderContextConstructor(): ExtractConstructor<RenderContext> {\n  return RenderContext as ExtractConstructor<RenderContext>;\n}\n", "import { Scope } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Scope} constructor.\n *\n * @returns The {@link obsidian#Scope} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getScopeConstructor(): ExtractConstructor<Scope> {\n  return Scope as ExtractConstructor<Scope>;\n}\n", "import { SecretStorage } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SecretStorage} constructor.\n *\n * @returns The {@link obsidian#SecretStorage} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSecretStorageConstructor(): ExtractConstructor<SecretStorage> {\n  return SecretStorage as ExtractConstructor<SecretStorage>;\n}\n", "import { Setting } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Setting} constructor.\n *\n * @returns The {@link obsidian#Setting} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSettingConstructor(): ExtractConstructor<Setting> {\n  return Setting as ExtractConstructor<Setting>;\n}\n", "import { SettingGroup } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SettingGroup} constructor.\n *\n * @returns The {@link obsidian#SettingGroup} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSettingGroupConstructor(): ExtractConstructor<SettingGroup> {\n  return SettingGroup as ExtractConstructor<SettingGroup>;\n}\n", "import { SettingPage } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SettingPage} constructor.\n *\n * @returns The {@link obsidian#SettingPage} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSettingPageConstructor(): ExtractConstructor<SettingPage> {\n  return SettingPage as ExtractConstructor<SettingPage>;\n}\n", "import { SettingTab } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SettingTab} constructor.\n *\n * @returns The {@link obsidian#SettingTab} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSettingTabConstructor(): ExtractConstructor<SettingTab> {\n  return SettingTab as unknown as ExtractConstructor<SettingTab>;\n}\n", "import { TAbstractFile } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TAbstractFile} constructor.\n *\n * @returns The {@link obsidian#TAbstractFile} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTAbstractFileConstructor(): ExtractConstructor<TAbstractFile> {\n  return TAbstractFile as unknown as ExtractConstructor<TAbstractFile>;\n}\n", "import { Tasks } from 'obsidian';\n\nimport type { ConstructorBase } from '../../../internals/constructors/ConstructorBase.d.ts';\n\n/**\n * Get the {@link obsidian#Tasks} constructor.\n *\n * @returns The {@link obsidian#Tasks} constructor.\n * @remark Constructor is `null`. See {@link https://forum.obsidian.md/t/api-bug-tasks-class/98993}.\n *\n * @public\n * @unofficial\n */\nexport function getTasksConstructor(): ConstructorBase<[], Tasks> {\n  return Tasks as ConstructorBase<[], Tasks>;\n}\n", "import { TFile } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TFile} constructor.\n *\n * @returns The {@link obsidian#TFile} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTFileConstructor(): ExtractConstructor<TFile> {\n  return TFile as ExtractConstructor<TFile>;\n}\n", "import { TFolder } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TFolder} constructor.\n *\n * @returns The {@link obsidian#TFolder} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTFolderConstructor(): ExtractConstructor<TFolder> {\n  return TFolder as ExtractConstructor<TFolder>;\n}\n", "import { Vault } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Vault} constructor.\n *\n * @returns The {@link obsidian#Vault} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getVaultConstructor(): ExtractConstructor<Vault> {\n  return Vault as ExtractConstructor<Vault>;\n}\n", "import { Workspace } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Workspace} constructor.\n *\n * @returns The {@link obsidian#Workspace} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceConstructor(): ExtractConstructor<Workspace> {\n  return Workspace as ExtractConstructor<Workspace>;\n}\n", "import { WorkspaceContainer } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceContainer} constructor.\n *\n * @returns The {@link obsidian#WorkspaceContainer} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceContainerConstructor(): ExtractConstructor<WorkspaceContainer> {\n  return WorkspaceContainer as unknown as ExtractConstructor<WorkspaceContainer>;\n}\n", "import { WorkspaceFloating } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceFloating} constructor.\n *\n * @returns The {@link obsidian#WorkspaceFloating} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceFloatingConstructor(): ExtractConstructor<WorkspaceFloating> {\n  return WorkspaceFloating as ExtractConstructor<WorkspaceFloating>;\n}\n", "import { WorkspaceItem } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceItem} constructor.\n *\n * @returns The {@link obsidian#WorkspaceItem} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceItemConstructor(): ExtractConstructor<WorkspaceItem> {\n  return WorkspaceItem as unknown as ExtractConstructor<WorkspaceItem>;\n}\n", "import { WorkspaceLeaf } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceLeaf} constructor.\n *\n * @returns The {@link obsidian#WorkspaceLeaf} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceLeafConstructor(): ExtractConstructor<WorkspaceLeaf> {\n  return WorkspaceLeaf as ExtractConstructor<WorkspaceLeaf>;\n}\n", "import { WorkspaceMobileDrawer } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceMobileDrawer} constructor.\n *\n * @returns The {@link obsidian#WorkspaceMobileDrawer} constructor.\n * @remark Constructor is `null`. See {@link https://forum.obsidian.md/t/api-bug-tasks-class/98993}.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceMobileDrawerConstructor(): ExtractConstructor<WorkspaceMobileDrawer> {\n  return WorkspaceMobileDrawer as ExtractConstructor<WorkspaceMobileDrawer>;\n}\n", "import { WorkspaceParent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceParent} constructor.\n *\n * @returns The {@link obsidian#WorkspaceParent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceParentConstructor(): ExtractConstructor<WorkspaceParent> {\n  return WorkspaceParent as unknown as ExtractConstructor<WorkspaceParent>;\n}\n", "import { WorkspaceRibbon } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceRibbon} constructor.\n *\n * @returns The {@link obsidian#WorkspaceRibbon} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceRibbonConstructor(): ExtractConstructor<WorkspaceRibbon> {\n  return WorkspaceRibbon as ExtractConstructor<WorkspaceRibbon>;\n}\n", "import { WorkspaceRoot } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceRoot} constructor.\n *\n * @returns The {@link obsidian#WorkspaceRoot} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceRootConstructor(): ExtractConstructor<WorkspaceRoot> {\n  return WorkspaceRoot as ExtractConstructor<WorkspaceRoot>;\n}\n", "import { WorkspaceSidedock } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceSidedock} constructor.\n *\n * @returns The {@link obsidian#WorkspaceSidedock} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceSidedockConstructor(): ExtractConstructor<WorkspaceSidedock> {\n  return WorkspaceSidedock as ExtractConstructor<WorkspaceSidedock>;\n}\n", "import { WorkspaceSplit } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceSplit} constructor.\n *\n * @returns The {@link obsidian#WorkspaceSplit} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceSplitConstructor(): ExtractConstructor<WorkspaceSplit> {\n  return WorkspaceSplit as ExtractConstructor<WorkspaceSplit>;\n}\n", "import { WorkspaceTabs } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceTabs} constructor.\n *\n * @returns The {@link obsidian#WorkspaceTabs} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceTabsConstructor(): ExtractConstructor<WorkspaceTabs> {\n  return WorkspaceTabs as ExtractConstructor<WorkspaceTabs>;\n}\n", "import { WorkspaceWindow } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#WorkspaceWindow} constructor.\n *\n * @returns The {@link obsidian#WorkspaceWindow} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceWindowConstructor(): ExtractConstructor<WorkspaceWindow> {\n  return WorkspaceWindow as ExtractConstructor<WorkspaceWindow>;\n}\n", "import { AbstractTextComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#AbstractTextComponent} constructor.\n *\n * @returns The {@link obsidian#AbstractTextComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAbstractTextComponentConstructor(): ExtractConstructor<\n  AbstractTextComponent<HTMLInputElement | HTMLTextAreaElement>\n> {\n  return AbstractTextComponent as ExtractConstructor<\n    AbstractTextComponent<HTMLInputElement | HTMLTextAreaElement>\n  >;\n}\n", "import { BaseComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BaseComponent} constructor.\n *\n * @returns The {@link obsidian#BaseComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBaseComponentConstructor(): ExtractConstructor<BaseComponent> {\n  return BaseComponent as ExtractConstructor<BaseComponent>;\n}\n", "import { ButtonComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ButtonComponent} constructor.\n *\n * @returns The {@link obsidian#ButtonComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getButtonComponentConstructor(): ExtractConstructor<ButtonComponent> {\n  return ButtonComponent as ExtractConstructor<ButtonComponent>;\n}\n", "import { ColorComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ColorComponent} constructor.\n *\n * @returns The {@link obsidian#ColorComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getColorComponentConstructor(): ExtractConstructor<ColorComponent> {\n  return ColorComponent as ExtractConstructor<ColorComponent>;\n}\n", "import { Component } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Component} constructor.\n *\n * @returns The {@link obsidian#Component} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getComponentConstructor(): ExtractConstructor<Component> {\n  return Component as ExtractConstructor<Component>;\n}\n", "import { ConfirmationButton } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ConfirmationButton} constructor.\n *\n * @returns The {@link obsidian#ConfirmationButton} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getConfirmationButtonConstructor(): ExtractConstructor<ConfirmationButton> {\n  return ConfirmationButton as unknown as ExtractConstructor<ConfirmationButton>;\n}\n", "import { DisplayValueComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#DisplayValueComponent} constructor.\n *\n * @returns The {@link obsidian#DisplayValueComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getDisplayValueComponentConstructor(): ExtractConstructor<DisplayValueComponent> {\n  return DisplayValueComponent as ExtractConstructor<DisplayValueComponent>;\n}\n", "import { DropdownComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#DropdownComponent} constructor.\n *\n * @returns The {@link obsidian#DropdownComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getDropdownComponentConstructor(): ExtractConstructor<DropdownComponent> {\n  return DropdownComponent as ExtractConstructor<DropdownComponent>;\n}\n", "import { ExtraButtonComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ExtraButtonComponent} constructor.\n *\n * @returns The {@link obsidian#ExtraButtonComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getExtraButtonComponentConstructor(): ExtractConstructor<ExtraButtonComponent> {\n  return ExtraButtonComponent as ExtractConstructor<ExtraButtonComponent>;\n}\n", "import { MomentFormatComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MomentFormatComponent} constructor.\n *\n * @returns The {@link obsidian#MomentFormatComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMomentFormatComponentConstructor(): ExtractConstructor<MomentFormatComponent> {\n  return MomentFormatComponent as ExtractConstructor<MomentFormatComponent>;\n}\n", "import { ProgressBarComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ProgressBarComponent} constructor.\n *\n * @returns The {@link obsidian#ProgressBarComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getProgressBarComponentConstructor(): ExtractConstructor<ProgressBarComponent> {\n  return ProgressBarComponent as ExtractConstructor<ProgressBarComponent>;\n}\n", "import { SearchComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SearchComponent} constructor.\n *\n * @returns The {@link obsidian#SearchComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSearchComponentConstructor(): ExtractConstructor<SearchComponent> {\n  return SearchComponent as ExtractConstructor<SearchComponent>;\n}\n", "import { SecretComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SecretComponent} constructor.\n *\n * @returns The {@link obsidian#SecretComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSecretComponentConstructor(): ExtractConstructor<SecretComponent> {\n  return SecretComponent as ExtractConstructor<SecretComponent>;\n}\n", "import { SliderComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#SliderComponent} constructor.\n *\n * @returns The {@link obsidian#SliderComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSliderComponentConstructor(): ExtractConstructor<SliderComponent> {\n  return SliderComponent as ExtractConstructor<SliderComponent>;\n}\n", "import { TextAreaComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TextAreaComponent} constructor.\n *\n * @returns The {@link obsidian#TextAreaComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTextAreaComponentConstructor(): ExtractConstructor<TextAreaComponent> {\n  return TextAreaComponent as ExtractConstructor<TextAreaComponent>;\n}\n", "import { TextComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TextComponent} constructor.\n *\n * @returns The {@link obsidian#TextComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTextComponentConstructor(): ExtractConstructor<TextComponent> {\n  return TextComponent as ExtractConstructor<TextComponent>;\n}\n", "import { ToggleComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ToggleComponent} constructor.\n *\n * @returns The {@link obsidian#ToggleComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getToggleComponentConstructor(): ExtractConstructor<ToggleComponent> {\n  return ToggleComponent as ExtractConstructor<ToggleComponent>;\n}\n", "import { ValueComponent } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ValueComponent} constructor.\n *\n * @returns The {@link obsidian#ValueComponent} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getValueComponentConstructor(): ExtractConstructor<ValueComponent<unknown>> {\n  return ValueComponent as ExtractConstructor<ValueComponent<unknown>>;\n}\n", "import { BooleanValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#BooleanValue} constructor.\n *\n * @returns The {@link obsidian#BooleanValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBooleanValueConstructor(): ExtractConstructor<BooleanValue> {\n  return BooleanValue as ExtractConstructor<BooleanValue>;\n}\n", "import { DateValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#DateValue} constructor.\n *\n * @returns The {@link obsidian#DateValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getDateValueConstructor(): ExtractConstructor<DateValue> {\n  return DateValue as ExtractConstructor<DateValue>;\n}\n", "import { DurationValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#DurationValue} constructor.\n *\n * @returns The {@link obsidian#DurationValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getDurationValueConstructor(): ExtractConstructor<DurationValue> {\n  return DurationValue as ExtractConstructor<DurationValue>;\n}\n", "import { FileValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#FileValue} constructor.\n *\n * @returns The {@link obsidian#FileValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFileValueConstructor(): ExtractConstructor<FileValue> {\n  return FileValue as ExtractConstructor<FileValue>;\n}\n", "import { HTMLValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#HTMLValue} constructor.\n *\n * @returns The {@link obsidian#HTMLValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getHTMLValueConstructor(): ExtractConstructor<HTMLValue> {\n  return HTMLValue as ExtractConstructor<HTMLValue>;\n}\n", "import { IconValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#IconValue} constructor.\n *\n * @returns The {@link obsidian#IconValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getIconValueConstructor(): ExtractConstructor<IconValue> {\n  return IconValue as ExtractConstructor<IconValue>;\n}\n", "import { ImageValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ImageValue} constructor.\n *\n * @returns The {@link obsidian#ImageValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getImageValueConstructor(): ExtractConstructor<ImageValue> {\n  return ImageValue as ExtractConstructor<ImageValue>;\n}\n", "import { LinkValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#LinkValue} constructor.\n *\n * @returns The {@link obsidian#LinkValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getLinkValueConstructor(): ExtractConstructor<LinkValue> {\n  return LinkValue as unknown as ExtractConstructor<LinkValue>;\n}\n", "import { ListValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ListValue} constructor.\n *\n * @returns The {@link obsidian#ListValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getListValueConstructor(): ExtractConstructor<ListValue> {\n  return ListValue as ExtractConstructor<ListValue>;\n}\n", "import { NotNullValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#NotNullValue} constructor.\n *\n * @returns The {@link obsidian#NotNullValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getNotNullValueConstructor(): ExtractConstructor<NotNullValue> {\n  return NotNullValue as unknown as ExtractConstructor<NotNullValue>;\n}\n", "import { NullValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#NullValue} constructor.\n *\n * @returns The {@link obsidian#NullValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getNullValueConstructor(): ExtractConstructor<NullValue> {\n  return NullValue as ExtractConstructor<NullValue>;\n}\n", "import { NumberValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#NumberValue} constructor.\n *\n * @returns The {@link obsidian#NumberValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getNumberValueConstructor(): ExtractConstructor<NumberValue> {\n  return NumberValue as ExtractConstructor<NumberValue>;\n}\n", "import { ObjectValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#ObjectValue} constructor.\n *\n * @returns The {@link obsidian#ObjectValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getObjectValueConstructor(): ExtractConstructor<ObjectValue> {\n  return ObjectValue as ExtractConstructor<ObjectValue>;\n}\n", "import { RegExpValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#RegExpValue} constructor.\n *\n * @returns The {@link obsidian#RegExpValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getRegExpValueConstructor(): ExtractConstructor<RegExpValue> {\n  return RegExpValue as ExtractConstructor<RegExpValue>;\n}\n", "import { RelativeDateValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#RelativeDateValue} constructor.\n *\n * @returns The {@link obsidian#RelativeDateValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getRelativeDateValueConstructor(): ExtractConstructor<RelativeDateValue> {\n  return RelativeDateValue as ExtractConstructor<RelativeDateValue>;\n}\n", "import { StringValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#StringValue} constructor.\n *\n * @returns The {@link obsidian#StringValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getStringValueConstructor(): ExtractConstructor<StringValue> {\n  return StringValue as ExtractConstructor<StringValue>;\n}\n", "import { TagValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#TagValue} constructor.\n *\n * @returns The {@link obsidian#TagValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTagValueConstructor(): ExtractConstructor<TagValue> {\n  return TagValue as ExtractConstructor<TagValue>;\n}\n", "import { UrlValue } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#UrlValue} constructor.\n *\n * @returns The {@link obsidian#UrlValue} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getUrlValueConstructor(): ExtractConstructor<UrlValue> {\n  return UrlValue as ExtractConstructor<UrlValue>;\n}\n", "import { Value } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#Value} constructor.\n *\n * @returns The {@link obsidian#Value} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getValueConstructor(): ExtractConstructor<Value> {\n  return Value as unknown as ExtractConstructor<Value>;\n}\n", "import { EditableFileView } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#EditableFileView} constructor.\n *\n * @returns The {@link obsidian#EditableFileView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEditableFileViewConstructor(): ExtractConstructor<EditableFileView> {\n  return EditableFileView as ExtractConstructor<EditableFileView>;\n}\n", "import { MarkdownView } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link obsidian#MarkdownView} constructor.\n *\n * @returns The {@link obsidian#MarkdownView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMarkdownViewConstructor(): ExtractConstructor<MarkdownView> {\n  return MarkdownView as ExtractConstructor<MarkdownView>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { AppMenuBarManager } from '../../../internals/AppMenuBarManager.d.ts';\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link AppMenuBarManager} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link AppMenuBarManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAppMenuBarManagerConstructor(app: App): ExtractConstructor<AppMenuBarManager> {\n  return app.appMenuBarManager.constructor as ExtractConstructor<AppMenuBarManager>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { AppSetting } from '../../../internals/AppSetting.d.ts';\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link AppSetting} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link AppSetting} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAppSettingConstructor(app: App): ExtractConstructor<AppSetting> {\n  return app.setting.constructor as ExtractConstructor<AppSetting>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { Cli } from '../../../internals/cli/Cli.d.ts';\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link Cli} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link Cli} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getCliConstructor(app: App): ExtractConstructor<Cli> {\n  return app.cli.constructor as ExtractConstructor<Cli>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { Commands } from '../../../internals/commands/Commands.d.ts';\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\n\n/**\n * Get the {@link Commands} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link Commands} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getCommandsConstructor(app: App): ExtractConstructor<Commands> {\n  return app.commands.constructor as ExtractConstructor<Commands>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { CustomCSS } from '../../../internals/custom-css/CustomCSS.d.ts';\n\n/**\n * Get the {@link CustomCSS} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link CustomCSS} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getCustomCSSConstructor(app: App): ExtractConstructor<CustomCSS> {\n  return app.customCss.constructor as ExtractConstructor<CustomCSS>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { DragManager } from '../../../internals/drag-manager/DragManager.d.ts';\n\n/**\n * Get the {@link DragManager} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link DragManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getDragManagerConstructor(app: App): ExtractConstructor<DragManager> {\n  return app.dragManager.constructor as ExtractConstructor<DragManager>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { EditorSuggests } from '../../../internals/EditorSuggests.d.ts';\n\n/**\n * Get the {@link EditorSuggests} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link EditorSuggests} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEditorSuggestsConstructor(app: App): ExtractConstructor<EditorSuggests> {\n  return app.workspace.editorSuggest.constructor as ExtractConstructor<EditorSuggests>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { EmbedRegistry } from '../../../internals/embed-registry/EmbedRegistry.d.ts';\n\n/**\n * Get the {@link EmbedRegistry} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link EmbedRegistry} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEmbedRegistryConstructor(app: App): ExtractConstructor<EmbedRegistry> {\n  return app.embedRegistry.constructor as ExtractConstructor<EmbedRegistry>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { FoldManager } from '../../../internals/FoldManager.d.ts';\n\n/**\n * Get the {@link FoldManager} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link FoldManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFoldManagerConstructor(app: App): ExtractConstructor<FoldManager> {\n  return app.foldManager.constructor as ExtractConstructor<FoldManager>;\n}\n", "import type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { FrameDom } from '../../../internals/FrameDom.d.ts';\n\n/**\n * Get the {@link FrameDom} constructor.\n *\n * @returns The {@link FrameDom} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFrameDomConstructor(): ExtractConstructor<FrameDom> {\n  return window.frameDom.constructor as ExtractConstructor<FrameDom>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { HotkeyManager } from '../../../internals/hotkey-manager/HotkeyManager.d.ts';\n\n/**\n * Get the {@link HotkeyManager} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link HotkeyManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getHotkeyManagerConstructor(app: App): ExtractConstructor<HotkeyManager> {\n  return app.hotkeyManager.constructor as ExtractConstructor<HotkeyManager>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { MetadataTypeManager } from '../../../internals/metadata-type-manager/MetadataTypeManager.d.ts';\n\n/**\n * Get the {@link MetadataTypeManager} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link MetadataTypeManager} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getMetadataTypeManagerConstructor(app: App): ExtractConstructor<MetadataTypeManager> {\n  return app.metadataTypeManager.constructor as ExtractConstructor<MetadataTypeManager>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ObsidianDOM } from '../../../internals/ObsidianDOM.d.ts';\n\n/**\n * Get the {@link ObsidianDOM} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link ObsidianDOM} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getObsidianDOMConstructor(app: App): ExtractConstructor<ObsidianDOM> {\n  return app.dom.constructor as ExtractConstructor<ObsidianDOM>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { Plugins } from '../../../internals/plugins/Plugins.d.ts';\n\n/**\n * Get the {@link Plugins} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link Plugins} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getPluginsConstructor(app: App): ExtractConstructor<Plugins> {\n  return app.plugins.constructor as ExtractConstructor<Plugins>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { RecentFileTracker } from '../../../internals/RecentFileTracker.d.ts';\n\n/**\n * Get the {@link RecentFileTracker} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link RecentFileTracker} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getRecentFileTrackerConstructor(app: App): ExtractConstructor<RecentFileTracker> {\n  return app.workspace.recentFileTracker.constructor as ExtractConstructor<RecentFileTracker>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ShareReceiver } from '../../../internals/ShareReceiver.d.ts';\n\n/**\n * Get the {@link ShareReceiver} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link ShareReceiver} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getShareReceiverConstructor(app: App): ExtractConstructor<ShareReceiver> {\n  return app.shareReceiver.constructor as ExtractConstructor<ShareReceiver>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { StatusBar } from '../../../internals/StatusBar.d.ts';\n\n/**\n * Get the {@link StatusBar} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link StatusBar} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getStatusBarConstructor(app: App): ExtractConstructor<StatusBar> {\n  return app.statusBar.constructor as ExtractConstructor<StatusBar>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ViewRegistry } from '../../../internals/view-registry/ViewRegistry.d.ts';\n\n/**\n * Get the {@link ViewRegistry} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link ViewRegistry} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getViewRegistryConstructor(app: App): ExtractConstructor<ViewRegistry> {\n  return app.viewRegistry.constructor as ExtractConstructor<ViewRegistry>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { WorkspaceLeafHistory } from '../../../internals/workspace-leaf-history/WorkspaceLeafHistory.d.ts';\n\n/**\n * Get the {@link WorkspaceLeafHistory} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link WorkspaceLeafHistory} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceLeafHistoryConstructor(app: App): ExtractConstructor<WorkspaceLeafHistory> {\n  const leaf = app.workspace.getMostRecentLeaf();\n  if (!leaf) {\n    throw new Error('No workspace leaf available to extract WorkspaceLeafHistory constructor');\n  }\n  return leaf.history.constructor as ExtractConstructor<WorkspaceLeafHistory>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { BasesContext } from '../../../../../internals/internal-plugins/bases/BasesContext.d.ts';\nimport type { BasesQuery } from '../../../../../internals/internal-plugins/bases/BasesQuery.d.ts';\n\nimport { InternalPluginName } from '../../../../constants/InternalPluginName.ts';\nimport { getQueryControllerConstructor } from '../../../augmentations/bases/getQueryControllerConstructor.ts';\n\n/**\n * Get the {@link BasesContext} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link BasesContext} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesContextConstructor(app: App): ExtractConstructor<BasesContext> {\n  const basesPlugin = app.internalPlugins.getPluginById(InternalPluginName.Bases);\n  if (!basesPlugin) {\n    throw new Error(`The ${InternalPluginName.Bases} plugin is not loaded.`);\n  }\n  const queryControllerConstructor = getQueryControllerConstructor();\n  const queryController = new queryControllerConstructor(app, basesPlugin.instance, createDiv());\n  queryController.query = {} as BasesQuery;\n  const basesContext = queryController.buildBasesContext();\n  return basesContext.constructor as ExtractConstructor<BasesContext>;\n}\n", "import type { App } from 'obsidian';\n\nimport { Component } from 'obsidian';\n\nimport type { BasesQueryConstructor } from '../../../../../internals/constructors/BasesQueryConstructor.d.ts';\n\nimport { getBasesControllerFromRender } from '../../../../functions/getBasesControllerFromRender.ts';\n\n/**\n * Get the {@link BasesQuery} constructor (the `.base` parser, exposing the static `fromString`).\n *\n * `BasesQuery` has no public `obsidian` export and no leaf-free factory, so the class is harvested at\n * runtime: a throwaway base is rendered off-screen (via {@link getBasesControllerFromRender}) and the\n * constructor is read off the resulting query. The throwaway render is torn down before returning.\n *\n * @param app - The app instance.\n * @returns The {@link BasesQuery} constructor.\n *\n * @public\n * @unofficial\n */\nexport async function getBasesQueryConstructor(app: App): Promise<BasesQueryConstructor> {\n  const component = new Component();\n  try {\n    const controller = await getBasesControllerFromRender(app, 'views: []\\n', 'getBasesQueryConstructor.base', component);\n    const query = controller.query;\n    if (!query) {\n      throw new Error('The rendered base did not produce a query.');\n    }\n    return query.constructor as unknown as BasesQueryConstructor;\n  } finally {\n    component.unload();\n  }\n}\n", "import type {\n  App,\n  Component\n} from 'obsidian';\n\nimport { MarkdownRenderer } from 'obsidian';\n\nimport type { BasesController } from '../../internals/internal-plugins/bases/BasesController.d.ts';\n\n/**\n * Render a base into a detached, off-screen element and return the live {@link BasesController} that drives\n * it. This is the leaf-free route to headless base evaluation: it runs Obsidian's own base-embed processor\n * via the public {@link obsidian#MarkdownRenderer.render}, then locates the controller in the render's\n * component tree.\n *\n * The caller owns `component`'s lifecycle and MUST call `component.unload()` once done with the controller\n * (which also detaches the rendered element).\n *\n * @param app - The app instance.\n * @param content - The `.base` file content (the body of a `base` code block).\n * @param sourcePath - The path supplying the query's file context.\n * @param component - The component that owns the render; the caller unloads it.\n * @returns The live {@link BasesController} for the rendered base.\n *\n * @public\n * @unofficial\n */\nexport async function getBasesControllerFromRender(\n  app: App,\n  content: string,\n  sourcePath: string,\n  component: Component\n): Promise<BasesController> {\n  // The `_children` walk plus the controller's `query` / `results` are runtime internals not modeled on\n  // Component, so they are typed locally purely to breadth-first search the render tree.\n  interface ComponentTreeNode {\n    /** The child components, if any. */\n    _children?: ComponentTreeNode[];\n\n    /** The current query, present on a controller. */\n    query?: unknown;\n\n    /** The query results, present as a `Map` on a controller. */\n    results?: unknown;\n  }\n\n  // The element must be attached to the document (not merely detached) for the base's initial scan to run,\n  // so it is positioned off-screen rather than hidden. It is removed when the caller unloads `component`.\n  const containerEl = createDiv();\n  containerEl.style.position = 'absolute';\n  containerEl.style.left = '-9999px';\n  containerEl.style.width = '600px';\n  document.body.appendChild(containerEl);\n  component.register(() => {\n    containerEl.remove();\n  });\n\n  await MarkdownRenderer.render(app, `\\`\\`\\`base\\n${content}\\n\\`\\`\\`\\n`, containerEl, sourcePath, component);\n\n  const queue: ComponentTreeNode[] = [component as unknown as ComponentTreeNode];\n  const seen = new Set<ComponentTreeNode>();\n\n  while (queue.length > 0) {\n    const node = queue.shift();\n    if (!node || seen.has(node)) {\n      continue;\n    }\n    seen.add(node);\n\n    if (node.results instanceof Map && 'query' in node) {\n      return node as unknown as BasesController;\n    }\n\n    for (const child of node._children ?? []) {\n      queue.push(child);\n    }\n  }\n\n  throw new Error('Could not locate the BasesController in the rendered component tree.');\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { InternalPlugin } from '../../../../internals/internal-plugins/InternalPlugin.d.ts';\n\n/**\n * Get the {@link InternalPlugin} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link InternalPlugin} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getInternalPluginConstructor<Instance>(app: App): ExtractConstructor<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 anyPlugin.constructor as ExtractConstructor<InternalPlugin<Instance>>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { InternalPlugins } from '../../../../internals/internal-plugins/InternalPlugins.d.ts';\n\n/**\n * Get the {@link InternalPlugins} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link InternalPlugins} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getInternalPluginsConstructor(app: App): ExtractConstructor<InternalPlugins> {\n  return app.internalPlugins.constructor as ExtractConstructor<InternalPlugins>;\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ViewTypeType } from '../../../../internals/views/ViewTypeType.d.d.ts';\nimport type { ViewTypeViewMapping } from '../../../../internals/views/ViewTypeViewMapping.d.ts';\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 *\n * @public\n * @unofficial\n */\nexport function getViewConstructorByViewType<TViewType extends ViewTypeType>(\n  app: App,\n  viewType: TViewType\n): ExtractConstructor<ViewTypeViewMapping[TViewType]> {\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 ExtractConstructor<ViewTypeViewMapping[TViewType]>;\n  } finally {\n    leaf.detach();\n  }\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { AllPropertiesView } from '../../../../internals/internal-plugins/properties/AllPropertiesView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link AllPropertiesView} constructor.\n *\n * @param app - The app.\n * @returns The {@link AllPropertiesView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAllPropertiesViewConstructor(app: App): ExtractConstructor<AllPropertiesView> {\n  return getViewConstructorByViewType(app, ViewType.AllProperties);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { AudioView } from '../../../../internals/views/AudioView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link AudioView} constructor.\n *\n * @param app - The app.\n * @returns The {@link AudioView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getAudioViewConstructor(app: App): ExtractConstructor<AudioView> {\n  return getViewConstructorByViewType(app, ViewType.Audio);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { BacklinkView } from '../../../../internals/internal-plugins/backlink/BacklinkView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link BacklinkView} constructor.\n *\n * @param app - The app.\n * @returns The {@link BacklinkView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBacklinkViewConstructor(app: App): ExtractConstructor<BacklinkView> {\n  return getViewConstructorByViewType(app, ViewType.Backlink);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { BasesView } from '../../../../internals/internal-plugins/bases/BasesView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link BasesView} constructor.\n *\n * @param app - The app.\n * @returns The {@link BasesView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBasesViewConstructor(app: App): ExtractConstructor<BasesView> {\n  return getViewConstructorByViewType(app, ViewType.Bases);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { BookmarksView } from '../../../../internals/internal-plugins/bookmarks/BookmarksView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link BookmarksView} constructor.\n *\n * @param app - The app.\n * @returns The {@link BookmarksView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getBookmarksViewConstructor(app: App): ExtractConstructor<BookmarksView> {\n  return getViewConstructorByViewType(app, ViewType.Bookmarks);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { CanvasView } from '../../../../internals/internal-plugins/canvas/CanvasView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link CanvasView} constructor.\n *\n * @param app - The app.\n * @returns The {@link CanvasView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getCanvasViewConstructor(app: App): ExtractConstructor<CanvasView> {\n  return getViewConstructorByViewType(app, ViewType.Canvas);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { EmptyView } from '../../../../internals/views/EmptyView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link EmptyView} constructor.\n *\n * @param app - The app.\n * @returns The {@link EmptyView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getEmptyViewConstructor(app: App): ExtractConstructor<EmptyView> {\n  return getViewConstructorByViewType(app, ViewType.Empty);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { FileExplorerView } from '../../../../internals/internal-plugins/file-explorer/FileExplorerView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link FileExplorerView} constructor.\n *\n * @param app - The app.\n * @returns The {@link FileExplorerView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFileExplorerViewConstructor(app: App): ExtractConstructor<FileExplorerView> {\n  return getViewConstructorByViewType(app, ViewType.FileExplorer);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { FilePropertiesView } from '../../../../internals/internal-plugins/properties/FilePropertiesView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link FilePropertiesView} constructor.\n *\n * @param app - The app.\n * @returns The {@link FilePropertiesView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getFilePropertiesViewConstructor(app: App): ExtractConstructor<FilePropertiesView> {\n  return getViewConstructorByViewType(app, ViewType.FileProperties);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { GraphView } from '../../../../internals/internal-plugins/graph/GraphView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link GraphView} constructor.\n *\n * @param app - The app.\n * @returns The {@link GraphView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getGraphViewConstructor(app: App): ExtractConstructor<GraphView> {\n  return getViewConstructorByViewType(app, ViewType.Graph);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ImageView } from '../../../../internals/views/ImageView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link ImageView} constructor.\n *\n * @param app - The app.\n * @returns The {@link ImageView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getImageViewConstructor(app: App): ExtractConstructor<ImageView> {\n  return getViewConstructorByViewType(app, ViewType.Image);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { LocalGraphView } from '../../../../internals/internal-plugins/graph/LocalGraphView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link LocalGraphView} constructor.\n *\n * @param app - The app.\n * @returns The {@link LocalGraphView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getLocalGraphViewConstructor(app: App): ExtractConstructor<LocalGraphView> {\n  return getViewConstructorByViewType(app, ViewType.LocalGraph);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { OutgoingLinkView } from '../../../../internals/internal-plugins/outgoing-link/OutgoingLinkView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link OutgoingLinkView} constructor.\n *\n * @param app - The app.\n * @returns The {@link OutgoingLinkView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getOutgoingLinkViewConstructor(app: App): ExtractConstructor<OutgoingLinkView> {\n  return getViewConstructorByViewType(app, ViewType.OutgoingLink);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { OutlineView } from '../../../../internals/internal-plugins/outline/OutlineView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link OutlineView} constructor.\n *\n * @param app - The app.\n * @returns The {@link OutlineView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getOutlineViewConstructor(app: App): ExtractConstructor<OutlineView> {\n  return getViewConstructorByViewType(app, ViewType.Outline);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { PdfView } from '../../../../internals/views/PdfView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link PdfView} constructor.\n *\n * @param app - The app.\n * @returns The {@link PdfView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getPdfViewConstructor(app: App): ExtractConstructor<PdfView> {\n  return getViewConstructorByViewType(app, ViewType.Pdf);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { ReleaseNotesView } from '../../../../internals/views/ReleaseNotesView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link ReleaseNotesView} constructor.\n *\n * @param app - The app.\n * @returns The {@link ReleaseNotesView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getReleaseNotesViewConstructor(app: App): ExtractConstructor<ReleaseNotesView> {\n  return getViewConstructorByViewType(app, ViewType.ReleaseNotes);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { SearchView } from '../../../../internals/internal-plugins/global-search/SearchView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link SearchView} constructor.\n *\n * @param app - The app.\n * @returns The {@link SearchView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSearchViewConstructor(app: App): ExtractConstructor<SearchView> {\n  return getViewConstructorByViewType(app, ViewType.Search);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { SyncView } from '../../../../internals/internal-plugins/sync/SyncView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link SyncView} constructor.\n *\n * @param app - The app.\n * @returns The {@link SyncView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getSyncViewConstructor(app: App): ExtractConstructor<SyncView> {\n  return getViewConstructorByViewType(app, ViewType.Sync);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { TableView } from '../../../../internals/internal-plugins/bases/TableView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link TableView} constructor.\n *\n * @param app - The app.\n * @returns The {@link TableView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTableViewConstructor(app: App): ExtractConstructor<TableView> {\n  return getViewConstructorByViewType(app, ViewType.Table);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { TagView } from '../../../../internals/views/TagView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link TagView} constructor.\n *\n * @param app - The app.\n * @returns The {@link TagView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getTagViewConstructor(app: App): ExtractConstructor<TagView> {\n  return getViewConstructorByViewType(app, ViewType.Tag);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { VideoView } from '../../../../internals/views/VideoView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link VideoView} constructor.\n *\n * @param app - The app.\n * @returns The {@link VideoView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getVideoViewConstructor(app: App): ExtractConstructor<VideoView> {\n  return getViewConstructorByViewType(app, ViewType.Video);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { WebviewerHistoryView } from '../../../../internals/internal-plugins/webviewer/WebviewerHistoryView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link WebviewerHistoryView} constructor.\n *\n * @param app - The app.\n * @returns The {@link WebviewerHistoryView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWebviewerHistoryViewConstructor(app: App): ExtractConstructor<WebviewerHistoryView> {\n  return getViewConstructorByViewType(app, ViewType.WebviewerHistory);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { WebviewerView } from '../../../../internals/internal-plugins/webviewer/WebviewerView.d.ts';\n\nimport { ViewType } from '../../../constants/ViewType.ts';\nimport { getViewConstructorByViewType } from './getViewConstructorByViewType.ts';\n\n/**\n * Get the {@link WebviewerView} constructor.\n *\n * @param app - The app.\n * @returns The {@link WebviewerView} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWebviewerViewConstructor(app: App): ExtractConstructor<WebviewerView> {\n  return getViewConstructorByViewType(app, ViewType.Webviewer);\n}\n", "import type { App } from 'obsidian';\n\nimport type { ExtractConstructor } from '../../../../internals/constructors/ExtractConstructor.d.ts';\nimport type { WorkspaceProtocolHandler } from '../../../../internals/workspace/WorkspaceProtocolHandler.d.ts';\n\n/**\n * Get the {@link WorkspaceProtocolHandler} constructor.\n *\n * @param app - The app instance.\n * @returns The {@link WorkspaceProtocolHandler} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getWorkspaceProtocolHandlerConstructor(app: App): ExtractConstructor<WorkspaceProtocolHandler> {\n  return app.workspace.protocolHandler.constructor as ExtractConstructor<WorkspaceProtocolHandler>;\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 *\n * @public\n * @unofficial\n */\nexport function parentFolderPath(path: string): string {\n  return path.replace(/\\/?[^/]*$/, '') || '/';\n}\n", "import type {\n  App,\n  TFolder\n} from 'obsidian';\n\nimport { getTFolderConstructor } from '../constructors/augmentations/getTFolderConstructor.ts';\nimport { parentFolderPath } from '../utils/PathUtils.ts';\n\n/**\n * Creates and properly initializes the instance of {@link obsidian#TFolder} even the underlying folder does not exist.\n * This doesn't create the missing folder on the file system.\n *\n * @param app - The Obsidian app instance.\n * @param path - The path to the folder.\n * @returns The created {@link obsidian#TFolder} instance.\n *\n * @public\n * @unofficial\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  App,\n  TFile\n} from 'obsidian';\n\nimport { getTFileConstructor } from '../constructors/augmentations/getTFileConstructor.ts';\nimport { parentFolderPath } from '../utils/PathUtils.ts';\nimport { createTFolderInstance } from './createTFolderInstance.ts';\n\n/**\n * Creates and properly initializes the instance of {@link obsidian#TFile} even the underlying file does not exist.\n * This doesn't create the missing file on the file system.\n *\n * @param app - The Obsidian app instance.\n * @param path - The path to the file.\n * @returns The created {@link obsidian#TFile} instance.\n *\n * @public\n * @unofficial\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  App,\n  BasesEntry\n} from 'obsidian';\n\nimport { Component } from 'obsidian';\n\nimport { getBasesControllerFromRender } from './getBasesControllerFromRender.ts';\n\n/**\n * Evaluate a `.base` file in headless mode \u2014 with no leaf or open view \u2014 and return its entries.\n *\n * It renders the base off-screen via {@link getBasesControllerFromRender}, waits for the initial vault scan\n * to settle, then reads the controller's results. Everything is torn down before returning.\n *\n * @param app - The app instance.\n * @param content - The `.base` file content (the body of a `base` code block).\n * @param sourcePath - The path supplying the query's file context.\n * @returns The evaluated base entries.\n *\n * @public\n * @unofficial\n */\nexport async function evaluateBaseHeadless(app: App, content: string, sourcePath: string): Promise<BasesEntry[]> {\n  const SCAN_POLL_INTERVAL_IN_MILLISECONDS = 50;\n  const SCAN_TIMEOUT_IN_MILLISECONDS = 30000;\n\n  const component = new Component();\n  try {\n    const controller = await getBasesControllerFromRender(app, content, sourcePath, component);\n\n    const startTime = performance.now();\n    while (controller.initialScan) {\n      if (performance.now() - startTime > SCAN_TIMEOUT_IN_MILLISECONDS) {\n        throw new Error('Timed out waiting for the base initial scan to settle.');\n      }\n      await new Promise<void>((resolve) => {\n        window.setTimeout(resolve, SCAN_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return Array.from(controller.results.values());\n  } finally {\n    component.unload();\n  }\n}\n", "import type { App } from 'obsidian';\n\nimport type { DataAdapterEx } from '../../internals/DataAdapterEx.d.ts';\n\n/**\n * Get the instance of the current {@link DataAdapterEx}.\n *\n * @param app - The application instance.\n * @returns The data adapter extension.\n *\n * @public\n * @unofficial\n */\nexport function getDataAdapterEx(app: App): DataAdapterEx {\n  return app.vault.adapter as DataAdapterEx;\n}\n", "import { loadMermaid as loadMermaidOriginal } from 'obsidian';\n\nimport type { Mermaid } from '../../../mermaid/internals/Mermaid.d.ts';\n\n/**\n * Load Mermaid and return a promise to the global mermaid object.\n * Can also use `window.mermaid` after this promise resolves to get the same reference.\n *\n * @returns A promise that resolves to the global `window.mermaid` object.\n *\n * @see {@link https://mermaid.js.org/ | Official Mermaid documentation}.\n * @public\n * @unofficial\n */\nexport async function loadMermaid(): Promise<Mermaid> {\n  return (await loadMermaidOriginal()) as Mermaid;\n}\n", "import { loadPdfJs as loadPdfJsOriginal } from 'obsidian';\n\nimport type { PdfJsModule } from '../../../pdfjs-dist/internals/PdfJsModule.d.ts';\n\n/**\n * Load PDF.js and return a promise to the global pdfjsLib object.\n * Can also use `window.pdfjsLib` after this promise resolves to get the same reference.\n *\n * @returns A promise that resolves to the global `window.pdfjsLib` object.\n *\n * @see {@link https://mozilla.github.io/pdf.js/ | Official PDF.js documentation}.\n * @public\n * @unofficial\n */\nexport async function loadPdfJs(): Promise<PdfJsModule> {\n  return (await loadPdfJsOriginal()) as PdfJsModule;\n}\n", "import { loadPrism as loadPrismOriginal } from 'obsidian';\n\nimport type { PrismModule } from '../../../prismjs/internals/PrismModule.d.ts';\n\n/**\n * Load Prism.js and return a promise to the global Prism object.\n * Can also use `window.Prism` after this promise resolves to get the same reference.\n *\n * @returns A promise that resolves to the global `window.Prism` object.\n *\n * @see {@link https://prismjs.com/ | Official Prism documentation}.\n * @public\n * @unofficial\n */\nexport async function loadPrism(): Promise<PrismModule> {\n  return (await loadPrismOriginal()) as PrismModule;\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 *\n * @public\n * @unofficial\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';\n\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 *\n * @public\n * @unofficial\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 *\n * @public\n * @unofficial\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';\n\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 *\n * @public\n * @unofficial\n */\nexport function isLinkCache(reference: Reference): reference is LinkCache {\n  return isReferenceCache(reference) && reference.original[0] !== '!';\n}\n"],
  "mappings": "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",
  "names": ["Component", "MarkdownRenderer", "Component", "Component", "Component"]
}
