obsidian-dev-utils 88.2.0 → 88.4.0

package/dist/lib/esm/obsidian/file-system.d.mts

@@ -203,6 +203,20 @@ export interface GetMarkdownFilesParams {
      */
     readonly pathOrFolder: PathOrFolder;
 }
+/**
+ * Parameters for {@link isTreatedAsAttachment}.
+ */
+export interface IsTreatedAsAttachmentParams {
+    /**
+     * The extensions that mark a file as an attachment, e.g. `['.excalidraw.md']`. Each entry is normalized before matching: surrounding whitespace is trimmed,
+     * a single leading dot is enforced, and the comparison is case-insensitive. Empty entries are ignored.
+     */
+    readonly attachmentExtensions: readonly string[];
+    /**
+     * The path or file to classify.
+     */
+    readonly pathOrFile: null | PathOrAbstractFile;
+}
 /**
  * A path or an abstract file.
  */
@@ -413,6 +427,17 @@ export declare function isMarkdownFile(pathOrFile: null | PathOrAbstractFile): b
  * @returns A boolean indicating whether the file is a note.
  */
 export declare function isNote(pathOrFile: null | PathOrAbstractFile): boolean;
+/**
+ * Checks if the given file should be treated as an attachment because of its extension.
+ *
+ * Some plugins store their data in files that are markdown on disk but are not prose — Excalidraw, for example, saves each drawing as `sketch.excalidraw.md`.
+ * Obsidian reports such a file's extension as `md`, so a caller that wants to tell a drawing apart from a note has to match the full multi-part extension
+ * (`.excalidraw.md`) against the file name. Which extensions count is the caller's configuration, not this library's — only the matching rule is shared.
+ *
+ * @param params - The path or file to classify and the configured attachment extensions.
+ * @returns A boolean indicating whether the file should be treated as an attachment.
+ */
+export declare function isTreatedAsAttachment(params: IsTreatedAsAttachmentParams): boolean;
 /**
  * Trims the markdown extension from the file path if the file is a markdown file.
  * If the file is not a markdown file, the original file path is returned.

package/dist/lib/esm/obsidian/file-system.mjs

@@ -36,6 +36,7 @@ import {
 } from "obsidian";
 import { normalizeOptionalProperties } from "../object-utils.mjs";
 import {
+  basename,
   extname,
   resolve
 } from "../path.mjs";
@@ -322,6 +323,20 @@ function isMarkdownFile(pathOrFile) {
 function isNote(pathOrFile) {
   return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);
 }
+function isTreatedAsAttachment(params) {
+  const {
+    attachmentExtensions,
+    pathOrFile
+  } = params;
+  if (pathOrFile === null || isFolder(pathOrFile)) {
+    return false;
+  }
+  const lowerCaseName = getName(pathOrFile).toLowerCase();
+  return attachmentExtensions.some((extension) => {
+    const normalizedExtension = extension.trim().replace(/^\.+/, "").toLowerCase();
+    return normalizedExtension !== "" && lowerCaseName.endsWith(`.${normalizedExtension}`);
+  });
+}
 function trimMarkdownExtension(file) {
   if (!isMarkdownFile(file)) {
     return file.path;
@@ -347,6 +362,9 @@ function getFileInternal(params) {
   }
   return app.vault.getAbstractFileByPath(path);
 }
+function getName(pathOrFile) {
+  return isAbstractFile(pathOrFile) ? pathOrFile.name : basename(pathOrFile);
+}
 function getResolvedPath(path) {
   return normalizePath(resolve("/", path));
 }
@@ -381,6 +399,7 @@ export {
   isFolder,
   isMarkdownFile,
   isNote,
+  isTreatedAsAttachment,
   trimMarkdownExtension
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/file-system.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for working with {@link TAbstractFile}, {@link TFile}, and {@link TFolder} instances in Obsidian.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  createTFileInstance,\n  createTFolderInstance,\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  normalizePath,\n  TAbstractFile,\n  TFile,\n  TFolder,\n  Vault\n} from 'obsidian';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport {\n  extname,\n  resolve\n} from '../path.ts';\nimport { trimEnd } from '../string.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport { getCaseInsensitiveFileIndex } from './case-insensitive-file-index.ts';\n\n/**\n * A file extension for `base` files.\n */\nexport const BASE_FILE_EXTENSION = 'base';\n\n/**\n * A file extension for `canvas` files.\n */\nexport const CANVAS_FILE_EXTENSION = 'canvas';\n\n/**\n * A file extension for `markdown` files.\n */\nexport const MARKDOWN_FILE_EXTENSION = 'md';\n\n/**\n * A type of file system object.\n */\nexport enum FileSystemType {\n  /**\n   * A file.\n   */\n  File = 'file',\n  /**\n   * A folder.\n   */\n  Folder = 'folder'\n}\n\n/**\n * Parameters for {@link exists}.\n */\nexport interface ExistsParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to check.\n   */\n  readonly path: string;\n\n  /**\n   * The type of the file system object to check. Default is `undefined`.\n   */\n  readonly type?: FileSystemType;\n}\n\n/**\n * Parameters for {@link getAbstractFileOrNull}.\n */\nexport interface GetAbstractFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve.\n   */\n  readonly pathOrFile: null | PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getAbstractFile}.\n */\nexport interface GetAbstractFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve the abstract file for.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getFileOrNull}.\n */\nexport interface GetFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file.\n   */\n  readonly pathOrFile: null | PathOrFile;\n}\n\n/**\n * Parameters for {@link getFile}.\n */\nexport interface GetFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file to retrieve the file for.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * Whether to include a non-existing file.\n   *  If `true`, a new file is created for the provided path.\n   *  If `false`, an error is thrown if the file is not found.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getFolderOrNull}.\n */\nexport interface GetFolderOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder to retrieve the folder from.\n   */\n  readonly pathOrFolder: null | PathOrFolder;\n}\n\n/**\n * Parameters for {@link getFolder}.\n */\nexport interface GetFolderParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder identifier.\n   */\n  readonly pathOrFolder: PathOrFolder;\n\n  /**\n   * Whether to allow the folder to not exist.\n   *  If `true`, a new folder is created for the provided path.\n   *  If `false`, an error is thrown if the folder is not found.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getMarkdownFiles}.\n */\nexport interface GetMarkdownFilesParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to recursively search for markdown files within subfolders. Default is `false`.\n   *\n   * @default `false`\n   */\n  readonly isRecursive?: boolean;\n\n  /**\n   * The path or folder to retrieve the markdown files from.\n   */\n  readonly pathOrFolder: PathOrFolder;\n}\n\n/**\n * A path or an abstract file.\n */\nexport type PathOrAbstractFile = string | TAbstractFile;\n\n/**\n * A path or a file.\n */\nexport type PathOrFile = string | TFile;\n\n/**\n * A path or a folder.\n */\nexport type PathOrFolder = string | TFolder;\n\n/**\n * Parameters for {@link getFileInternal}.\n */\ninterface GetFileInternalParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to retrieve the abstract file for.\n   */\n  readonly path: string;\n}\n\n/**\n * Converts an array of abstract files to an array of files.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of files.\n * @throws Error if any of the abstract files are not files.\n */\nexport function asArrayOfFiles(abstractFiles: TAbstractFile[]): TFile[] {\n  return abstractFiles.map((abstractFile) => asFile(abstractFile));\n}\n\n/**\n * Converts an array of abstract files to an array of folders.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of folders.\n * @throws Error if any of the abstract files are not folders.\n */\nexport function asArrayOfFolders(abstractFiles: TAbstractFile[]): TFolder[] {\n  return abstractFiles.map((abstractFile) => asFolder(abstractFile));\n}\n\n/**\n * Converts an abstract file to a file.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFile(abstractFile: null | TAbstractFile): TFile {\n  return ensureNonNullable(asFileOrNull(abstractFile), 'Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a file or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file or `null`.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFileOrNull(abstractFile: null | TAbstractFile): null | TFile {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFile) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a folder.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolder(abstractFile: null | TAbstractFile): TFolder {\n  return ensureNonNullable(asFolderOrNull(abstractFile), 'Abstract file is not a folder');\n}\n\n/**\n * Converts an abstract file to a folder or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder or `null`.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolderOrNull(abstractFile: null | TAbstractFile): null | TFolder {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFolder) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a folder');\n}\n\n/**\n * Checks if the given path or file has the specified extension.\n *\n * @param pathOrFile - The path or abstract file to check.\n * @param extension - The extension to compare against.\n * @returns Returns `true` if the path or file has the specified extension, `false` otherwise.\n */\nexport function checkExtension(pathOrFile: null | PathOrAbstractFile, extension: string): boolean {\n  if (isFile(pathOrFile)) {\n    return pathOrFile.extension === extension;\n  }\n\n  if (typeof pathOrFile === 'string') {\n    // Compare the path's own extension instead of resolving the file.\n    // Resolving a string path is O(vault) on a miss on a case-insensitive filesystem.\n    // That miss is the hot path during deletion cascades.\n    // Obsidian lowercases a file's canonical extension, so compare case-insensitively.\n    return extname(pathOrFile).slice(1).toLowerCase() === extension;\n  }\n\n  return false;\n}\n\n/**\n * Checks if the given path exists.\n *\n * @param params - The parameters for the check.\n * @returns `true` if the path exists, `false` otherwise.\n */\nexport function exists(params: ExistsParams): boolean {\n  const {\n    app,\n    isCaseInsensitive,\n    path,\n    type\n  } = params;\n  const abstractFile = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: path\n  }));\n  if (!abstractFile) {\n    return false;\n  }\n\n  if (type === undefined) {\n    return true;\n  }\n\n  return getFileSystemType(abstractFile) === type;\n}\n\n/**\n * Retrieves the TAbstractFile object for the given path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file.\n * @throws Error if the abstract file is not found.\n */\nexport function getAbstractFile(params: GetAbstractFileParams): TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  return ensureNonNullable(\n    getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n      app,\n      isCaseInsensitive,\n      pathOrFile\n    })),\n    `Abstract file not found: ${pathOrFile as string}`\n  );\n}\n\n/**\n * Retrieves an abstract file or `null` based on the provided path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file if found, otherwise `null`.\n */\nexport function getAbstractFileOrNull(params: GetAbstractFileOrNullParams): null | TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  if (pathOrFile === null) {\n    return null;\n  }\n\n  if (isAbstractFile(pathOrFile)) {\n    if (isFile(pathOrFile)) {\n      return app.vault.getFileByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    if (isFolder(pathOrFile)) {\n      return app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore stop */\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    return app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile;\n    /* v8 ignore stop */\n  }\n\n  const file = getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: pathOrFile\n  }));\n\n  if (file) {\n    return file;\n  }\n\n  const resolvedPath = getResolvedPath(pathOrFile);\n\n  if (resolvedPath === pathOrFile) {\n    return null;\n  }\n\n  return getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: resolvedPath\n  }));\n}\n\n/**\n * Retrieves a file based on the provided path or file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The file corresponding to the provided path or file.\n * @throws Error if the file is not found.\n */\nexport function getFile(params: GetFileParams): TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile,\n    shouldIncludeNonExisting\n  } = params;\n  let file = getFileOrNull(normalizeOptionalProperties<GetFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\n  if (!file) {\n    if (shouldIncludeNonExisting) {\n      file = createTFileInstance(app, pathOrFile as string);\n    } else {\n      throw new Error(`File not found: ${pathOrFile as string}`);\n    }\n  }\n\n  return file;\n}\n\n/**\n * Retrieves a file or `null` based on the provided path or file.\n * If the provided argument is already a file, it is returned as is.\n * Otherwise, the function uses the app's vault to retrieve the file by its path.\n *\n * @param params - The parameters for the retrieval.\n * @returns The file if found, otherwise `null`.\n */\nexport function getFileOrNull(params: GetFileOrNullParams): null | TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  const file = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\n  if (isFile(file)) {\n    return file;\n  }\n  return null;\n}\n\n/**\n * Gets the type of a file system object.\n *\n * @param abstractFile - The abstract file to get the type of.\n * @returns The type of the abstract file.\n * @throws Error if the abstract file is not a file or a folder.\n */\nexport function getFileSystemType(abstractFile: TAbstractFile): FileSystemType {\n  if (isFile(abstractFile)) {\n    return FileSystemType.File;\n  }\n  if (isFolder(abstractFile)) {\n    return FileSystemType.Folder;\n  }\n  throw new Error('Abstract file is not a file or a folder');\n}\n\n/**\n * Retrieves a folder based on the provided app and pathOrFolder.\n *\n * @param params - The parameters for the retrieval.\n * @returns The retrieved folder.\n * @throws If the folder is not found.\n */\nexport function getFolder(params: GetFolderParams): TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder,\n    shouldIncludeNonExisting\n  } = params;\n  let folder = getFolderOrNull(normalizeOptionalProperties<GetFolderOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  }));\n  if (!folder) {\n    if (shouldIncludeNonExisting) {\n      folder = createTFolderInstance(app, pathOrFolder as string);\n    } else {\n      throw new Error(`Folder not found: ${pathOrFolder as string}`);\n    }\n  }\n\n  return folder;\n}\n\n/**\n * Retrieves a folder or `null` based on the provided path or folder.\n *\n * @param params - The parameters for the retrieval.\n * @returns The folder if found, otherwise `null`.\n */\nexport function getFolderOrNull(params: GetFolderOrNullParams): null | TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  } = params;\n  const folder = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: pathOrFolder\n  }));\n  if (isFolder(folder)) {\n    return folder;\n  }\n  return null;\n}\n\n/**\n * Retrieves an array of files representing the markdown files within a specified folder or path.\n *\n * @param params - The parameters for the retrieval.\n * @returns An array of files representing the markdown files.\n */\nexport function getMarkdownFiles(params: GetMarkdownFilesParams): TFile[] {\n  const {\n    app,\n    isRecursive,\n    pathOrFolder\n  } = params;\n  const folder = getFolder({\n    app,\n    pathOrFolder\n  });\n\n  let markdownFiles: TFile[] = [];\n\n  if (isRecursive) {\n    Vault.recurseChildren(folder, (abstractFile) => {\n      if (isMarkdownFile(abstractFile) && abstractFile instanceof TFile) {\n        markdownFiles.push(abstractFile);\n      }\n    });\n  } else {\n    markdownFiles = folder.children.filter((file) => isMarkdownFile(file)) as TFile[];\n  }\n\n  markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));\n  return markdownFiles;\n}\n\n/**\n * Retrieves the file for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the file to retrieve or create.\n * @returns The file representing the file\n */\nexport async function getOrCreateFile(app: App, path: string): Promise<TFile> {\n  const file = getFileOrNull({\n    app,\n    pathOrFile: path\n  });\n  if (file) {\n    return file;\n  }\n\n  const folderPath = parentFolderPath(path);\n  await getOrCreateFolder(app, folderPath);\n\n  return await app.vault.create(path, '');\n}\n\n/**\n * Retrieves the folder for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the folder to retrieve or create.\n * @returns The folder representing the folder.\n */\nexport async function getOrCreateFolder(app: App, path: string): Promise<TFolder> {\n  const folder = getFolderOrNull({\n    app,\n    pathOrFolder: path\n  });\n  if (folder) {\n    return folder;\n  }\n\n  return await app.vault.createFolder(path);\n}\n\n/**\n * Returns the path of the given `pathOrFile`.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or abstract file.\n * @returns The path of the `pathOrFile`.\n */\nexport function getPath(app: App, pathOrFile: PathOrAbstractFile): string {\n  if (isAbstractFile(pathOrFile)) {\n    return pathOrFile.path;\n  }\n\n  const file = getAbstractFileOrNull({\n    app,\n    pathOrFile\n  });\n  if (file) {\n    return file.path;\n  }\n\n  return getResolvedPath(pathOrFile);\n}\n\n/**\n * Checks if the given file is an instance of abstract file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of abstract file.\n */\nexport function isAbstractFile(file: unknown): file is TAbstractFile {\n  return file instanceof TAbstractFile;\n}\n\n/**\n *   Checks if the given file is a base file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a base file.\n */\nexport function isBaseFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, BASE_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a canvas file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a canvas file or not.\n */\nexport function isCanvasFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, CANVAS_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is an instance of file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of file.\n */\nexport function isFile(file: unknown): file is TFile {\n  return file instanceof TFile;\n}\n\n/**\n * Checks if the given file is a folder.\n *\n * @param file - The file to check.\n * @returns `true` if the file is a folder, `false` otherwise.\n */\nexport function isFolder(file: unknown): file is TFolder {\n  return file instanceof TFolder;\n}\n\n/**\n * Checks if the given file is a Markdown file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a Markdown file.\n */\nexport function isMarkdownFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a note.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a note.\n */\nexport function isNote(pathOrFile: null | PathOrAbstractFile): boolean {\n  return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);\n}\n\n/**\n * Trims the markdown extension from the file path if the file is a markdown file.\n * If the file is not a markdown file, the original file path is returned.\n *\n * @param file - The file to trim the markdown extension from.\n * @returns The file path with the markdown extension trimmed.\n */\nexport function trimMarkdownExtension(file: TAbstractFile): string {\n  if (!isMarkdownFile(file)) {\n    return file.path;\n  }\n\n  return trimEnd({\n    str: file.path,\n    suffix: `.${MARKDOWN_FILE_EXTENSION}`\n  });\n}\n\nfunction getFileInternal(params: GetFileInternalParams): null | TAbstractFile {\n  const {\n    app,\n    path\n  } = params;\n  let { isCaseInsensitive } = params;\n  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;\n  if (isCaseInsensitive) {\n    const caseInsensitiveFileIndex = getCaseInsensitiveFileIndex(app);\n    if (caseInsensitiveFileIndex) {\n      return caseInsensitiveFileIndex.get(path);\n    }\n    return app.vault.getAbstractFileByPathInsensitive(path);\n  }\n\n  return app.vault.getAbstractFileByPath(path);\n}\n\nfunction getResolvedPath(path: string): string {\n  return normalizePath(resolve('/', path));\n}\n"],
  "mappings": "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",
  "names": ["FileSystemType"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/file-system.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for working with {@link TAbstractFile}, {@link TFile}, and {@link TFolder} instances in Obsidian.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  createTFileInstance,\n  createTFolderInstance,\n  getDataAdapterEx,\n  parentFolderPath\n} from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  normalizePath,\n  TAbstractFile,\n  TFile,\n  TFolder,\n  Vault\n} from 'obsidian';\n\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport {\n  basename,\n  extname,\n  resolve\n} from '../path.ts';\nimport { trimEnd } from '../string.ts';\nimport { ensureNonNullable } from '../type-guards.ts';\nimport { getCaseInsensitiveFileIndex } from './case-insensitive-file-index.ts';\n\n/**\n * A file extension for `base` files.\n */\nexport const BASE_FILE_EXTENSION = 'base';\n\n/**\n * A file extension for `canvas` files.\n */\nexport const CANVAS_FILE_EXTENSION = 'canvas';\n\n/**\n * A file extension for `markdown` files.\n */\nexport const MARKDOWN_FILE_EXTENSION = 'md';\n\n/**\n * A type of file system object.\n */\nexport enum FileSystemType {\n  /**\n   * A file.\n   */\n  File = 'file',\n  /**\n   * A folder.\n   */\n  Folder = 'folder'\n}\n\n/**\n * Parameters for {@link exists}.\n */\nexport interface ExistsParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to check.\n   */\n  readonly path: string;\n\n  /**\n   * The type of the file system object to check. Default is `undefined`.\n   */\n  readonly type?: FileSystemType;\n}\n\n/**\n * Parameters for {@link getAbstractFileOrNull}.\n */\nexport interface GetAbstractFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve.\n   */\n  readonly pathOrFile: null | PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getAbstractFile}.\n */\nexport interface GetAbstractFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or abstract file to retrieve the abstract file for.\n   */\n  readonly pathOrFile: PathOrAbstractFile;\n}\n\n/**\n * Parameters for {@link getFileOrNull}.\n */\nexport interface GetFileOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file.\n   */\n  readonly pathOrFile: null | PathOrFile;\n}\n\n/**\n * Parameters for {@link getFile}.\n */\nexport interface GetFileParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or file to retrieve the file for.\n   */\n  readonly pathOrFile: PathOrFile;\n\n  /**\n   * Whether to include a non-existing file.\n   *  If `true`, a new file is created for the provided path.\n   *  If `false`, an error is thrown if the file is not found.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getFolderOrNull}.\n */\nexport interface GetFolderOrNullParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder to retrieve the folder from.\n   */\n  readonly pathOrFolder: null | PathOrFolder;\n}\n\n/**\n * Parameters for {@link getFolder}.\n */\nexport interface GetFolderParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path or folder identifier.\n   */\n  readonly pathOrFolder: PathOrFolder;\n\n  /**\n   * Whether to allow the folder to not exist.\n   *  If `true`, a new folder is created for the provided path.\n   *  If `false`, an error is thrown if the folder is not found.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeNonExisting?: boolean;\n}\n\n/**\n * Parameters for {@link getMarkdownFiles}.\n */\nexport interface GetMarkdownFilesParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to recursively search for markdown files within subfolders. Default is `false`.\n   *\n   * @default `false`\n   */\n  readonly isRecursive?: boolean;\n\n  /**\n   * The path or folder to retrieve the markdown files from.\n   */\n  readonly pathOrFolder: PathOrFolder;\n}\n\n/**\n * Parameters for {@link isTreatedAsAttachment}.\n */\nexport interface IsTreatedAsAttachmentParams {\n  /**\n   * The extensions that mark a file as an attachment, e.g. `['.excalidraw.md']`. Each entry is normalized before matching: surrounding whitespace is trimmed,\n   * a single leading dot is enforced, and the comparison is case-insensitive. Empty entries are ignored.\n   */\n  readonly attachmentExtensions: readonly string[];\n\n  /**\n   * The path or file to classify.\n   */\n  readonly pathOrFile: null | PathOrAbstractFile;\n}\n\n/**\n * A path or an abstract file.\n */\nexport type PathOrAbstractFile = string | TAbstractFile;\n\n/**\n * A path or a file.\n */\nexport type PathOrFile = string | TFile;\n\n/**\n * A path or a folder.\n */\nexport type PathOrFolder = string | TFolder;\n\n/**\n * Parameters for {@link getFileInternal}.\n */\ninterface GetFileInternalParams {\n  /**\n   * The Obsidian App instance.\n   */\n  readonly app: App;\n\n  /**\n   * Specifies whether to perform a case-insensitive search. When `undefined` or not specified, the behavior is determined by the actual file system.\n   *\n   * @default `undefined`\n   */\n  readonly isCaseInsensitive?: boolean;\n\n  /**\n   * The path to retrieve the abstract file for.\n   */\n  readonly path: string;\n}\n\n/**\n * Converts an array of abstract files to an array of files.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of files.\n * @throws Error if any of the abstract files are not files.\n */\nexport function asArrayOfFiles(abstractFiles: TAbstractFile[]): TFile[] {\n  return abstractFiles.map((abstractFile) => asFile(abstractFile));\n}\n\n/**\n * Converts an array of abstract files to an array of folders.\n *\n * @param abstractFiles - The abstract files to convert.\n * @returns The array of folders.\n * @throws Error if any of the abstract files are not folders.\n */\nexport function asArrayOfFolders(abstractFiles: TAbstractFile[]): TFolder[] {\n  return abstractFiles.map((abstractFile) => asFolder(abstractFile));\n}\n\n/**\n * Converts an abstract file to a file.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFile(abstractFile: null | TAbstractFile): TFile {\n  return ensureNonNullable(asFileOrNull(abstractFile), 'Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a file or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The file or `null`.\n * @throws Error if the abstract file is not a file.\n */\nexport function asFileOrNull(abstractFile: null | TAbstractFile): null | TFile {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFile) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a file');\n}\n\n/**\n * Converts an abstract file to a folder.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolder(abstractFile: null | TAbstractFile): TFolder {\n  return ensureNonNullable(asFolderOrNull(abstractFile), 'Abstract file is not a folder');\n}\n\n/**\n * Converts an abstract file to a folder or `null`.\n *\n * @param abstractFile - The abstract file to convert.\n * @returns The folder or `null`.\n * @throws Error if the abstract file is not a folder.\n */\nexport function asFolderOrNull(abstractFile: null | TAbstractFile): null | TFolder {\n  if (abstractFile === null) {\n    return null;\n  }\n  if (abstractFile instanceof TFolder) {\n    return abstractFile;\n  }\n  throw new Error('Abstract file is not a folder');\n}\n\n/**\n * Checks if the given path or file has the specified extension.\n *\n * @param pathOrFile - The path or abstract file to check.\n * @param extension - The extension to compare against.\n * @returns Returns `true` if the path or file has the specified extension, `false` otherwise.\n */\nexport function checkExtension(pathOrFile: null | PathOrAbstractFile, extension: string): boolean {\n  if (isFile(pathOrFile)) {\n    return pathOrFile.extension === extension;\n  }\n\n  if (typeof pathOrFile === 'string') {\n    // Compare the path's own extension instead of resolving the file.\n    // Resolving a string path is O(vault) on a miss on a case-insensitive filesystem.\n    // That miss is the hot path during deletion cascades.\n    // Obsidian lowercases a file's canonical extension, so compare case-insensitively.\n    return extname(pathOrFile).slice(1).toLowerCase() === extension;\n  }\n\n  return false;\n}\n\n/**\n * Checks if the given path exists.\n *\n * @param params - The parameters for the check.\n * @returns `true` if the path exists, `false` otherwise.\n */\nexport function exists(params: ExistsParams): boolean {\n  const {\n    app,\n    isCaseInsensitive,\n    path,\n    type\n  } = params;\n  const abstractFile = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: path\n  }));\n  if (!abstractFile) {\n    return false;\n  }\n\n  if (type === undefined) {\n    return true;\n  }\n\n  return getFileSystemType(abstractFile) === type;\n}\n\n/**\n * Retrieves the TAbstractFile object for the given path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file.\n * @throws Error if the abstract file is not found.\n */\nexport function getAbstractFile(params: GetAbstractFileParams): TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  return ensureNonNullable(\n    getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n      app,\n      isCaseInsensitive,\n      pathOrFile\n    })),\n    `Abstract file not found: ${pathOrFile as string}`\n  );\n}\n\n/**\n * Retrieves an abstract file or `null` based on the provided path or abstract file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The abstract file if found, otherwise `null`.\n */\nexport function getAbstractFileOrNull(params: GetAbstractFileOrNullParams): null | TAbstractFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  if (pathOrFile === null) {\n    return null;\n  }\n\n  if (isAbstractFile(pathOrFile)) {\n    if (isFile(pathOrFile)) {\n      return app.vault.getFileByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    if (isFolder(pathOrFile)) {\n      return app.vault.getFolderByPath(pathOrFile.path) ?? pathOrFile;\n    }\n    /* v8 ignore stop */\n    /* v8 ignore start -- TAbstractFile is always TFile or TFolder in Obsidian; defensive fallback. */\n    return app.vault.getAbstractFileByPath(pathOrFile.path) ?? pathOrFile;\n    /* v8 ignore stop */\n  }\n\n  const file = getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: pathOrFile\n  }));\n\n  if (file) {\n    return file;\n  }\n\n  const resolvedPath = getResolvedPath(pathOrFile);\n\n  if (resolvedPath === pathOrFile) {\n    return null;\n  }\n\n  return getFileInternal(normalizeOptionalProperties<GetFileInternalParams>({\n    app,\n    isCaseInsensitive,\n    path: resolvedPath\n  }));\n}\n\n/**\n * Retrieves a file based on the provided path or file.\n *\n * @param params - The parameters for the retrieval.\n * @returns The file corresponding to the provided path or file.\n * @throws Error if the file is not found.\n */\nexport function getFile(params: GetFileParams): TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile,\n    shouldIncludeNonExisting\n  } = params;\n  let file = getFileOrNull(normalizeOptionalProperties<GetFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\n  if (!file) {\n    if (shouldIncludeNonExisting) {\n      file = createTFileInstance(app, pathOrFile as string);\n    } else {\n      throw new Error(`File not found: ${pathOrFile as string}`);\n    }\n  }\n\n  return file;\n}\n\n/**\n * Retrieves a file or `null` based on the provided path or file.\n * If the provided argument is already a file, it is returned as is.\n * Otherwise, the function uses the app's vault to retrieve the file by its path.\n *\n * @param params - The parameters for the retrieval.\n * @returns The file if found, otherwise `null`.\n */\nexport function getFileOrNull(params: GetFileOrNullParams): null | TFile {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  } = params;\n  const file = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile\n  }));\n  if (isFile(file)) {\n    return file;\n  }\n  return null;\n}\n\n/**\n * Gets the type of a file system object.\n *\n * @param abstractFile - The abstract file to get the type of.\n * @returns The type of the abstract file.\n * @throws Error if the abstract file is not a file or a folder.\n */\nexport function getFileSystemType(abstractFile: TAbstractFile): FileSystemType {\n  if (isFile(abstractFile)) {\n    return FileSystemType.File;\n  }\n  if (isFolder(abstractFile)) {\n    return FileSystemType.Folder;\n  }\n  throw new Error('Abstract file is not a file or a folder');\n}\n\n/**\n * Retrieves a folder based on the provided app and pathOrFolder.\n *\n * @param params - The parameters for the retrieval.\n * @returns The retrieved folder.\n * @throws If the folder is not found.\n */\nexport function getFolder(params: GetFolderParams): TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder,\n    shouldIncludeNonExisting\n  } = params;\n  let folder = getFolderOrNull(normalizeOptionalProperties<GetFolderOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  }));\n  if (!folder) {\n    if (shouldIncludeNonExisting) {\n      folder = createTFolderInstance(app, pathOrFolder as string);\n    } else {\n      throw new Error(`Folder not found: ${pathOrFolder as string}`);\n    }\n  }\n\n  return folder;\n}\n\n/**\n * Retrieves a folder or `null` based on the provided path or folder.\n *\n * @param params - The parameters for the retrieval.\n * @returns The folder if found, otherwise `null`.\n */\nexport function getFolderOrNull(params: GetFolderOrNullParams): null | TFolder {\n  const {\n    app,\n    isCaseInsensitive,\n    pathOrFolder\n  } = params;\n  const folder = getAbstractFileOrNull(normalizeOptionalProperties<GetAbstractFileOrNullParams>({\n    app,\n    isCaseInsensitive,\n    pathOrFile: pathOrFolder\n  }));\n  if (isFolder(folder)) {\n    return folder;\n  }\n  return null;\n}\n\n/**\n * Retrieves an array of files representing the markdown files within a specified folder or path.\n *\n * @param params - The parameters for the retrieval.\n * @returns An array of files representing the markdown files.\n */\nexport function getMarkdownFiles(params: GetMarkdownFilesParams): TFile[] {\n  const {\n    app,\n    isRecursive,\n    pathOrFolder\n  } = params;\n  const folder = getFolder({\n    app,\n    pathOrFolder\n  });\n\n  let markdownFiles: TFile[] = [];\n\n  if (isRecursive) {\n    Vault.recurseChildren(folder, (abstractFile) => {\n      if (isMarkdownFile(abstractFile) && abstractFile instanceof TFile) {\n        markdownFiles.push(abstractFile);\n      }\n    });\n  } else {\n    markdownFiles = folder.children.filter((file) => isMarkdownFile(file)) as TFile[];\n  }\n\n  markdownFiles = markdownFiles.sort((a, b) => a.path.localeCompare(b.path));\n  return markdownFiles;\n}\n\n/**\n * Retrieves the file for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the file to retrieve or create.\n * @returns The file representing the file\n */\nexport async function getOrCreateFile(app: App, path: string): Promise<TFile> {\n  const file = getFileOrNull({\n    app,\n    pathOrFile: path\n  });\n  if (file) {\n    return file;\n  }\n\n  const folderPath = parentFolderPath(path);\n  await getOrCreateFolder(app, folderPath);\n\n  return await app.vault.create(path, '');\n}\n\n/**\n * Retrieves the folder for the given path or creates a new one if it does not exist.\n *\n * @param app - The Obsidian App instance.\n * @param path - The path of the folder to retrieve or create.\n * @returns The folder representing the folder.\n */\nexport async function getOrCreateFolder(app: App, path: string): Promise<TFolder> {\n  const folder = getFolderOrNull({\n    app,\n    pathOrFolder: path\n  });\n  if (folder) {\n    return folder;\n  }\n\n  return await app.vault.createFolder(path);\n}\n\n/**\n * Returns the path of the given `pathOrFile`.\n *\n * @param app - The Obsidian App instance.\n * @param pathOrFile - The path or abstract file.\n * @returns The path of the `pathOrFile`.\n */\nexport function getPath(app: App, pathOrFile: PathOrAbstractFile): string {\n  if (isAbstractFile(pathOrFile)) {\n    return pathOrFile.path;\n  }\n\n  const file = getAbstractFileOrNull({\n    app,\n    pathOrFile\n  });\n  if (file) {\n    return file.path;\n  }\n\n  return getResolvedPath(pathOrFile);\n}\n\n/**\n * Checks if the given file is an instance of abstract file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of abstract file.\n */\nexport function isAbstractFile(file: unknown): file is TAbstractFile {\n  return file instanceof TAbstractFile;\n}\n\n/**\n *   Checks if the given file is a base file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a base file.\n */\nexport function isBaseFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, BASE_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a canvas file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a canvas file or not.\n */\nexport function isCanvasFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, CANVAS_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is an instance of file.\n *\n * @param file - The file to check.\n * @returns A boolean indicating whether the file is an instance of file.\n */\nexport function isFile(file: unknown): file is TFile {\n  return file instanceof TFile;\n}\n\n/**\n * Checks if the given file is a folder.\n *\n * @param file - The file to check.\n * @returns `true` if the file is a folder, `false` otherwise.\n */\nexport function isFolder(file: unknown): file is TFolder {\n  return file instanceof TFolder;\n}\n\n/**\n * Checks if the given file is a Markdown file.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a Markdown file.\n */\nexport function isMarkdownFile(pathOrFile: null | PathOrAbstractFile): boolean {\n  return checkExtension(pathOrFile, MARKDOWN_FILE_EXTENSION);\n}\n\n/**\n * Checks if the given file is a note.\n *\n * @param pathOrFile - The path or file to check.\n * @returns A boolean indicating whether the file is a note.\n */\nexport function isNote(pathOrFile: null | PathOrAbstractFile): boolean {\n  return isMarkdownFile(pathOrFile) || isCanvasFile(pathOrFile) || isBaseFile(pathOrFile);\n}\n\n/**\n * Checks if the given file should be treated as an attachment because of its extension.\n *\n * Some plugins store their data in files that are markdown on disk but are not prose \u2014 Excalidraw, for example, saves each drawing as `sketch.excalidraw.md`.\n * Obsidian reports such a file's extension as `md`, so a caller that wants to tell a drawing apart from a note has to match the full multi-part extension\n * (`.excalidraw.md`) against the file name. Which extensions count is the caller's configuration, not this library's \u2014 only the matching rule is shared.\n *\n * @param params - The path or file to classify and the configured attachment extensions.\n * @returns A boolean indicating whether the file should be treated as an attachment.\n */\nexport function isTreatedAsAttachment(params: IsTreatedAsAttachmentParams): boolean {\n  const {\n    attachmentExtensions,\n    pathOrFile\n  } = params;\n  if (pathOrFile === null || isFolder(pathOrFile)) {\n    return false;\n  }\n\n  const lowerCaseName = getName(pathOrFile).toLowerCase();\n  return attachmentExtensions.some((extension) => {\n    // Enforcing a single leading dot is what keeps the match on an extension boundary.\n    // A bare `raw.md` would otherwise match `sketch.excalidraw.md`, which is never what a caller means.\n    const normalizedExtension = extension.trim().replace(/^\\.+/, '').toLowerCase();\n    return normalizedExtension !== '' && lowerCaseName.endsWith(`.${normalizedExtension}`);\n  });\n}\n\n/**\n * Trims the markdown extension from the file path if the file is a markdown file.\n * If the file is not a markdown file, the original file path is returned.\n *\n * @param file - The file to trim the markdown extension from.\n * @returns The file path with the markdown extension trimmed.\n */\nexport function trimMarkdownExtension(file: TAbstractFile): string {\n  if (!isMarkdownFile(file)) {\n    return file.path;\n  }\n\n  return trimEnd({\n    str: file.path,\n    suffix: `.${MARKDOWN_FILE_EXTENSION}`\n  });\n}\n\nfunction getFileInternal(params: GetFileInternalParams): null | TAbstractFile {\n  const {\n    app,\n    path\n  } = params;\n  let { isCaseInsensitive } = params;\n  isCaseInsensitive ??= getDataAdapterEx(app).insensitive;\n  if (isCaseInsensitive) {\n    const caseInsensitiveFileIndex = getCaseInsensitiveFileIndex(app);\n    if (caseInsensitiveFileIndex) {\n      return caseInsensitiveFileIndex.get(path);\n    }\n    return app.vault.getAbstractFileByPathInsensitive(path);\n  }\n\n  return app.vault.getAbstractFileByPath(path);\n}\n\nfunction getName(pathOrFile: PathOrAbstractFile): string {\n  return isAbstractFile(pathOrFile) ? pathOrFile.name : basename(pathOrFile);\n}\n\nfunction getResolvedPath(path: string): string {\n  return normalizePath(resolve('/', path));\n}\n"],
  "mappings": "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",
  "names": ["FileSystemType"]
}


