@obsidian-typings/obsidian-catalyst-1.15.1 0.0.0 → 1.2.0

package/dist/cjs/implementations.cjs

@@ -0,0 +1,1488 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/obsidian/implementations/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CustomArrayDictImpl: () => CustomArrayDictImpl,
+  FileExtension: () => FileExtension,
+  InternalPluginName: () => InternalPluginName,
+  ViewType: () => ViewType,
+  createTFileInstance: () => createTFileInstance,
+  createTFolderInstance: () => createTFolderInstance,
+  evaluateBaseHeadless: () => evaluateBaseHeadless,
+  getAbstractTextComponentConstructor: () => getAbstractTextComponentConstructor,
+  getAllPropertiesViewConstructor: () => getAllPropertiesViewConstructor,
+  getAppConstructor: () => getAppConstructor,
+  getAppMenuBarManagerConstructor: () => getAppMenuBarManagerConstructor,
+  getAppSettingConstructor: () => getAppSettingConstructor,
+  getAudioViewConstructor: () => getAudioViewConstructor,
+  getBacklinkViewConstructor: () => getBacklinkViewConstructor,
+  getBaseComponentConstructor: () => getBaseComponentConstructor,
+  getBasesContextConstructor: () => getBasesContextConstructor,
+  getBasesControllerFromRender: () => getBasesControllerFromRender,
+  getBasesEntryConstructor: () => getBasesEntryConstructor,
+  getBasesEntryGroupConstructor: () => getBasesEntryGroupConstructor,
+  getBasesQueryConstructor: () => getBasesQueryConstructor,
+  getBasesQueryResultConstructor: () => getBasesQueryResultConstructor,
+  getBasesViewConfigConstructor: () => getBasesViewConfigConstructor,
+  getBasesViewConstructor: () => getBasesViewConstructor,
+  getBookmarksViewConstructor: () => getBookmarksViewConstructor,
+  getBooleanValueConstructor: () => getBooleanValueConstructor,
+  getButtonComponentConstructor: () => getButtonComponentConstructor,
+  getCanvasViewConstructor: () => getCanvasViewConstructor,
+  getCapacitorAdapterConstructor: () => getCapacitorAdapterConstructor,
+  getCliConstructor: () => getCliConstructor,
+  getColorComponentConstructor: () => getColorComponentConstructor,
+  getCommandsConstructor: () => getCommandsConstructor,
+  getComponentConstructor: () => getComponentConstructor,
+  getConfirmationButtonConstructor: () => getConfirmationButtonConstructor,
+  getConfirmationModalConstructor: () => getConfirmationModalConstructor,
+  getCustomCSSConstructor: () => getCustomCSSConstructor,
+  getDataAdapterEx: () => getDataAdapterEx,
+  getDateValueConstructor: () => getDateValueConstructor,
+  getDisplayValueComponentConstructor: () => getDisplayValueComponentConstructor,
+  getDragManagerConstructor: () => getDragManagerConstructor,
+  getDropdownComponentConstructor: () => getDropdownComponentConstructor,
+  getDurationValueConstructor: () => getDurationValueConstructor,
+  getEditableFileViewConstructor: () => getEditableFileViewConstructor,
+  getEditorConstructor: () => getEditorConstructor,
+  getEditorSuggestsConstructor: () => getEditorSuggestsConstructor,
+  getEmbedRegistryConstructor: () => getEmbedRegistryConstructor,
+  getEmptyViewConstructor: () => getEmptyViewConstructor,
+  getEventsConstructor: () => getEventsConstructor,
+  getExtraButtonComponentConstructor: () => getExtraButtonComponentConstructor,
+  getFileExplorerViewConstructor: () => getFileExplorerViewConstructor,
+  getFileManagerConstructor: () => getFileManagerConstructor,
+  getFilePropertiesViewConstructor: () => getFilePropertiesViewConstructor,
+  getFileSystemAdapterConstructor: () => getFileSystemAdapterConstructor,
+  getFileValueConstructor: () => getFileValueConstructor,
+  getFoldManagerConstructor: () => getFoldManagerConstructor,
+  getFrameDomConstructor: () => getFrameDomConstructor,
+  getFuzzySuggestModalConstructor: () => getFuzzySuggestModalConstructor,
+  getGraphViewConstructor: () => getGraphViewConstructor,
+  getHTMLValueConstructor: () => getHTMLValueConstructor,
+  getHotkeyManagerConstructor: () => getHotkeyManagerConstructor,
+  getHoverPopoverConstructor: () => getHoverPopoverConstructor,
+  getIconValueConstructor: () => getIconValueConstructor,
+  getImageValueConstructor: () => getImageValueConstructor,
+  getImageViewConstructor: () => getImageViewConstructor,
+  getInternalPluginConstructor: () => getInternalPluginConstructor,
+  getInternalPluginsConstructor: () => getInternalPluginsConstructor,
+  getKeymapConstructor: () => getKeymapConstructor,
+  getLinkValueConstructor: () => getLinkValueConstructor,
+  getListValueConstructor: () => getListValueConstructor,
+  getLocalGraphViewConstructor: () => getLocalGraphViewConstructor,
+  getMarkdownPreviewRendererConstructor: () => getMarkdownPreviewRendererConstructor,
+  getMarkdownPreviewViewConstructor: () => getMarkdownPreviewViewConstructor,
+  getMarkdownRenderChildConstructor: () => getMarkdownRenderChildConstructor,
+  getMarkdownRendererConstructor: () => getMarkdownRendererConstructor,
+  getMarkdownViewConstructor: () => getMarkdownViewConstructor,
+  getMenuConstructor: () => getMenuConstructor,
+  getMenuItemConstructor: () => getMenuItemConstructor,
+  getMenuSeparatorConstructor: () => getMenuSeparatorConstructor,
+  getMetadataCacheConstructor: () => getMetadataCacheConstructor,
+  getMetadataTypeManagerConstructor: () => getMetadataTypeManagerConstructor,
+  getModalConstructor: () => getModalConstructor,
+  getMomentFormatComponentConstructor: () => getMomentFormatComponentConstructor,
+  getNotNullValueConstructor: () => getNotNullValueConstructor,
+  getNoticeConstructor: () => getNoticeConstructor,
+  getNullValueConstructor: () => getNullValueConstructor,
+  getNumberValueConstructor: () => getNumberValueConstructor,
+  getObjectValueConstructor: () => getObjectValueConstructor,
+  getObsidianDOMConstructor: () => getObsidianDOMConstructor,
+  getObsidianSearchQueryConstructor: () => getObsidianSearchQueryConstructor,
+  getOutgoingLinkViewConstructor: () => getOutgoingLinkViewConstructor,
+  getOutlineViewConstructor: () => getOutlineViewConstructor,
+  getPdfViewConstructor: () => getPdfViewConstructor,
+  getPlatformEx: () => getPlatformEx,
+  getPluginsConstructor: () => getPluginsConstructor,
+  getProgressBarComponentConstructor: () => getProgressBarComponentConstructor,
+  getQueryControllerConstructor: () => getQueryControllerConstructor,
+  getRecentFileTrackerConstructor: () => getRecentFileTrackerConstructor,
+  getRegExpValueConstructor: () => getRegExpValueConstructor,
+  getRelativeDateValueConstructor: () => getRelativeDateValueConstructor,
+  getReleaseNotesViewConstructor: () => getReleaseNotesViewConstructor,
+  getRenderContextConstructor: () => getRenderContextConstructor,
+  getScopeConstructor: () => getScopeConstructor,
+  getSearchComponentConstructor: () => getSearchComponentConstructor,
+  getSearchMatcherGuards: () => getSearchMatcherGuards,
+  getSearchViewConstructor: () => getSearchViewConstructor,
+  getSecretComponentConstructor: () => getSecretComponentConstructor,
+  getSecretStorageConstructor: () => getSecretStorageConstructor,
+  getSettingConstructor: () => getSettingConstructor,
+  getSettingGroupConstructor: () => getSettingGroupConstructor,
+  getSettingPageConstructor: () => getSettingPageConstructor,
+  getSettingTabConstructor: () => getSettingTabConstructor,
+  getShareReceiverConstructor: () => getShareReceiverConstructor,
+  getSliderComponentConstructor: () => getSliderComponentConstructor,
+  getStatusBarConstructor: () => getStatusBarConstructor,
+  getStringValueConstructor: () => getStringValueConstructor,
+  getSyncViewConstructor: () => getSyncViewConstructor,
+  getTAbstractFileConstructor: () => getTAbstractFileConstructor,
+  getTFileConstructor: () => getTFileConstructor,
+  getTFolderConstructor: () => getTFolderConstructor,
+  getTagValueConstructor: () => getTagValueConstructor,
+  getTagViewConstructor: () => getTagViewConstructor,
+  getTasksConstructor: () => getTasksConstructor,
+  getTextAreaComponentConstructor: () => getTextAreaComponentConstructor,
+  getTextComponentConstructor: () => getTextComponentConstructor,
+  getToggleComponentConstructor: () => getToggleComponentConstructor,
+  getUrlValueConstructor: () => getUrlValueConstructor,
+  getValueComponentConstructor: () => getValueComponentConstructor,
+  getValueConstructor: () => getValueConstructor,
+  getVaultConstructor: () => getVaultConstructor,
+  getVideoViewConstructor: () => getVideoViewConstructor,
+  getViewConstructorByViewType: () => getViewConstructorByViewType,
+  getViewRegistryConstructor: () => getViewRegistryConstructor,
+  getWebviewerHistoryViewConstructor: () => getWebviewerHistoryViewConstructor,
+  getWebviewerViewConstructor: () => getWebviewerViewConstructor,
+  getWorkspaceConstructor: () => getWorkspaceConstructor,
+  getWorkspaceContainerConstructor: () => getWorkspaceContainerConstructor,
+  getWorkspaceFloatingConstructor: () => getWorkspaceFloatingConstructor,
+  getWorkspaceItemConstructor: () => getWorkspaceItemConstructor,
+  getWorkspaceLeafConstructor: () => getWorkspaceLeafConstructor,
+  getWorkspaceLeafHistoryConstructor: () => getWorkspaceLeafHistoryConstructor,
+  getWorkspaceMobileDrawerConstructor: () => getWorkspaceMobileDrawerConstructor,
+  getWorkspaceParentConstructor: () => getWorkspaceParentConstructor,
+  getWorkspaceProtocolHandlerConstructor: () => getWorkspaceProtocolHandlerConstructor,
+  getWorkspaceRibbonConstructor: () => getWorkspaceRibbonConstructor,
+  getWorkspaceRootConstructor: () => getWorkspaceRootConstructor,
+  getWorkspaceSidedockConstructor: () => getWorkspaceSidedockConstructor,
+  getWorkspaceSplitConstructor: () => getWorkspaceSplitConstructor,
+  getWorkspaceTabsConstructor: () => getWorkspaceTabsConstructor,
+  getWorkspaceWindowConstructor: () => getWorkspaceWindowConstructor,
+  isEmbedCache: () => isEmbedCache,
+  isFrontmatterLinkCache: () => isFrontmatterLinkCache,
+  isLayoutReady: () => isLayoutReady,
+  isLinkCache: () => isLinkCache,
+  isReferenceCache: () => isReferenceCache,
+  loadMermaid: () => loadMermaid,
+  loadPdfJs: () => loadPdfJs,
+  loadPrism: () => loadPrism,
+  onLayoutReadyEx: () => onLayoutReadyEx,
+  parentFolderPath: () => parentFolderPath
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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",
+  Tag: "tag",
+  Video: "video",
+  Webviewer: "webviewer",
+  WebviewerHistory: "webviewer-history"
+};
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesEntryConstructor.ts
+var import_obsidian = require("obsidian");
+function getBasesEntryConstructor() {
+  return import_obsidian.BasesEntry;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesEntryGroupConstructor.ts
+var import_obsidian2 = require("obsidian");
+function getBasesEntryGroupConstructor() {
+  return import_obsidian2.BasesEntryGroup;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesQueryResultConstructor.ts
+var import_obsidian3 = require("obsidian");
+function getBasesQueryResultConstructor() {
+  return import_obsidian3.BasesQueryResult;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getBasesViewConfigConstructor.ts
+var import_obsidian4 = require("obsidian");
+function getBasesViewConfigConstructor() {
+  return import_obsidian4.BasesViewConfig;
+}
+
+// src/obsidian/implementations/constructors/augmentations/bases/getQueryControllerConstructor.ts
+var import_obsidian5 = require("obsidian");
+function getQueryControllerConstructor() {
+  return import_obsidian5.QueryController;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getAppConstructor.ts
+var import_obsidian6 = require("obsidian");
+function getAppConstructor() {
+  return import_obsidian6.App;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getCapacitorAdapterConstructor.ts
+var import_obsidian7 = require("obsidian");
+function getCapacitorAdapterConstructor() {
+  return import_obsidian7.CapacitorAdapter;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getConfirmationModalConstructor.ts
+var import_obsidian8 = require("obsidian");
+function getConfirmationModalConstructor() {
+  return import_obsidian8.ConfirmationModal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getEditorConstructor.ts
+var import_obsidian9 = require("obsidian");
+function getEditorConstructor() {
+  return import_obsidian9.Editor;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getEventsConstructor.ts
+var import_obsidian10 = require("obsidian");
+function getEventsConstructor() {
+  return import_obsidian10.Events;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFileManagerConstructor.ts
+var import_obsidian11 = require("obsidian");
+function getFileManagerConstructor() {
+  return import_obsidian11.FileManager;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFileSystemAdapterConstructor.ts
+var import_obsidian12 = require("obsidian");
+function getFileSystemAdapterConstructor() {
+  return import_obsidian12.FileSystemAdapter;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getFuzzySuggestModalConstructor.ts
+var import_obsidian13 = require("obsidian");
+function getFuzzySuggestModalConstructor() {
+  return import_obsidian13.FuzzySuggestModal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getHoverPopoverConstructor.ts
+var import_obsidian14 = require("obsidian");
+function getHoverPopoverConstructor() {
+  return import_obsidian14.HoverPopover;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getKeymapConstructor.ts
+var import_obsidian15 = require("obsidian");
+function getKeymapConstructor() {
+  return import_obsidian15.Keymap;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewRendererConstructor.ts
+var import_obsidian16 = require("obsidian");
+function getMarkdownPreviewRendererConstructor() {
+  return import_obsidian16.MarkdownPreviewRenderer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownPreviewViewConstructor.ts
+var import_obsidian17 = require("obsidian");
+function getMarkdownPreviewViewConstructor() {
+  return import_obsidian17.MarkdownPreviewView;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownRenderChildConstructor.ts
+var import_obsidian18 = require("obsidian");
+function getMarkdownRenderChildConstructor() {
+  return import_obsidian18.MarkdownRenderChild;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMarkdownRendererConstructor.ts
+var import_obsidian19 = require("obsidian");
+function getMarkdownRendererConstructor() {
+  return import_obsidian19.MarkdownRenderer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuConstructor.ts
+var import_obsidian20 = require("obsidian");
+function getMenuConstructor() {
+  return import_obsidian20.Menu;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuItemConstructor.ts
+var import_obsidian21 = require("obsidian");
+function getMenuItemConstructor() {
+  return import_obsidian21.MenuItem;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMenuSeparatorConstructor.ts
+var import_obsidian22 = require("obsidian");
+function getMenuSeparatorConstructor() {
+  return import_obsidian22.MenuSeparator;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getMetadataCacheConstructor.ts
+var import_obsidian23 = require("obsidian");
+function getMetadataCacheConstructor() {
+  return import_obsidian23.MetadataCache;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getModalConstructor.ts
+var import_obsidian24 = require("obsidian");
+function getModalConstructor() {
+  return import_obsidian24.Modal;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getNoticeConstructor.ts
+var import_obsidian25 = require("obsidian");
+function getNoticeConstructor() {
+  return import_obsidian25.Notice;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getRenderContextConstructor.ts
+var import_obsidian26 = require("obsidian");
+function getRenderContextConstructor() {
+  return import_obsidian26.RenderContext;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getScopeConstructor.ts
+var import_obsidian27 = require("obsidian");
+function getScopeConstructor() {
+  return import_obsidian27.Scope;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSecretStorageConstructor.ts
+var import_obsidian28 = require("obsidian");
+function getSecretStorageConstructor() {
+  return import_obsidian28.SecretStorage;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingConstructor.ts
+var import_obsidian29 = require("obsidian");
+function getSettingConstructor() {
+  return import_obsidian29.Setting;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingGroupConstructor.ts
+var import_obsidian30 = require("obsidian");
+function getSettingGroupConstructor() {
+  return import_obsidian30.SettingGroup;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingPageConstructor.ts
+var import_obsidian31 = require("obsidian");
+function getSettingPageConstructor() {
+  return import_obsidian31.SettingPage;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getSettingTabConstructor.ts
+var import_obsidian32 = require("obsidian");
+function getSettingTabConstructor() {
+  return import_obsidian32.SettingTab;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTAbstractFileConstructor.ts
+var import_obsidian33 = require("obsidian");
+function getTAbstractFileConstructor() {
+  return import_obsidian33.TAbstractFile;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTasksConstructor.ts
+var import_obsidian34 = require("obsidian");
+function getTasksConstructor() {
+  return import_obsidian34.Tasks;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTFileConstructor.ts
+var import_obsidian35 = require("obsidian");
+function getTFileConstructor() {
+  return import_obsidian35.TFile;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getTFolderConstructor.ts
+var import_obsidian36 = require("obsidian");
+function getTFolderConstructor() {
+  return import_obsidian36.TFolder;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getVaultConstructor.ts
+var import_obsidian37 = require("obsidian");
+function getVaultConstructor() {
+  return import_obsidian37.Vault;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceConstructor.ts
+var import_obsidian38 = require("obsidian");
+function getWorkspaceConstructor() {
+  return import_obsidian38.Workspace;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceContainerConstructor.ts
+var import_obsidian39 = require("obsidian");
+function getWorkspaceContainerConstructor() {
+  return import_obsidian39.WorkspaceContainer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceFloatingConstructor.ts
+var import_obsidian40 = require("obsidian");
+function getWorkspaceFloatingConstructor() {
+  return import_obsidian40.WorkspaceFloating;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceItemConstructor.ts
+var import_obsidian41 = require("obsidian");
+function getWorkspaceItemConstructor() {
+  return import_obsidian41.WorkspaceItem;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceLeafConstructor.ts
+var import_obsidian42 = require("obsidian");
+function getWorkspaceLeafConstructor() {
+  return import_obsidian42.WorkspaceLeaf;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceMobileDrawerConstructor.ts
+var import_obsidian43 = require("obsidian");
+function getWorkspaceMobileDrawerConstructor() {
+  return import_obsidian43.WorkspaceMobileDrawer;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceParentConstructor.ts
+var import_obsidian44 = require("obsidian");
+function getWorkspaceParentConstructor() {
+  return import_obsidian44.WorkspaceParent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceRibbonConstructor.ts
+var import_obsidian45 = require("obsidian");
+function getWorkspaceRibbonConstructor() {
+  return import_obsidian45.WorkspaceRibbon;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceRootConstructor.ts
+var import_obsidian46 = require("obsidian");
+function getWorkspaceRootConstructor() {
+  return import_obsidian46.WorkspaceRoot;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceSidedockConstructor.ts
+var import_obsidian47 = require("obsidian");
+function getWorkspaceSidedockConstructor() {
+  return import_obsidian47.WorkspaceSidedock;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceSplitConstructor.ts
+var import_obsidian48 = require("obsidian");
+function getWorkspaceSplitConstructor() {
+  return import_obsidian48.WorkspaceSplit;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceTabsConstructor.ts
+var import_obsidian49 = require("obsidian");
+function getWorkspaceTabsConstructor() {
+  return import_obsidian49.WorkspaceTabs;
+}
+
+// src/obsidian/implementations/constructors/augmentations/getWorkspaceWindowConstructor.ts
+var import_obsidian50 = require("obsidian");
+function getWorkspaceWindowConstructor() {
+  return import_obsidian50.WorkspaceWindow;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getAbstractTextComponentConstructor.ts
+var import_obsidian51 = require("obsidian");
+function getAbstractTextComponentConstructor() {
+  return import_obsidian51.AbstractTextComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getBaseComponentConstructor.ts
+var import_obsidian52 = require("obsidian");
+function getBaseComponentConstructor() {
+  return import_obsidian52.BaseComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getButtonComponentConstructor.ts
+var import_obsidian53 = require("obsidian");
+function getButtonComponentConstructor() {
+  return import_obsidian53.ButtonComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getColorComponentConstructor.ts
+var import_obsidian54 = require("obsidian");
+function getColorComponentConstructor() {
+  return import_obsidian54.ColorComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getComponentConstructor.ts
+var import_obsidian55 = require("obsidian");
+function getComponentConstructor() {
+  return import_obsidian55.Component;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getConfirmationButtonConstructor.ts
+var import_obsidian56 = require("obsidian");
+function getConfirmationButtonConstructor() {
+  return import_obsidian56.ConfirmationButton;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDisplayValueComponentConstructor.ts
+var import_obsidian57 = require("obsidian");
+function getDisplayValueComponentConstructor() {
+  return import_obsidian57.DisplayValueComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getDropdownComponentConstructor.ts
+var import_obsidian58 = require("obsidian");
+function getDropdownComponentConstructor() {
+  return import_obsidian58.DropdownComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getExtraButtonComponentConstructor.ts
+var import_obsidian59 = require("obsidian");
+function getExtraButtonComponentConstructor() {
+  return import_obsidian59.ExtraButtonComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getMomentFormatComponentConstructor.ts
+var import_obsidian60 = require("obsidian");
+function getMomentFormatComponentConstructor() {
+  return import_obsidian60.MomentFormatComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getProgressBarComponentConstructor.ts
+var import_obsidian61 = require("obsidian");
+function getProgressBarComponentConstructor() {
+  return import_obsidian61.ProgressBarComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSearchComponentConstructor.ts
+var import_obsidian62 = require("obsidian");
+function getSearchComponentConstructor() {
+  return import_obsidian62.SearchComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSecretComponentConstructor.ts
+var import_obsidian63 = require("obsidian");
+function getSecretComponentConstructor() {
+  return import_obsidian63.SecretComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getSliderComponentConstructor.ts
+var import_obsidian64 = require("obsidian");
+function getSliderComponentConstructor() {
+  return import_obsidian64.SliderComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextAreaComponentConstructor.ts
+var import_obsidian65 = require("obsidian");
+function getTextAreaComponentConstructor() {
+  return import_obsidian65.TextAreaComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getTextComponentConstructor.ts
+var import_obsidian66 = require("obsidian");
+function getTextComponentConstructor() {
+  return import_obsidian66.TextComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getToggleComponentConstructor.ts
+var import_obsidian67 = require("obsidian");
+function getToggleComponentConstructor() {
+  return import_obsidian67.ToggleComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/settings/setting-components/getValueComponentConstructor.ts
+var import_obsidian68 = require("obsidian");
+function getValueComponentConstructor() {
+  return import_obsidian68.ValueComponent;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getBooleanValueConstructor.ts
+var import_obsidian69 = require("obsidian");
+function getBooleanValueConstructor() {
+  return import_obsidian69.BooleanValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getDateValueConstructor.ts
+var import_obsidian70 = require("obsidian");
+function getDateValueConstructor() {
+  return import_obsidian70.DateValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getDurationValueConstructor.ts
+var import_obsidian71 = require("obsidian");
+function getDurationValueConstructor() {
+  return import_obsidian71.DurationValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getFileValueConstructor.ts
+var import_obsidian72 = require("obsidian");
+function getFileValueConstructor() {
+  return import_obsidian72.FileValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getHTMLValueConstructor.ts
+var import_obsidian73 = require("obsidian");
+function getHTMLValueConstructor() {
+  return import_obsidian73.HTMLValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getIconValueConstructor.ts
+var import_obsidian74 = require("obsidian");
+function getIconValueConstructor() {
+  return import_obsidian74.IconValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getImageValueConstructor.ts
+var import_obsidian75 = require("obsidian");
+function getImageValueConstructor() {
+  return import_obsidian75.ImageValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getLinkValueConstructor.ts
+var import_obsidian76 = require("obsidian");
+function getLinkValueConstructor() {
+  return import_obsidian76.LinkValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getListValueConstructor.ts
+var import_obsidian77 = require("obsidian");
+function getListValueConstructor() {
+  return import_obsidian77.ListValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNotNullValueConstructor.ts
+var import_obsidian78 = require("obsidian");
+function getNotNullValueConstructor() {
+  return import_obsidian78.NotNullValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNullValueConstructor.ts
+var import_obsidian79 = require("obsidian");
+function getNullValueConstructor() {
+  return import_obsidian79.NullValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getNumberValueConstructor.ts
+var import_obsidian80 = require("obsidian");
+function getNumberValueConstructor() {
+  return import_obsidian80.NumberValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getObjectValueConstructor.ts
+var import_obsidian81 = require("obsidian");
+function getObjectValueConstructor() {
+  return import_obsidian81.ObjectValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getRegExpValueConstructor.ts
+var import_obsidian82 = require("obsidian");
+function getRegExpValueConstructor() {
+  return import_obsidian82.RegExpValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getRelativeDateValueConstructor.ts
+var import_obsidian83 = require("obsidian");
+function getRelativeDateValueConstructor() {
+  return import_obsidian83.RelativeDateValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getStringValueConstructor.ts
+var import_obsidian84 = require("obsidian");
+function getStringValueConstructor() {
+  return import_obsidian84.StringValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getTagValueConstructor.ts
+var import_obsidian85 = require("obsidian");
+function getTagValueConstructor() {
+  return import_obsidian85.TagValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getUrlValueConstructor.ts
+var import_obsidian86 = require("obsidian");
+function getUrlValueConstructor() {
+  return import_obsidian86.UrlValue;
+}
+
+// src/obsidian/implementations/constructors/augmentations/values/getValueConstructor.ts
+var import_obsidian87 = require("obsidian");
+function getValueConstructor() {
+  return import_obsidian87.Value;
+}
+
+// src/obsidian/implementations/constructors/augmentations/views/getEditableFileViewConstructor.ts
+var import_obsidian88 = require("obsidian");
+function getEditableFileViewConstructor() {
+  return import_obsidian88.EditableFileView;
+}
+
+// src/obsidian/implementations/constructors/augmentations/views/getMarkdownViewConstructor.ts
+var import_obsidian89 = require("obsidian");
+function getMarkdownViewConstructor() {
+  return import_obsidian89.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/getObsidianSearchQueryConstructor.ts
+function getObsidianSearchQueryConstructor(app) {
+  const leaf = app.workspace.createLeafInTabGroup();
+  try {
+    const viewCreator = app.viewRegistry.getViewCreatorByType(ViewType.FileExplorer);
+    if (!viewCreator) {
+      throw new Error("View creator not found");
+    }
+    const view = viewCreator(leaf);
+    view.onSearchChanged("probe");
+    if (!view.searchQuery) {
+      throw new Error("The probe query did not compile.");
+    }
+    return view.searchQuery.constructor;
+  } finally {
+    leaf.detach();
+  }
+}
+
+// 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
+var import_obsidian91 = require("obsidian");
+
+// src/obsidian/implementations/functions/getBasesControllerFromRender.ts
+var import_obsidian90 = require("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 import_obsidian90.MarkdownRenderer.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 QueryController in the rendered component tree.");
+}
+
+// src/obsidian/implementations/constructors/internals/internal-plugins/bases/getBasesQueryConstructor.ts
+async function getBasesQueryConstructor(app) {
+  const component = new import_obsidian91.Component();
+  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/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
+var import_obsidian92 = require("obsidian");
+async function evaluateBaseHeadless(app, baseOrContent, sourcePath) {
+  const SCAN_POLL_INTERVAL_IN_MILLISECONDS = 50;
+  const SCAN_TIMEOUT_IN_MILLISECONDS = 3e4;
+  let content;
+  let querySourcePath;
+  if (sourcePath === void 0) {
+    const file = typeof baseOrContent === "string" ? app.vault.getAbstractFileByPath(baseOrContent) : baseOrContent;
+    if (!(file instanceof import_obsidian92.TFile)) {
+      throw new Error(`No .base file exists at '${String(baseOrContent)}'.`);
+    }
+    if (file.extension !== "base") {
+      throw new Error(`'${file.path}' is not a .base file.`);
+    }
+    content = await app.vault.cachedRead(file);
+    querySourcePath = file.path;
+  } else {
+    if (typeof baseOrContent !== "string") {
+      throw new Error("Pass the .base file on its own, without a source path.");
+    }
+    content = baseOrContent;
+    querySourcePath = sourcePath;
+  }
+  const component = new import_obsidian92.Component();
+  try {
+    const controller = await getBasesControllerFromRender(app, content, querySourcePath, 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/getPlatformEx.ts
+var import_obsidian93 = require("obsidian");
+function getPlatformEx() {
+  return import_obsidian93.Platform;
+}
+
+// src/obsidian/implementations/functions/loadMermaid.ts
+var import_obsidian94 = require("obsidian");
+async function loadMermaid() {
+  return await (0, import_obsidian94.loadMermaid)();
+}
+
+// src/obsidian/implementations/functions/loadPdfJs.ts
+var import_obsidian95 = require("obsidian");
+async function loadPdfJs() {
+  return await (0, import_obsidian95.loadPdfJs)();
+}
+
+// src/obsidian/implementations/functions/loadPrism.ts
+var import_obsidian96 = require("obsidian");
+async function loadPrism() {
+  return await (0, import_obsidian96.loadPrism)();
+}
+
+// src/obsidian/implementations/functions/onLayoutReadyEx.ts
+function onLayoutReadyEx(workspace, callback) {
+  workspace.onLayoutReady(() => callback(workspace));
+}
+
+// src/obsidian/implementations/type-guards/getSearchMatcherGuards.ts
+function getSearchMatcherGuards(app) {
+  const Query = getObsidianSearchQueryConstructor(app);
+  return {
+    and: guard("alpha bravo"),
+    case: guard("match-case:alpha"),
+    comparison: guard("[alpha:>bravo]", "value"),
+    content: guard("content:alpha"),
+    file: guard("file:alpha"),
+    negation: guard("-alpha"),
+    or: guard("alpha OR bravo"),
+    path: guard("path:alpha"),
+    property: guard("[alpha]"),
+    quotedText: guard('"alpha"'),
+    regex: guard("/alpha/"),
+    tag: guard("tag:alpha"),
+    text: guard("alpha")
+  };
+  function guard(query, child) {
+    const probe = new Query(app, query, false).matcher;
+    if (!probe) {
+      throw new Error("The matcher probe did not compile.");
+    }
+    if (child && !(child in probe)) {
+      throw new Error("The matcher probe has no value node.");
+    }
+    const node = child && child in probe ? probe[child] : probe;
+    if (!node || typeof node !== "object") {
+      throw new Error("The matcher probe has no value matcher.");
+    }
+    const prototype = Object.getPrototypeOf(node);
+    return (matcher) => Object.getPrototypeOf(matcher) === prototype;
+  }
+}
+
+// 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/isLayoutReady.ts
+function isLayoutReady(workspace) {
+  return workspace.layoutReady;
+}
+
+// src/obsidian/implementations/type-guards/isLinkCache.ts
+function isLinkCache(reference) {
+  return isReferenceCache(reference) && reference.original[0] !== "!";
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/obsidian/implementations/index.ts", "../../src/obsidian/implementations/classes/CustomArrayDictImpl.ts", "../../src/obsidian/implementations/constants/FileExtension.ts", "../../src/obsidian/implementations/constants/InternalPluginName.ts", "../../src/obsidian/implementations/constants/ViewType.ts", "../../src/obsidian/implementations/constructors/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/getObsidianSearchQueryConstructor.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/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/getPlatformEx.ts", "../../src/obsidian/implementations/functions/loadMermaid.ts", "../../src/obsidian/implementations/functions/loadPdfJs.ts", "../../src/obsidian/implementations/functions/loadPrism.ts", "../../src/obsidian/implementations/functions/onLayoutReadyEx.ts", "../../src/obsidian/implementations/type-guards/getSearchMatcherGuards.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/isLayoutReady.ts", "../../src/obsidian/implementations/type-guards/isLinkCache.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * from './classes/CustomArrayDictImpl.ts';\nexport * from './constants/FileExtension.ts';\nexport * from './constants/InternalPluginName.ts';\nexport * from './constants/ViewType.ts';\nexport * from './constructors/augmentations/bases/getBasesEntryConstructor.ts';\nexport * from './constructors/augmentations/bases/getBasesEntryGroupConstructor.ts';\nexport * from './constructors/augmentations/bases/getBasesQueryResultConstructor.ts';\nexport * from './constructors/augmentations/bases/getBasesViewConfigConstructor.ts';\nexport * from './constructors/augmentations/bases/getQueryControllerConstructor.ts';\nexport * from './constructors/augmentations/getAppConstructor.ts';\nexport * from './constructors/augmentations/getCapacitorAdapterConstructor.ts';\nexport * from './constructors/augmentations/getConfirmationModalConstructor.ts';\nexport * from './constructors/augmentations/getEditorConstructor.ts';\nexport * from './constructors/augmentations/getEventsConstructor.ts';\nexport * from './constructors/augmentations/getFileManagerConstructor.ts';\nexport * from './constructors/augmentations/getFileSystemAdapterConstructor.ts';\nexport * from './constructors/augmentations/getFuzzySuggestModalConstructor.ts';\nexport * from './constructors/augmentations/getHoverPopoverConstructor.ts';\nexport * from './constructors/augmentations/getKeymapConstructor.ts';\nexport * from './constructors/augmentations/getMarkdownPreviewRendererConstructor.ts';\nexport * from './constructors/augmentations/getMarkdownPreviewViewConstructor.ts';\nexport * from './constructors/augmentations/getMarkdownRenderChildConstructor.ts';\nexport * from './constructors/augmentations/getMarkdownRendererConstructor.ts';\nexport * from './constructors/augmentations/getMenuConstructor.ts';\nexport * from './constructors/augmentations/getMenuItemConstructor.ts';\nexport * from './constructors/augmentations/getMenuSeparatorConstructor.ts';\nexport * from './constructors/augmentations/getMetadataCacheConstructor.ts';\nexport * from './constructors/augmentations/getModalConstructor.ts';\nexport * from './constructors/augmentations/getNoticeConstructor.ts';\nexport * from './constructors/augmentations/getRenderContextConstructor.ts';\nexport * from './constructors/augmentations/getScopeConstructor.ts';\nexport * from './constructors/augmentations/getSecretStorageConstructor.ts';\nexport * from './constructors/augmentations/getSettingConstructor.ts';\nexport * from './constructors/augmentations/getSettingGroupConstructor.ts';\nexport * from './constructors/augmentations/getSettingPageConstructor.ts';\nexport * from './constructors/augmentations/getSettingTabConstructor.ts';\nexport * from './constructors/augmentations/getTAbstractFileConstructor.ts';\nexport * from './constructors/augmentations/getTasksConstructor.ts';\nexport * from './constructors/augmentations/getTFileConstructor.ts';\nexport * from './constructors/augmentations/getTFolderConstructor.ts';\nexport * from './constructors/augmentations/getVaultConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceContainerConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceFloatingConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceItemConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceLeafConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceMobileDrawerConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceParentConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceRibbonConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceRootConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceSidedockConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceSplitConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceTabsConstructor.ts';\nexport * from './constructors/augmentations/getWorkspaceWindowConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getAbstractTextComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getBaseComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getButtonComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getColorComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getConfirmationButtonConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getDisplayValueComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getDropdownComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getExtraButtonComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getMomentFormatComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getProgressBarComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getSearchComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getSecretComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getSliderComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getTextAreaComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getTextComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getToggleComponentConstructor.ts';\nexport * from './constructors/augmentations/settings/setting-components/getValueComponentConstructor.ts';\nexport * from './constructors/augmentations/values/getBooleanValueConstructor.ts';\nexport * from './constructors/augmentations/values/getDateValueConstructor.ts';\nexport * from './constructors/augmentations/values/getDurationValueConstructor.ts';\nexport * from './constructors/augmentations/values/getFileValueConstructor.ts';\nexport * from './constructors/augmentations/values/getHTMLValueConstructor.ts';\nexport * from './constructors/augmentations/values/getIconValueConstructor.ts';\nexport * from './constructors/augmentations/values/getImageValueConstructor.ts';\nexport * from './constructors/augmentations/values/getLinkValueConstructor.ts';\nexport * from './constructors/augmentations/values/getListValueConstructor.ts';\nexport * from './constructors/augmentations/values/getNotNullValueConstructor.ts';\nexport * from './constructors/augmentations/values/getNullValueConstructor.ts';\nexport * from './constructors/augmentations/values/getNumberValueConstructor.ts';\nexport * from './constructors/augmentations/values/getObjectValueConstructor.ts';\nexport * from './constructors/augmentations/values/getRegExpValueConstructor.ts';\nexport * from './constructors/augmentations/values/getRelativeDateValueConstructor.ts';\nexport * from './constructors/augmentations/values/getStringValueConstructor.ts';\nexport * from './constructors/augmentations/values/getTagValueConstructor.ts';\nexport * from './constructors/augmentations/values/getUrlValueConstructor.ts';\nexport * from './constructors/augmentations/values/getValueConstructor.ts';\nexport * from './constructors/augmentations/views/getEditableFileViewConstructor.ts';\nexport * from './constructors/augmentations/views/getMarkdownViewConstructor.ts';\nexport * from './constructors/internals/getAppMenuBarManagerConstructor.ts';\nexport * from './constructors/internals/getAppSettingConstructor.ts';\nexport * from './constructors/internals/getCliConstructor.ts';\nexport * from './constructors/internals/getCommandsConstructor.ts';\nexport * from './constructors/internals/getCustomCSSConstructor.ts';\nexport * from './constructors/internals/getDragManagerConstructor.ts';\nexport * from './constructors/internals/getEditorSuggestsConstructor.ts';\nexport * from './constructors/internals/getEmbedRegistryConstructor.ts';\nexport * from './constructors/internals/getFoldManagerConstructor.ts';\nexport * from './constructors/internals/getFrameDomConstructor.ts';\nexport * from './constructors/internals/getHotkeyManagerConstructor.ts';\nexport * from './constructors/internals/getMetadataTypeManagerConstructor.ts';\nexport * from './constructors/internals/getObsidianDOMConstructor.ts';\nexport * from './constructors/internals/getObsidianSearchQueryConstructor.ts';\nexport * from './constructors/internals/getPluginsConstructor.ts';\nexport * from './constructors/internals/getRecentFileTrackerConstructor.ts';\nexport * from './constructors/internals/getShareReceiverConstructor.ts';\nexport * from './constructors/internals/getStatusBarConstructor.ts';\nexport * from './constructors/internals/getViewRegistryConstructor.ts';\nexport * from './constructors/internals/getWorkspaceLeafHistoryConstructor.ts';\nexport * from './constructors/internals/internal-plugins/bases/getBasesContextConstructor.ts';\nexport * from './constructors/internals/internal-plugins/bases/getBasesQueryConstructor.ts';\nexport * from './constructors/internals/internal-plugins/getInternalPluginConstructor.ts';\nexport * from './constructors/internals/internal-plugins/getInternalPluginsConstructor.ts';\nexport * from './constructors/internals/views/getAllPropertiesViewConstructor.ts';\nexport * from './constructors/internals/views/getAudioViewConstructor.ts';\nexport * from './constructors/internals/views/getBacklinkViewConstructor.ts';\nexport * from './constructors/internals/views/getBasesViewConstructor.ts';\nexport * from './constructors/internals/views/getBookmarksViewConstructor.ts';\nexport * from './constructors/internals/views/getCanvasViewConstructor.ts';\nexport * from './constructors/internals/views/getEmptyViewConstructor.ts';\nexport * from './constructors/internals/views/getFileExplorerViewConstructor.ts';\nexport * from './constructors/internals/views/getFilePropertiesViewConstructor.ts';\nexport * from './constructors/internals/views/getGraphViewConstructor.ts';\nexport * from './constructors/internals/views/getImageViewConstructor.ts';\nexport * from './constructors/internals/views/getLocalGraphViewConstructor.ts';\nexport * from './constructors/internals/views/getOutgoingLinkViewConstructor.ts';\nexport * from './constructors/internals/views/getOutlineViewConstructor.ts';\nexport * from './constructors/internals/views/getPdfViewConstructor.ts';\nexport * from './constructors/internals/views/getReleaseNotesViewConstructor.ts';\nexport * from './constructors/internals/views/getSearchViewConstructor.ts';\nexport * from './constructors/internals/views/getSyncViewConstructor.ts';\nexport * from './constructors/internals/views/getTagViewConstructor.ts';\nexport * from './constructors/internals/views/getVideoViewConstructor.ts';\nexport * from './constructors/internals/views/getViewConstructorByViewType.ts';\nexport * from './constructors/internals/views/getWebviewerHistoryViewConstructor.ts';\nexport * from './constructors/internals/views/getWebviewerViewConstructor.ts';\nexport * from './constructors/internals/workspace/getWorkspaceProtocolHandlerConstructor.ts';\nexport * from './functions/createTFileInstance.ts';\nexport * from './functions/createTFolderInstance.ts';\nexport * from './functions/evaluateBaseHeadless.ts';\nexport * from './functions/getBasesControllerFromRender.ts';\nexport * from './functions/getDataAdapterEx.ts';\nexport * from './functions/getPlatformEx.ts';\nexport * from './functions/loadMermaid.ts';\nexport * from './functions/loadPdfJs.ts';\nexport * from './functions/loadPrism.ts';\nexport * from './functions/onLayoutReadyEx.ts';\nexport * from './type-guards/getSearchMatcherGuards.ts';\nexport * from './type-guards/isEmbedCache.ts';\nexport * from './type-guards/isFrontmatterLinkCache.ts';\nexport * from './type-guards/isLayoutReady.ts';\nexport * from './type-guards/isLinkCache.ts';\nexport * from './type-guards/isReferenceCache.ts';\nexport * from './utils/PathUtils.ts';\nexport type * from '../../index.d.ts';\n", "import type { CustomArrayDict } from '../../internals/collections/CustomArrayDict.d.ts';\n\n/**\n * A dictionary from 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  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 { FileExplorerView } from '../../../internals/internal-plugins/file-explorer/FileExplorerView.d.ts';\nimport type { ObsidianSearchQuery } from '../../../internals/search-query/ObsidianSearchQuery.d.ts';\n\nimport { ViewType } from '../../constants/ViewType.ts';\n\n/**\n * Get the {@link ObsidianSearchQuery} constructor.\n *\n * The class has no reachable instance until a query is compiled, so a throwaway file explorer view is created\n * on a temporary leaf, a probe filter query is compiled through it, and the constructor is read off the result.\n * The leaf is detached before returning.\n *\n * @param app - The app instance.\n * @returns The {@link ObsidianSearchQuery} constructor.\n *\n * @public\n * @unofficial\n */\nexport function getObsidianSearchQueryConstructor(app: App): ExtractConstructor<ObsidianSearchQuery> {\n  const leaf = app.workspace.createLeafInTabGroup();\n  try {\n    const viewCreator = app.viewRegistry.getViewCreatorByType(ViewType.FileExplorer);\n    if (!viewCreator) {\n      throw new Error('View creator not found');\n    }\n    const view = viewCreator(leaf) as FileExplorerView;\n    view.onSearchChanged('probe');\n    if (!view.searchQuery) {\n      throw new Error('The probe query did not compile.');\n    }\n    return view.searchQuery.constructor as ExtractConstructor<ObsidianSearchQuery>;\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 { 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  QueryController\n} from 'obsidian';\n\nimport { MarkdownRenderer } from 'obsidian';\n\n/**\n * Render a base into a detached, off-screen element and return the live {@link obsidian#QueryController} 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 obsidian#QueryController} 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<QueryController> {\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 QueryController;\n    }\n\n    for (const child of node._children ?? []) {\n      queue.push(child);\n    }\n  }\n\n  throw new Error('Could not locate the QueryController 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.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/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/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/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 { TagView } from '../../../../internals/views/TagView/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 {\n  Component,\n  TFile\n} 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 * The file is read with {@link obsidian#Vault.cachedRead}, and its own path supplies the query's file context.\n *\n * @example\n * ```ts\n * const entries = await evaluateBaseHeadless(app, 'Projects/Tasks.base');\n * ```\n *\n * @param app - The app instance.\n * @param base - The `.base` file, or its vault path.\n * @returns The evaluated base entries.\n * @throws If no file exists at the given path, or the file is not a `.base` file.\n *\n * @public\n * @unofficial\n */\nexport async function evaluateBaseHeadless(app: App, base: string | TFile): Promise<BasesEntry[]>;\n/**\n * Evaluate `.base` content in headless mode \u2014 with no leaf or open view \u2014 and return its entries.\n *\n * Use this form for content that is not a `.base` file of its own, such as the body of a `base` code block in a\n * note.\n *\n * @example\n * ```ts\n * const entries = await evaluateBaseHeadless(app, 'filters:\\n  and:\\n    - file.hasTag(\"task\")\\n', 'Notes/Today.md');\n * ```\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/**\n * Evaluate a base 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 baseOrContent - The `.base` file or its vault path, or the `.base` content when `sourcePath` is given.\n * @param sourcePath - The path supplying the query's file context, given only with `.base` content.\n * @returns The evaluated base entries.\n *\n * @public\n * @unofficial\n */\nexport async function evaluateBaseHeadless(app: App, baseOrContent: string | TFile, sourcePath?: string): Promise<BasesEntry[]> {\n  const SCAN_POLL_INTERVAL_IN_MILLISECONDS = 50;\n  const SCAN_TIMEOUT_IN_MILLISECONDS = 30000;\n\n  let content: string;\n  let querySourcePath: string;\n\n  if (sourcePath === undefined) {\n    const file = typeof baseOrContent === 'string' ? app.vault.getAbstractFileByPath(baseOrContent) : baseOrContent;\n    if (!(file instanceof TFile)) {\n      throw new Error(`No .base file exists at '${String(baseOrContent)}'.`);\n    }\n    if (file.extension !== 'base') {\n      throw new Error(`'${file.path}' is not a .base file.`);\n    }\n    content = await app.vault.cachedRead(file);\n    querySourcePath = file.path;\n  } else {\n    if (typeof baseOrContent !== 'string') {\n      throw new Error('Pass the .base file on its own, without a source path.');\n    }\n    content = baseOrContent;\n    querySourcePath = sourcePath;\n  }\n\n  const component = new Component();\n  try {\n    const controller = await getBasesControllerFromRender(app, content, querySourcePath, 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 { Platform } from 'obsidian';\n\nimport type { PlatformEx } from '../../internals/PlatformEx.d.ts';\n\n/**\n * Get the {@link obsidian#Platform} constant as {@link PlatformEx}.\n *\n * @returns The platform extension.\n *\n * @public\n * @unofficial\n */\nexport function getPlatformEx(): PlatformEx {\n  return Platform as PlatformEx;\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 { InteropPdfJsModule as PdfJsModule } from '../../../pdfjs-dist/interop/InteropPdfJsModule.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 { Workspace } from 'obsidian';\n\nimport type { LayoutReadyWorkspace } from '../../internals/workspace/LayoutReadyWorkspace.d.ts';\n\n/**\n * Run the callback once the workspace layout is loaded, passing it the workspace as a {@link LayoutReadyWorkspace}.\n *\n * Like {@link obsidian#Workspace.onLayoutReady}, it runs the callback right away if the layout is already loaded,\n * and queues it otherwise. Obsidian calls an `onLayoutReady` callback with no arguments, so this helper is what\n * hands the callback the narrowed workspace.\n *\n * @param workspace - The workspace.\n * @param callback - The callback to run.\n *\n * @public\n * @unofficial\n */\nexport function onLayoutReadyEx(workspace: Workspace, callback: (workspace: LayoutReadyWorkspace) => unknown): void {\n  workspace.onLayoutReady(() => callback(workspace as LayoutReadyWorkspace));\n}\n", "import type { App } from 'obsidian';\n\nimport type { SearchMatcher } from '../../internals/search-query/SearchMatcher.d.ts';\nimport type { SearchMatcherGuards } from '../../internals/search-query/SearchMatcherGuards.d.ts';\n\nimport { getObsidianSearchQueryConstructor } from '../constructors/internals/getObsidianSearchQueryConstructor.ts';\n\n/**\n * Creates exact prototype guards by compiling probe queries with the running app's parser.\n *\n * No translated descriptions or minified names are inspected. Create the guards once per app;\n * each predicate rejects unknown nodes, including subclasses. Unsupported nodes must keep all candidates.\n * Probe compilation does not start Search or change an existing search pane.\n *\n * @param app - The app instance.\n * @returns Guards tied to this app's parser prototypes.\n * @public\n * @unofficial\n */\nexport function getSearchMatcherGuards(app: App): SearchMatcherGuards {\n  const Query = getObsidianSearchQueryConstructor(app);\n  return {\n    and: guard('alpha bravo'),\n    case: guard('match-case:alpha'),\n    comparison: guard('[alpha:>bravo]', 'value'),\n    content: guard('content:alpha'),\n    file: guard('file:alpha'),\n    negation: guard('-alpha'),\n    or: guard('alpha OR bravo'),\n    path: guard('path:alpha'),\n    property: guard('[alpha]'),\n    quotedText: guard('\"alpha\"'),\n    regex: guard('/alpha/'),\n    tag: guard('tag:alpha'),\n    text: guard('alpha')\n  };\n\n  function guard<T extends SearchMatcher>(query: string, child?: 'value'): (matcher: SearchMatcher) => matcher is T {\n    const probe = new Query(app, query, false).matcher;\n    if (!probe) {\n      throw new Error('The matcher probe did not compile.');\n    }\n    if (child && !(child in probe)) {\n      throw new Error('The matcher probe has no value node.');\n    }\n    const node: unknown = child && child in probe ? probe[child] : probe;\n    if (!node || typeof node !== 'object') {\n      throw new Error('The matcher probe has no value matcher.');\n    }\n    const prototype = Object.getPrototypeOf(node);\n    return (matcher): matcher is T => Object.getPrototypeOf(matcher) === prototype;\n  }\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 { Workspace } from 'obsidian';\n\nimport type { LayoutReadyWorkspace } from '../../internals/workspace/LayoutReadyWorkspace.d.ts';\n\n/**\n * Check if the workspace layout is loaded, narrowing the workspace to {@link LayoutReadyWorkspace}.\n *\n * @param workspace - The workspace to check.\n * @returns Whether the workspace layout is loaded.\n *\n * @public\n * @unofficial\n */\nexport function isLayoutReady(workspace: Workspace): workspace is LayoutReadyWorkspace {\n  return workspace.layoutReady;\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": ["import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "loadMermaidOriginal", "import_obsidian", "loadPdfJsOriginal", "import_obsidian", "loadPrismOriginal"]
}