package/dist/lib/esm/obsidian/i18n/locales/en.d.mts

@@ -36,6 +36,9 @@ export declare const en: {
             readonly closeAriaLabel: "Close";
             readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
         };
+        readonly pathSettings: {
+            readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
+        };
         readonly queue: {
             readonly flushQueue: "Flush queue";
         };

package/dist/lib/esm/obsidian/i18n/locales/en.mjs

@@ -50,6 +50,9 @@ const en = {
       closeAriaLabel: "Close",
       unhandledError: "An unhandled error occurred. Please check the console for more information."
     },
+    pathSettings: {
+      invalidRegularExpression: "Invalid regular expression: {{regExp}}"
+    },
     queue: {
       flushQueue: "Flush queue"
     },
@@ -74,4 +77,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/i18n/locales/translations-map.d.mts

@@ -39,6 +39,9 @@ declare const translationsMapImpl: {
                 readonly closeAriaLabel: "Close";
                 readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
             };
+            readonly pathSettings: {
+                readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
+            };
             readonly queue: {
                 readonly flushQueue: "Flush queue";
             };

package/dist/lib/esm/obsidian/index.d.mts

@@ -36,6 +36,7 @@ export * as 'hover-link-source-registrar' from './hover-link-source-registrar.mj
 export * as 'html-element' from './html-element.mjs';
 export * as 'i18n' from './i18n/index.mjs';
 export * as 'is-in-obsidian' from './is-in-obsidian.mjs';
+export * as 'link-update-progress' from './link-update-progress.mjs';
 export * as 'link' from './link.mjs';
 export * as 'logger' from './logger.mjs';
 export * as 'loop' from './loop.mjs';
@@ -54,6 +55,7 @@ export * as 'path-settings' from './path-settings.mjs';
 export * as 'pdf' from './pdf.mjs';
 export * as 'plugin' from './plugin/index.mjs';
 export * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.mjs';
+export * as 'popovers' from './popovers/index.mjs';
 export * as 'queue' from './queue.mjs';
 export * as 'react' from './react/index.mjs';
 export * as 'reference' from './reference.mjs';

package/dist/lib/esm/obsidian/index.mjs

@@ -58,6 +58,7 @@ import * as hover_link_source_registrar from "./hover-link-source-registrar.mjs"
 import * as html_element from "./html-element.mjs";
 import * as i18n from "./i18n/index.mjs";
 import * as is_in_obsidian from "./is-in-obsidian.mjs";
+import * as link_update_progress from "./link-update-progress.mjs";
 import * as link from "./link.mjs";
 import * as logger from "./logger.mjs";
 import * as loop from "./loop.mjs";
@@ -76,6 +77,7 @@ import * as path_settings from "./path-settings.mjs";
 import * as pdf from "./pdf.mjs";
 import * as plugin from "./plugin/index.mjs";
 import * as plugin_cli_handler_registrar from "./plugin-cli-handler-registrar.mjs";
+import * as popovers from "./popovers/index.mjs";
 import * as queue from "./queue.mjs";
 import * as react from "./react/index.mjs";
 import * as reference from "./reference.mjs";
@@ -131,6 +133,7 @@ export {
   i18n,
   is_in_obsidian as "is-in-obsidian",
   link,
+  link_update_progress as "link-update-progress",
   logger,
   loop,
   markdown,
@@ -148,6 +151,7 @@ export {
   pdf,
   plugin,
   plugin_cli_handler_registrar as "plugin-cli-handler-registrar",
+  popovers,
   queue,
   react,
   reference,
@@ -165,4 +169,4 @@ export {
   view_registrar as "view-registrar",
   workspace
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,uBAAyB;AACrC,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "demo-vault-helper", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/index.ts"],
  "sourcesContent": ["/* THIS IS A GENERATED/BUNDLED FILE BY BUILD SCRIPT */\n\nexport * as 'active-file-provider' from './active-file-provider.ts';\nexport * as 'app' from './app.ts';\nexport * as 'async-with-notice' from './async-with-notice.ts';\nexport * as 'attachment-path' from './attachment-path.ts';\nexport * as 'backlink' from './backlink.ts';\nexport * as 'bases-view-registrar' from './bases-view-registrar.ts';\nexport * as 'callout' from './callout.ts';\nexport * as 'canvas' from './canvas.ts';\nexport * as 'case-insensitive-file-index' from './case-insensitive-file-index.ts';\nexport * as 'code-block-markdown-information' from './code-block-markdown-information.ts';\nexport * as 'code-block-reg-exp' from './code-block-reg-exp.ts';\nexport * as 'command-handlers' from './command-handlers/index.ts';\nexport * as 'command-registrar' from './command-registrar.ts';\nexport * as 'community-plugins' from './community-plugins.ts';\nexport * as 'components' from './components/index.ts';\nexport * as 'constructors' from './constructors/index.ts';\nexport * as 'css-class' from './css-class.ts';\nexport * as 'data-handler' from './data-handler.ts';\nexport * as 'dataview-link' from './dataview-link.ts';\nexport * as 'dataview' from './dataview.ts';\nexport * as 'demo-vault-helper' from './demo-vault-helper.ts';\nexport * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.ts';\nexport * as 'desktop-trusted-input' from './desktop-trusted-input.ts';\nexport * as 'editor-extension-registrar' from './editor-extension-registrar.ts';\nexport * as 'editor-suggest-registrar' from './editor-suggest-registrar.ts';\nexport * as 'editor' from './editor.ts';\nexport * as 'events' from './events.ts';\nexport * as 'extensions-registrar' from './extensions-registrar.ts';\nexport * as 'file-change' from './file-change.ts';\nexport * as 'file-manager' from './file-manager.ts';\nexport * as 'file-system' from './file-system.ts';\nexport * as 'frontmatter-link-cache-with-offsets' from './frontmatter-link-cache-with-offsets.ts';\nexport * as 'frontmatter' from './frontmatter.ts';\nexport * as 'hover-link-source-registrar' from './hover-link-source-registrar.ts';\nexport * as 'html-element' from './html-element.ts';\nexport * as 'i18n' from './i18n/index.ts';\nexport * as 'is-in-obsidian' from './is-in-obsidian.ts';\nexport * as 'link-update-progress' from './link-update-progress.ts';\nexport * as 'link' from './link.ts';\nexport * as 'logger' from './logger.ts';\nexport * as 'loop' from './loop.ts';\nexport * as 'markdown-code-block-processor-registrar' from './markdown-code-block-processor-registrar.ts';\nexport * as 'markdown-code-block-processor' from './markdown-code-block-processor.ts';\nexport * as 'markdown-post-processor-registrar' from './markdown-post-processor-registrar.ts';\nexport * as 'markdown-view' from './markdown-view.ts';\nexport * as 'markdown' from './markdown.ts';\nexport * as 'menu-event-registrar' from './menu-event-registrar.ts';\nexport * as 'metadata-cache' from './metadata-cache.ts';\nexport * as 'modals' from './modals/index.ts';\nexport * as 'obsidian-protocol-handler-registrar' from './obsidian-protocol-handler-registrar.ts';\nexport * as 'obsidian-settings' from './obsidian-settings.ts';\nexport * as 'parse-link' from './parse-link.ts';\nexport * as 'path-settings' from './path-settings.ts';\nexport * as 'pdf' from './pdf.ts';\nexport * as 'plugin' from './plugin/index.ts';\nexport * as 'plugin-cli-handler-registrar' from './plugin-cli-handler-registrar.ts';\nexport * as 'popovers' from './popovers/index.ts';\nexport * as 'queue' from './queue.ts';\nexport * as 'react' from './react/index.ts';\nexport * as 'reference' from './reference.ts';\nexport * as 'resource-lock' from './resource-lock.ts';\nexport * as 'resource-url' from './resource-url.ts';\nexport * as 'ribbon-icon-registrar' from './ribbon-icon-registrar.ts';\nexport * as 'setting-components' from './setting-components/index.ts';\nexport * as 'setting-ex' from './setting-ex.ts';\nexport * as 'setting-group-ex' from './setting-group-ex.ts';\nexport * as 'status-bar-item-registrar' from './status-bar-item-registrar.ts';\nexport * as 'validation' from './validation.ts';\nexport * as 'vault-delete' from './vault-delete.ts';\nexport * as 'vault-transaction' from './vault-transaction.ts';\nexport * as 'vault' from './vault.ts';\nexport * as 'view-registrar' from './view-registrar.ts';\nexport * as 'workspace' from './workspace.ts';\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAYA,0BAA4B;AACxC,YAAY,SAAW;AACvB,YAAYC,uBAAyB;AACrC,YAAYC,qBAAuB;AACnC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAY,aAAe;AAC3B,YAAY,YAAc;AAC1B,YAAYC,iCAAmC;AAC/C,YAAYC,qCAAuC;AACnD,YAAYC,wBAA0B;AACtC,YAAYC,sBAAwB;AACpC,YAAYC,uBAAyB;AACrC,YAAYC,uBAAyB;AACrC,YAAY,gBAAkB;AAC9B,YAAY,kBAAoB;AAChC,YAAYC,eAAiB;AAC7B,YAAYC,kBAAoB;AAChC,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,uBAAyB;AACrC,YAAYC,+BAAiC;AAC7C,YAAYC,2BAA6B;AACzC,YAAYC,gCAAkC;AAC9C,YAAYC,8BAAgC;AAC5C,YAAY,YAAc;AAC1B,YAAY,YAAc;AAC1B,YAAYC,0BAA4B;AACxC,YAAYC,iBAAmB;AAC/B,YAAYC,kBAAoB;AAChC,YAAYC,iBAAmB;AAC/B,YAAYC,yCAA2C;AACvD,YAAY,iBAAmB;AAC/B,YAAYC,iCAAmC;AAC/C,YAAYC,kBAAoB;AAChC,YAAY,UAAY;AACxB,YAAYC,oBAAsB;AAClC,YAAYC,0BAA4B;AACxC,YAAY,UAAY;AACxB,YAAY,YAAc;AAC1B,YAAY,UAAY;AACxB,YAAYC,6CAA+C;AAC3D,YAAYC,mCAAqC;AACjD,YAAYC,uCAAyC;AACrD,YAAYC,mBAAqB;AACjC,YAAY,cAAgB;AAC5B,YAAYC,0BAA4B;AACxC,YAAYC,oBAAsB;AAClC,YAAY,YAAc;AAC1B,YAAYC,yCAA2C;AACvD,YAAYC,uBAAyB;AACrC,YAAYC,gBAAkB;AAC9B,YAAYC,mBAAqB;AACjC,YAAY,SAAW;AACvB,YAAY,YAAc;AAC1B,YAAYC,kCAAoC;AAChD,YAAY,cAAgB;AAC5B,YAAY,WAAa;AACzB,YAAY,WAAa;AACzB,YAAY,eAAiB;AAC7B,YAAYC,mBAAqB;AACjC,YAAYC,kBAAoB;AAChC,YAAYC,2BAA6B;AACzC,YAAYC,wBAA0B;AACtC,YAAYC,gBAAkB;AAC9B,YAAYC,sBAAwB;AACpC,YAAYC,+BAAiC;AAC7C,YAAY,gBAAkB;AAC9B,YAAYC,kBAAoB;AAChC,YAAYC,uBAAyB;AACrC,YAAY,WAAa;AACzB,YAAYC,oBAAsB;AAClC,YAAY,eAAiB;",
  "names": ["active-file-provider", "async-with-notice", "attachment-path", "bases-view-registrar", "case-insensitive-file-index", "code-block-markdown-information", "code-block-reg-exp", "command-handlers", "command-registrar", "community-plugins", "css-class", "data-handler", "dataview-link", "demo-vault-helper", "desktop-demo-vault-opener", "desktop-trusted-input", "editor-extension-registrar", "editor-suggest-registrar", "extensions-registrar", "file-change", "file-manager", "file-system", "frontmatter-link-cache-with-offsets", "hover-link-source-registrar", "html-element", "is-in-obsidian", "link-update-progress", "markdown-code-block-processor-registrar", "markdown-code-block-processor", "markdown-post-processor-registrar", "markdown-view", "menu-event-registrar", "metadata-cache", "obsidian-protocol-handler-registrar", "obsidian-settings", "parse-link", "path-settings", "plugin-cli-handler-registrar", "resource-lock", "resource-url", "ribbon-icon-registrar", "setting-components", "setting-ex", "setting-group-ex", "status-bar-item-registrar", "vault-delete", "vault-transaction", "view-registrar"]
}


package/dist/lib/esm/obsidian/link-update-progress.d.mts

@@ -0,0 +1,32 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Types describing the progress reported while links are updated across multiple files during a
+ * rename/move link-update operation. A consumer (e.g. a plugin) can supply a
+ * {@link LinkUpdateProgressReporter} to surface a persistent/updating "N of M links updated" notice.
+ */
+/**
+ * A progress update emitted once per file whose links are updated during a multi-file rename/move
+ * link-update operation.
+ */
+export interface LinkUpdateProgress {
+    /**
+     * The path of the file whose links were just updated.
+     */
+    readonly currentPath: string;
+    /**
+     * The number of files processed so far, including the current one.
+     */
+    readonly processed: number;
+    /**
+     * The total number of files whose links will be updated.
+     */
+    readonly total: number;
+}
+/**
+ * A reporter invoked once per file whose links are updated during a multi-file rename/move
+ * link-update operation. It is always optional: when it is not provided, no progress is reported and
+ * behavior is otherwise unchanged.
+ */
+export type LinkUpdateProgressReporter = (this: void, progress: LinkUpdateProgress) => void;

package/dist/lib/esm/obsidian/link-update-progress.mjs

@@ -0,0 +1,24 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/obsidian/link.d.mts

@@ -9,6 +9,7 @@ import type { App, CachedMetadata, Reference, TFile } from 'obsidian';
 import type { Promisable } from 'type-fest';
 import type { MaybeReturn } from '../type.mjs';
 import type { PathOrFile } from './file-system.mjs';
+import type { LinkUpdateProgressReporter } from './link-update-progress.mjs';
 import type { ProcessOptions } from './vault.mjs';
 /**
  * A style of the link path.
@@ -110,6 +111,11 @@ export interface EditBacklinksParams extends EditBacklinksOptions {
      * The function that converts each link.
      */
     linkConverter(this: void, link: Reference): Promisable<MaybeReturn<string>>;
+    /**
+     * An optional reporter invoked once per backlink file after its links are updated, with the running
+     * count of processed files and the total. When omitted, no progress is reported.
+     */
+    readonly linkUpdateProgressReporter?: LinkUpdateProgressReporter;
     /**
      * The path or file to edit the backlinks for.
      */