obsidian-dev-utils 50.0.0 → 51.1.6

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

@@ -0,0 +1,441 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import {
+  MarkdownView,
+  TAbstractFile,
+  TFile,
+  TFolder
+} from "obsidian";
+import {
+  getDataAdapterEx,
+  parentFolderPath,
+  ViewType
+} from "obsidian-typings/implementations";
+import { abortSignalAny } from "../abort-controller.mjs";
+import { getLibDebugger } from "../debug.mjs";
+import { noopAsync } from "../function.mjs";
+import {
+  basename,
+  dirname,
+  extname,
+  join
+} from "../path.mjs";
+import { resolveValue } from "../value-provider.mjs";
+import { retryWithTimeoutNotice } from "./async-with-notice.mjs";
+import {
+  lockEditor,
+  unlockEditor
+} from "./editor.mjs";
+import {
+  asFile,
+  asFolder,
+  FileSystemType,
+  getAbstractFile,
+  getAbstractFileOrNull,
+  getFile,
+  getFileOrNull,
+  getFileSystemType,
+  getFolder,
+  getFolderOrNull,
+  getPath,
+  isFile,
+  isMarkdownFile,
+  isNote
+} from "./file-system.mjs";
+import { t } from "./i18n/i18n.mjs";
+async function copySafe(app, oldPathOrFile, newPath) {
+  const file = getFile(app, oldPathOrFile);
+  if (file.path === newPath) {
+    return newPath;
+  }
+  const newFolderPath = parentFolderPath(newPath);
+  await createFolderSafe(app, newFolderPath);
+  const newAvailablePath = getAvailablePath(app, newPath);
+  try {
+    await app.vault.copy(file, newAvailablePath);
+  } catch (e) {
+    if (!await app.vault.exists(newAvailablePath)) {
+      throw e;
+    }
+  }
+  return newAvailablePath;
+}
+async function createFolderSafe(app, path) {
+  if (await app.vault.adapter.exists(path)) {
+    return false;
+  }
+  try {
+    await app.vault.createFolder(path);
+    return true;
+  } catch (e) {
+    if (!await app.vault.exists(path)) {
+      throw e;
+    }
+    return true;
+  }
+}
+async function createTempFile(app, path) {
+  let file = getFileOrNull(app, path);
+  if (file) {
+    return noopAsync;
+  }
+  const folderCleanup = await createTempFolder(app, parentFolderPath(path));
+  try {
+    await app.vault.create(path, "");
+  } catch (e) {
+    if (!await app.vault.exists(path)) {
+      throw e;
+    }
+  }
+  return async () => {
+    file = getFile(app, path);
+    if (!file.deleted) {
+      await trashSafe(app, file);
+    }
+    await folderCleanup();
+  };
+}
+async function createTempFolder(app, path) {
+  let folder = getFolderOrNull(app, path);
+  if (folder) {
+    return noopAsync;
+  }
+  const folderPath = parentFolderPath(path);
+  await createTempFolder(app, folderPath);
+  const folderCleanup = await createTempFolder(app, parentFolderPath(path));
+  await createFolderSafe(app, path);
+  return async () => {
+    folder = getFolder(app, path);
+    if (!folder.deleted) {
+      await trashSafe(app, folder);
+    }
+    await folderCleanup();
+  };
+}
+async function deleteEmptyFolder(app, pathOrFolder) {
+  const folder = getFolderOrNull(app, pathOrFolder);
+  if (!folder) {
+    return;
+  }
+  if (!await isEmptyFolder(app, folder)) {
+    return;
+  }
+  await trashSafe(app, folder);
+}
+async function deleteEmptyFolderHierarchy(app, pathOrFolder) {
+  let folder = getFolderOrNull(app, pathOrFolder);
+  while (folder) {
+    if (!await isEmptyFolder(app, folder)) {
+      return;
+    }
+    const parent = folder.parent;
+    await deleteEmptyFolder(app, folder);
+    folder = parent;
+  }
+}
+function getAbstractFilePathSafe(app, path, type) {
+  const abstractFile = getAbstractFileOrNull(app, path);
+  if (abstractFile && getFileSystemType(abstractFile) === type) {
+    return path;
+  }
+  return getAvailablePath(app, path);
+}
+function getAvailablePath(app, path) {
+  const ext = extname(path);
+  return app.vault.getAvailablePath(join(dirname(path), basename(path, ext)), ext.slice(1));
+}
+function getFilePathSafe(app, path) {
+  return getAbstractFilePathSafe(app, path, FileSystemType.File);
+}
+function getFolderPathSafe(app, path) {
+  return getAbstractFilePathSafe(app, path, FileSystemType.Folder);
+}
+function getMarkdownFilesSorted(app) {
+  return app.vault.getMarkdownFiles().sort((a, b) => a.path.localeCompare(b.path));
+}
+function getNoteFilesSorted(app) {
+  return app.vault.getAllLoadedFiles().filter((file) => isFile(file) && isNote(app, file)).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function getOrCreateAbstractFileSafe(app, path, type) {
+  path = getAbstractFilePathSafe(app, path, type);
+  const abstractFile = getAbstractFileOrNull(app, path);
+  if (abstractFile) {
+    return abstractFile;
+  }
+  switch (type) {
+    case FileSystemType.File:
+      return await app.vault.create(path, "");
+    case FileSystemType.Folder:
+      return await app.vault.createFolder(path);
+    default:
+      throw new Error(`Invalid file system type: ${type}`);
+  }
+}
+async function getOrCreateFileSafe(app, path) {
+  return asFile(await getOrCreateAbstractFileSafe(app, path, FileSystemType.File));
+}
+async function getOrCreateFolderSafe(app, path) {
+  return asFolder(await getOrCreateAbstractFileSafe(app, path, FileSystemType.Folder));
+}
+function getSafeRenamePath(app, oldPathOrAbstractFile, newPath) {
+  const oldPath = getPath(app, oldPathOrAbstractFile);
+  if (getDataAdapterEx(app).insensitive) {
+    let folderPath = dirname(newPath);
+    let nonExistingPath = basename(newPath);
+    let folder;
+    while (true) {
+      folder = getFolderOrNull(app, folderPath, true);
+      if (folder) {
+        break;
+      }
+      nonExistingPath = join(basename(folderPath), nonExistingPath);
+      folderPath = dirname(folderPath);
+    }
+    newPath = join(folder.getParentPrefix(), nonExistingPath);
+  }
+  if (oldPath.toLowerCase() === newPath.toLowerCase()) {
+    return newPath;
+  }
+  return getAvailablePath(app, newPath);
+}
+async function invokeWithFileSystemLock(app, pathOrFile, fn) {
+  const file = getFile(app, pathOrFile);
+  await app.vault.process(file, (content) => {
+    fn(content);
+    return content;
+  });
+}
+function isChild(app, a, b) {
+  const aPath = getPath(app, a);
+  const bPath = getPath(app, b);
+  if (aPath === bPath) {
+    return false;
+  }
+  if (bPath === "/") {
+    return true;
+  }
+  return aPath.startsWith(`${bPath}/`);
+}
+function isChildOrSelf(app, a, b) {
+  const aPath = getPath(app, a);
+  const bPath = getPath(app, b);
+  return aPath === bPath || isChild(app, a, b);
+}
+async function isEmptyFolder(app, pathOrFolder) {
+  const listedFiles = await listSafe(app, getPath(app, pathOrFolder));
+  return listedFiles.files.length === 0 && listedFiles.folders.length === 0;
+}
+async function listSafe(app, pathOrFolder) {
+  const path = getPath(app, pathOrFolder);
+  const EMPTY = { files: [], folders: [] };
+  if ((await app.vault.adapter.stat(path))?.type !== "folder") {
+    return EMPTY;
+  }
+  try {
+    return await app.vault.adapter.list(path);
+  } catch (e) {
+    if (await app.vault.exists(path)) {
+      throw e;
+    }
+    return EMPTY;
+  }
+}
+async function process(app, pathOrFile, newContentProvider, options = {}) {
+  const DEFAULT_RETRY_OPTIONS = {
+    shouldFailOnMissingFile: true,
+    shouldLockEditorWhileProcessing: true,
+    shouldShowTimeoutNotice: true,
+    // eslint-disable-next-line no-magic-numbers -- Default value.
+    timeoutInMilliseconds: 500
+  };
+  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  const abortController = new AbortController();
+  fullOptions.abortSignal = abortSignalAny(fullOptions.abortSignal, abortController.signal);
+  const path = getPath(app, pathOrFile);
+  let activeLeafChangeEventRef = null;
+  if (fullOptions.shouldLockEditorWhileProcessing) {
+    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+      if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path) {
+        lockEditor(leaf.view.editor);
+      }
+    }
+    activeLeafChangeEventRef = app.workspace.on("active-leaf-change", (leaf) => {
+      if (leaf?.view instanceof MarkdownView && leaf.view.file?.path === path) {
+        lockEditor(leaf.view.editor);
+      }
+    });
+  }
+  try {
+    await retryWithTimeoutNotice({
+      async operationFn(abortSignal) {
+        abortSignal.throwIfAborted();
+        const oldContent = await readSafe(app, pathOrFile);
+        abortSignal.throwIfAborted();
+        if (oldContent === null) {
+          return handleMissingFile();
+        }
+        const newContent = await resolveValue(newContentProvider, abortSignal, oldContent);
+        abortSignal.throwIfAborted();
+        if (newContent === null) {
+          return false;
+        }
+        let isSuccess = true;
+        const doesFileExist = await invokeFileActionSafe(app, pathOrFile, async (file) => {
+          abortSignal.throwIfAborted();
+          await app.vault.process(file, (content) => {
+            abortSignal.throwIfAborted();
+            if (content !== oldContent) {
+              getLibDebugger("Vault:process")("Content has changed since it was read. Retrying...", {
+                actualContent: content,
+                expectedContent: oldContent,
+                path: file.path
+              });
+              isSuccess = false;
+              return content;
+            }
+            return newContent;
+          });
+          abortSignal.throwIfAborted();
+        });
+        if (!doesFileExist) {
+          return handleMissingFile();
+        }
+        return isSuccess;
+        function handleMissingFile() {
+          if (fullOptions.shouldFailOnMissingFile) {
+            throw new Error(`File '${path}' not found`);
+          }
+          return true;
+        }
+      },
+      operationName: t(($) => $.obsidianDevUtils.vault.processFile, { filePath: path }),
+      retryOptions: fullOptions,
+      shouldShowTimeoutNotice: fullOptions.shouldShowTimeoutNotice
+    });
+  } finally {
+    activeLeafChangeEventRef?.e.offref(activeLeafChangeEventRef);
+    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+      if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path) {
+        unlockEditor(leaf.view.editor);
+      }
+    }
+  }
+}
+async function readSafe(app, pathOrFile) {
+  let content = null;
+  await invokeFileActionSafe(app, pathOrFile, async (file) => {
+    await saveNote(app, file);
+    content = await app.vault.read(file);
+  });
+  return content;
+}
+async function renameSafe(app, oldPathOrAbstractFile, newPath) {
+  const oldAbstractFile = getAbstractFile(app, oldPathOrAbstractFile);
+  const newAvailablePath = getSafeRenamePath(app, oldPathOrAbstractFile, newPath);
+  if (oldAbstractFile.path.toLowerCase() === newAvailablePath.toLowerCase()) {
+    if (oldAbstractFile.path !== newPath) {
+      await app.fileManager.renameFile(oldAbstractFile, newAvailablePath);
+    }
+    return newAvailablePath;
+  }
+  const newFolderPath = parentFolderPath(newAvailablePath);
+  await createFolderSafe(app, newFolderPath);
+  try {
+    await app.fileManager.renameFile(oldAbstractFile, newAvailablePath);
+  } catch (e) {
+    if (!await app.vault.exists(newAvailablePath) || await app.vault.exists(oldAbstractFile.path)) {
+      throw e;
+    }
+  }
+  return newAvailablePath;
+}
+async function saveNote(app, pathOrFile) {
+  if (!isMarkdownFile(app, pathOrFile)) {
+    return;
+  }
+  const path = getPath(app, pathOrFile);
+  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+    if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path && leaf.view.dirty) {
+      await leaf.view.save();
+    }
+  }
+}
+async function trashSafe(app, pathOrFile) {
+  const file = getAbstractFileOrNull(app, pathOrFile);
+  if (!file) {
+    return;
+  }
+  try {
+    await app.fileManager.trashFile(file);
+  } catch (e) {
+    if (await app.vault.exists(file.path)) {
+      throw e;
+    }
+    getLibDebugger("Vault:trashSafe")(`An error occurred while trashing ${file.path}, but the file no longer exists.`, { error: e, path: file.path });
+  }
+}
+async function invokeFileActionSafe(app, pathOrFile, fileAction) {
+  const path = getPath(app, pathOrFile);
+  let file = getFileOrNull(app, path);
+  if (!file || file.deleted) {
+    return false;
+  }
+  try {
+    await fileAction(file);
+    return true;
+  } catch (e) {
+    file = getFileOrNull(app, path);
+    if (!file || file.deleted) {
+      return false;
+    }
+    throw e;
+  }
+}
+export {
+  copySafe,
+  createFolderSafe,
+  createTempFile,
+  createTempFolder,
+  deleteEmptyFolder,
+  deleteEmptyFolderHierarchy,
+  getAbstractFilePathSafe,
+  getAvailablePath,
+  getFilePathSafe,
+  getFolderPathSafe,
+  getMarkdownFilesSorted,
+  getNoteFilesSorted,
+  getOrCreateAbstractFileSafe,
+  getOrCreateFileSafe,
+  getOrCreateFolderSafe,
+  getSafeRenamePath,
+  invokeWithFileSystemLock,
+  isChild,
+  isChildOrSelf,
+  isEmptyFolder,
+  listSafe,
+  process,
+  readSafe,
+  renameSafe,
+  saveNote,
+  trashSafe
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/vault.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * This module provides utility functions for working with the Obsidian Vault.\n */\n\nimport type {\n  App,\n  EventRef,\n  ListedFiles\n} from 'obsidian';\n\nimport {\n  MarkdownView,\n  TAbstractFile,\n  TFile,\n  TFolder\n} from 'obsidian';\nimport {\n  getDataAdapterEx,\n  parentFolderPath,\n  ViewType\n} from 'obsidian-typings/implementations';\n\nimport type { RetryOptions } from '../async.ts';\nimport type { ValueProvider } from '../value-provider.ts';\nimport type {\n  PathOrAbstractFile,\n  PathOrFile,\n  PathOrFolder\n} from './file-system.ts';\n\nimport { abortSignalAny } from '../abort-controller.ts';\nimport { getLibDebugger } from '../debug.ts';\nimport { noopAsync } from '../function.ts';\nimport {\n  basename,\n  dirname,\n  extname,\n  join\n} from '../path.ts';\nimport { resolveValue } from '../value-provider.ts';\nimport { retryWithTimeoutNotice } from './async-with-notice.ts';\nimport {\n  lockEditor,\n  unlockEditor\n} from './editor.ts';\nimport {\n  asFile,\n  asFolder,\n  FileSystemType,\n  getAbstractFile,\n  getAbstractFileOrNull,\n  getFile,\n  getFileOrNull,\n  getFileSystemType,\n  getFolder,\n  getFolderOrNull,\n  getPath,\n  isFile,\n  isMarkdownFile,\n  isNote\n} from './file-system.ts';\nimport { t } from './i18n/i18n.ts';\n\n/**\n * Options for {@link process}.\n */\nexport interface ProcessOptions extends RetryOptions {\n  /**\n   * Whether to fail if the file is missing or deleted. Default is `true`.\n   */\n  readonly shouldFailOnMissingFile?: boolean;\n\n  /**\n   * Whether to lock the editor while processing the file. Applicable only for markdown files. Default is `true`.\n   */\n  readonly shouldLockEditorWhileProcessing?: boolean;\n\n  /**\n   * Whether to show a timeout notice. Default is `true`.\n   */\n  readonly shouldShowTimeoutNotice?: boolean;\n}\n\n/**\n * Copies a file safely in the vault.\n *\n * @param app - The application instance.\n * @param oldPathOrFile - The old path or file to copy.\n * @param newPath - The new path to copy the file to.\n * @returns A {@link Promise} that resolves to the new path of the copied file.\n */\nexport async function copySafe(app: App, oldPathOrFile: PathOrFile, newPath: string): Promise<string> {\n  const file = getFile(app, oldPathOrFile);\n\n  if (file.path === newPath) {\n    return newPath;\n  }\n\n  const newFolderPath = parentFolderPath(newPath);\n  await createFolderSafe(app, newFolderPath);\n\n  const newAvailablePath = getAvailablePath(app, newPath);\n\n  try {\n    await app.vault.copy(file, newAvailablePath);\n  } catch (e) {\n    if (!await app.vault.exists(newAvailablePath)) {\n      throw e;\n    }\n  }\n\n  return newAvailablePath;\n}\n\n/**\n * Creates a folder safely in the specified path.\n *\n * @param app - The application instance.\n * @param path - The path of the folder to create.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the folder was created.\n * @throws If an error occurs while creating the folder and it still doesn't exist.\n */\nexport async function createFolderSafe(app: App, path: string): Promise<boolean> {\n  if (await app.vault.adapter.exists(path)) {\n    return false;\n  }\n\n  try {\n    await app.vault.createFolder(path);\n    return true;\n  } catch (e) {\n    if (!await app.vault.exists(path)) {\n      throw e;\n    }\n    return true;\n  }\n}\n\n/**\n * Creates a temporary file in the vault with parent folders if needed.\n *\n * @param app - The application instance.\n * @param path - The path of the file to create.\n * @returns A {@link Promise} that resolves to a function that can be called to delete the temporary file and all its created parents.\n */\nexport async function createTempFile(app: App, path: string): Promise<() => Promise<void>> {\n  let file = getFileOrNull(app, path);\n  if (file) {\n    return noopAsync;\n  }\n\n  const folderCleanup = await createTempFolder(app, parentFolderPath(path));\n\n  try {\n    await app.vault.create(path, '');\n  } catch (e) {\n    if (!await app.vault.exists(path)) {\n      throw e;\n    }\n  }\n\n  return async () => {\n    file = getFile(app, path);\n    if (!file.deleted) {\n      await trashSafe(app, file);\n    }\n    await folderCleanup();\n  };\n}\n\n/**\n * Creates a temporary folder in the vault with parent folders if needed.\n *\n * @param app - The application instance.\n * @param path - The path of the folder to create.\n * @returns A {@link Promise} that resolves to a function that can be called to delete the temporary folder and all its created parents.\n */\nexport async function createTempFolder(app: App, path: string): Promise<() => Promise<void>> {\n  let folder = getFolderOrNull(app, path);\n  if (folder) {\n    return noopAsync;\n  }\n\n  const folderPath = parentFolderPath(path);\n  await createTempFolder(app, folderPath);\n\n  const folderCleanup = await createTempFolder(app, parentFolderPath(path));\n\n  await createFolderSafe(app, path);\n\n  return async () => {\n    folder = getFolder(app, path);\n    if (!folder.deleted) {\n      await trashSafe(app, folder);\n    }\n    await folderCleanup();\n  };\n}\n\n/**\n * Deletes an empty folder.\n *\n * @param app - The application instance.\n * @param pathOrFolder - The folder to delete.\n * @returns A {@link Promise} that resolves when the folder is deleted.\n */\nexport async function deleteEmptyFolder(app: App, pathOrFolder: null | PathOrFolder): Promise<void> {\n  const folder = getFolderOrNull(app, pathOrFolder);\n  if (!folder) {\n    return;\n  }\n  if (!await isEmptyFolder(app, folder)) {\n    return;\n  }\n  await trashSafe(app, folder);\n}\n\n/**\n * Removes empty folder hierarchy starting from the given folder.\n *\n * @param app - The application instance.\n * @param pathOrFolder - The folder to start removing empty hierarchy from.\n * @returns A {@link Promise} that resolves when the empty hierarchy is deleted.\n */\nexport async function deleteEmptyFolderHierarchy(app: App, pathOrFolder: null | PathOrFolder): Promise<void> {\n  let folder = getFolderOrNull(app, pathOrFolder);\n\n  while (folder) {\n    if (!await isEmptyFolder(app, folder)) {\n      return;\n    }\n    const parent = folder.parent;\n    await deleteEmptyFolder(app, folder);\n    folder = parent;\n  }\n}\n\n/**\n * Gets a safe path for a file or folder.\n *\n * @param app - The application instance.\n * @param path - The path of the file or folder to get a safe path for.\n * @param type - The type of the file system object.\n * @returns The safe path for the file or folder.\n */\nexport function getAbstractFilePathSafe(app: App, path: string, type: FileSystemType): string {\n  const abstractFile = getAbstractFileOrNull(app, path);\n\n  if (abstractFile && getFileSystemType(abstractFile) === type) {\n    return path;\n  }\n\n  return getAvailablePath(app, path);\n}\n\n/**\n * Gets an available path for a file in the vault.\n *\n * @param app - The application instance.\n * @param path - The path of the file to get an available path for.\n * @returns The available path for the file.\n */\nexport function getAvailablePath(app: App, path: string): string {\n  const ext = extname(path);\n  return app.vault.getAvailablePath(join(dirname(path), basename(path, ext)), ext.slice(1));\n}\n\n/**\n * Gets a safe file path for a file or folder.\n *\n * @param app - The application instance.\n * @param path - The path of the file or folder to get a safe path for.\n * @returns The safe path for the file or folder.\n */\nexport function getFilePathSafe(app: App, path: string): string {\n  return getAbstractFilePathSafe(app, path, FileSystemType.File);\n}\n\n/**\n * Gets a safe folder path for a file or folder.\n *\n * @param app - The application instance.\n * @param path - The path of the file or folder to get a safe path for.\n * @returns The safe path for the file or folder.\n */\nexport function getFolderPathSafe(app: App, path: string): string {\n  return getAbstractFilePathSafe(app, path, FileSystemType.Folder);\n}\n\n/**\n * Retrieves an array of Markdown files from the app's vault and sorts them alphabetically by their file path.\n *\n * @param app - The Obsidian app instance.\n * @returns An array of Markdown files sorted by file path.\n */\nexport function getMarkdownFilesSorted(app: App): TFile[] {\n  return app.vault.getMarkdownFiles().sort((a, b) => a.path.localeCompare(b.path));\n}\n\n/**\n * Retrieves an array of all note files from the app's vault and sorts them alphabetically by their file path.\n *\n * @param app - The Obsidian app instance.\n * @returns An array of all note files in the vault sorted by file path.\n */\nexport function getNoteFilesSorted(app: App): TFile[] {\n  return app.vault.getAllLoadedFiles().filter((file) => isFile(file) && isNote(app, file)).sort((a, b) => a.path.localeCompare(b.path)) as TFile[];\n}\n\n/**\n * Gets or creates an abstract file safely in the specified path.\n *\n * If the file already exists, it will be returned.\n * If the file does not exist, it will be created and returned.\n *\n * @param app - The application instance.\n * @param path - The path of the abstract file to get or create.\n * @param type - The type of the abstract file to get or create.\n * @returns A {@link Promise} that resolves to the abstract file.\n */\nexport async function getOrCreateAbstractFileSafe(app: App, path: string, type: FileSystemType): Promise<TAbstractFile> {\n  path = getAbstractFilePathSafe(app, path, type);\n  const abstractFile = getAbstractFileOrNull(app, path);\n  if (abstractFile) {\n    return abstractFile;\n  }\n\n  switch (type) {\n    case FileSystemType.File:\n      return await app.vault.create(path, '');\n    case FileSystemType.Folder:\n      return await app.vault.createFolder(path);\n    default:\n      throw new Error(`Invalid file system type: ${type as string}`);\n  }\n}\n\n/**\n * Gets or creates a file safely in the specified path.\n *\n * If the file already exists, it will be returned.\n * If the file does not exist, it will be created and returned.\n *\n * @param app - The application instance.\n * @param path - The path of the file to get or create.\n * @returns A {@link Promise} that resolves to the file.\n */\nexport async function getOrCreateFileSafe(app: App, path: string): Promise<TFile> {\n  return asFile(await getOrCreateAbstractFileSafe(app, path, FileSystemType.File));\n}\n\n/**\n * Gets or creates a folder safely in the specified path.\n *\n * If the folder already exists, it will be returned.\n * If the folder does not exist, it will be created and returned.\n *\n * @param app - The application instance.\n * @param path - The path of the folder to get or create.\n * @returns A {@link Promise} that resolves to the folder.\n */\nexport async function getOrCreateFolderSafe(app: App, path: string): Promise<TFolder> {\n  return asFolder(await getOrCreateAbstractFileSafe(app, path, FileSystemType.Folder));\n}\n\n/**\n * Gets a safe rename path for a file.\n *\n * @param app - The application instance.\n * @param oldPathOrAbstractFile - The old path or abstract file to rename.\n * @param newPath - The new path to rename the abstract file to.\n * @returns The safe rename path for the abstract file.\n */\nexport function getSafeRenamePath(app: App, oldPathOrAbstractFile: PathOrAbstractFile, newPath: string): string {\n  const oldPath = getPath(app, oldPathOrAbstractFile);\n\n  if (getDataAdapterEx(app).insensitive) {\n    let folderPath = dirname(newPath);\n    let nonExistingPath = basename(newPath);\n    let folder: null | TFolder;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- There is no elegant way to perform infinite loops.\n    while (true) {\n      folder = getFolderOrNull(app, folderPath, true);\n      if (folder) {\n        break;\n      }\n      nonExistingPath = join(basename(folderPath), nonExistingPath);\n      folderPath = dirname(folderPath);\n    }\n    newPath = join(folder.getParentPrefix(), nonExistingPath);\n  }\n\n  if (oldPath.toLowerCase() === newPath.toLowerCase()) {\n    return newPath;\n  }\n\n  return getAvailablePath(app, newPath);\n}\n\n/**\n * Invokes a function with the file system lock.\n *\n * @param app - The application instance.\n * @param pathOrFile - The path or file to execute the function with the file system lock of.\n * @param fn - The function to execute.\n */\nexport async function invokeWithFileSystemLock(app: App, pathOrFile: PathOrFile, fn: (content: string) => void): Promise<void> {\n  const file = getFile(app, pathOrFile);\n  await app.vault.process(file, (content) => {\n    fn(content);\n    return content;\n  });\n}\n\n/**\n * Checks if a path or file is a child of another path or file.\n *\n * @param app - The application instance.\n * @param a - The first path or file.\n * @param b - The second path or file.\n * @returns A boolean indicating whether the first path or file is a child of the second path or file.\n */\nexport function isChild(app: App, a: PathOrAbstractFile, b: PathOrAbstractFile): boolean {\n  const aPath = getPath(app, a);\n  const bPath = getPath(app, b);\n\n  if (aPath === bPath) {\n    return false;\n  }\n\n  if (bPath === '/') {\n    return true;\n  }\n\n  return aPath.startsWith(`${bPath}/`);\n}\n\n/**\n * Checks if a path or file is a child or self of another path or file.\n *\n * @param app - The application instance.\n * @param a - The first path or file.\n * @param b - The second path or file.\n * @returns A boolean indicating whether the first path or file is a child or self of the second path or file.\n */\nexport function isChildOrSelf(app: App, a: PathOrAbstractFile, b: PathOrAbstractFile): boolean {\n  const aPath = getPath(app, a);\n  const bPath = getPath(app, b);\n  return aPath === bPath || isChild(app, a, b);\n}\n\n/**\n * Checks if a folder is empty.\n *\n * @param app - The application instance.\n * @param pathOrFolder - The path or folder to check.\n * @returns A {@link Promise} that resolves to a boolean indicating whether the folder is empty.\n */\nexport async function isEmptyFolder(app: App, pathOrFolder: PathOrFolder): Promise<boolean> {\n  const listedFiles = await listSafe(app, getPath(app, pathOrFolder));\n  return listedFiles.files.length === 0 && listedFiles.folders.length === 0;\n}\n\n/**\n * Safely lists the files and folders at the specified path in the vault.\n *\n * @param app - The Obsidian application instance.\n * @param pathOrFolder - The path or folder to list.\n * @returns A {@link Promise} that resolves to a {@link ListedFiles} object containing the listed files and folders.\n */\nexport async function listSafe(app: App, pathOrFolder: PathOrFolder): Promise<ListedFiles> {\n  const path = getPath(app, pathOrFolder);\n  const EMPTY = { files: [], folders: [] };\n\n  if ((await app.vault.adapter.stat(path))?.type !== 'folder') {\n    return EMPTY;\n  }\n\n  try {\n    return await app.vault.adapter.list(path);\n  } catch (e) {\n    if (await app.vault.exists(path)) {\n      throw e;\n    }\n    return EMPTY;\n  }\n}\n\n/**\n * Processes a file with retry logic, updating its content based on a provided value or function.\n *\n * @param app - The application instance, typically used for accessing the vault.\n * @param pathOrFile - The path or file to be processed. It can be a string representing the path or a file object.\n * @param newContentProvider - A value provider that returns the new content based on the old content of the file.\n * It can be a string or a function that takes the old content as an argument and returns the new content.\n * If function is provided, it should return `null` if the process should be retried.\n * @param options - Optional options for processing/retrying the operation.\n *\n * @returns A {@link Promise} that resolves once the process is complete.\n *\n * @throws Will throw an error if the process fails after the specified number of retries or timeout.\n */\nexport async function process(\n  app: App,\n  pathOrFile: PathOrFile,\n  newContentProvider: ValueProvider<null | string, [string]>,\n  options: ProcessOptions = {}\n): Promise<void> {\n  const DEFAULT_RETRY_OPTIONS = {\n    shouldFailOnMissingFile: true,\n    shouldLockEditorWhileProcessing: true,\n    shouldShowTimeoutNotice: true,\n    // eslint-disable-next-line no-magic-numbers -- Default value.\n    timeoutInMilliseconds: 500\n  };\n  const fullOptions = { ...DEFAULT_RETRY_OPTIONS, ...options };\n  const abortController = new AbortController();\n  fullOptions.abortSignal = abortSignalAny(fullOptions.abortSignal, abortController.signal);\n  const path = getPath(app, pathOrFile);\n\n  let activeLeafChangeEventRef: EventRef | null = null;\n\n  if (fullOptions.shouldLockEditorWhileProcessing) {\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path) {\n        lockEditor(leaf.view.editor);\n      }\n    }\n\n    activeLeafChangeEventRef = app.workspace.on('active-leaf-change', (leaf) => {\n      if (leaf?.view instanceof MarkdownView && leaf.view.file?.path === path) {\n        lockEditor(leaf.view.editor);\n      }\n    });\n  }\n\n  try {\n    await retryWithTimeoutNotice({\n      async operationFn(abortSignal) {\n        abortSignal.throwIfAborted();\n\n        const oldContent = await readSafe(app, pathOrFile);\n        abortSignal.throwIfAborted();\n\n        if (oldContent === null) {\n          return handleMissingFile();\n        }\n\n        const newContent = await resolveValue(newContentProvider, abortSignal, oldContent);\n        abortSignal.throwIfAborted();\n\n        if (newContent === null) {\n          return false;\n        }\n\n        let isSuccess = true;\n        const doesFileExist = await invokeFileActionSafe(app, pathOrFile, async (file) => {\n          abortSignal.throwIfAborted();\n          await app.vault.process(file, (content) => {\n            abortSignal.throwIfAborted();\n            if (content !== oldContent) {\n              getLibDebugger('Vault:process')('Content has changed since it was read. Retrying...', {\n                actualContent: content,\n                expectedContent: oldContent,\n                path: file.path\n              });\n              isSuccess = false;\n              return content;\n            }\n\n            return newContent;\n          });\n\n          abortSignal.throwIfAborted();\n        });\n\n        if (!doesFileExist) {\n          return handleMissingFile();\n        }\n\n        return isSuccess;\n\n        function handleMissingFile(): boolean {\n          if (fullOptions.shouldFailOnMissingFile) {\n            throw new Error(`File '${path}' not found`);\n          }\n          return true;\n        }\n      },\n      operationName: t(($) => $.obsidianDevUtils.vault.processFile, { filePath: path }),\n      retryOptions: fullOptions,\n      shouldShowTimeoutNotice: fullOptions.shouldShowTimeoutNotice\n    });\n  } finally {\n    activeLeafChangeEventRef?.e.offref(activeLeafChangeEventRef);\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path) {\n        unlockEditor(leaf.view.editor);\n      }\n    }\n  }\n}\n\n/**\n * Reads the content of a file safely from the vault.\n *\n * It covers the case when the file was removed during the reading.\n *\n * @param app - The application instance.\n * @param pathOrFile - The path or file to read.\n * @returns A {@link Promise} that resolves to the content of the file or `null` if the file is missing or deleted.\n */\nexport async function readSafe(app: App, pathOrFile: PathOrFile): Promise<null | string> {\n  let content: null | string = null;\n  await invokeFileActionSafe(app, pathOrFile, async (file) => {\n    await saveNote(app, file);\n    content = await app.vault.read(file);\n  });\n  return content;\n}\n\n/**\n * Renames a file safely in the vault.\n * If the new path already exists, the file will be renamed to an available path.\n *\n * @param app - The application instance.\n * @param oldPathOrAbstractFile - The old path or file to rename.\n * @param newPath - The new path to rename the file to.\n * @returns A {@link Promise} that resolves to the new path of the file.\n */\nexport async function renameSafe(app: App, oldPathOrAbstractFile: PathOrAbstractFile, newPath: string): Promise<string> {\n  const oldAbstractFile = getAbstractFile(app, oldPathOrAbstractFile);\n\n  const newAvailablePath = getSafeRenamePath(app, oldPathOrAbstractFile, newPath);\n\n  if (oldAbstractFile.path.toLowerCase() === newAvailablePath.toLowerCase()) {\n    if (oldAbstractFile.path !== newPath) {\n      await app.fileManager.renameFile(oldAbstractFile, newAvailablePath);\n    }\n    return newAvailablePath;\n  }\n\n  const newFolderPath = parentFolderPath(newAvailablePath);\n  await createFolderSafe(app, newFolderPath);\n\n  try {\n    await app.fileManager.renameFile(oldAbstractFile, newAvailablePath);\n  } catch (e) {\n    if (!await app.vault.exists(newAvailablePath) || await app.vault.exists(oldAbstractFile.path)) {\n      throw e;\n    }\n  }\n\n  return newAvailablePath;\n}\n\n/**\n * Saves the specified note in the Obsidian app.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The note to be saved.\n * @returns A {@link Promise} that resolves when the note is saved.\n */\nexport async function saveNote(app: App, pathOrFile: PathOrFile): Promise<void> {\n  if (!isMarkdownFile(app, pathOrFile)) {\n    return;\n  }\n\n  const path = getPath(app, pathOrFile);\n\n  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n    if (leaf.view instanceof MarkdownView && leaf.view.file?.path === path && leaf.view.dirty) {\n      await leaf.view.save();\n    }\n  }\n}\n\n/**\n * Trashes an abstract file safely from the vault.\n *\n * @param app - The Obsidian application instance.\n * @param pathOrFile - The path or abstract file to trash.\n * @returns A {@link Promise} that resolves when the file is trashed.\n */\nexport async function trashSafe(app: App, pathOrFile: PathOrAbstractFile): Promise<void> {\n  const file = getAbstractFileOrNull(app, pathOrFile);\n  if (!file) {\n    return;\n  }\n\n  try {\n    await app.fileManager.trashFile(file);\n  } catch (e) {\n    if (await app.vault.exists(file.path)) {\n      throw e;\n    }\n\n    getLibDebugger('Vault:trashSafe')(`An error occurred while trashing ${file.path}, but the file no longer exists.`, { error: e, path: file.path });\n  }\n}\n\nasync function invokeFileActionSafe(app: App, pathOrFile: PathOrFile, fileAction: (file: TFile) => Promise<void>): Promise<boolean> {\n  const path = getPath(app, pathOrFile);\n  let file = getFileOrNull(app, path);\n  if (!file || file.deleted) {\n    return false;\n  }\n  try {\n    await fileAction(file);\n    return true;\n  } catch (e) {\n    file = getFileOrNull(app, path);\n    if (!file || file.deleted) {\n      return false;\n    }\n    throw e;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -0,0 +1,36 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+function getAllContainers(app) {
+  const containers = /* @__PURE__ */ new Set();
+  app.workspace.iterateAllLeaves((leaf) => {
+    containers.add(leaf.getContainer());
+  });
+  return Array.from(containers);
+}
+function getAllDomWindows(app) {
+  return getAllContainers(app).map((container) => container.win);
+}
+export {
+  getAllContainers,
+  getAllDomWindows
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL3dvcmtzcGFjZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqXG4gKiBUaGlzIG1vZHVsZSBwcm92aWRlcyBhZGRpdGlvbmFsIHV0aWxpdGllcyBmb3Igd29ya2luZyB3aXRoIHRoZSBPYnNpZGlhbiB7QGxpbmsgV29ya3NwYWNlfS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIEFwcCxcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFycyAtLSBXZSBuZWVkIHRvIGltcG9ydCBgV29ya3NwYWNlYCB0byB1c2UgaXQgaW4gdGhlIHRzZG9jcy5cbiAgV29ya3NwYWNlLFxuICBXb3Jrc3BhY2VDb250YWluZXJcbn0gZnJvbSAnb2JzaWRpYW4nO1xuXG4vKipcbiAqIFJldHVybnMgYWxsIGNvbnRhaW5lcnMgaW4gdGhlIHdvcmtzcGFjZS5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcC5cbiAqIEByZXR1cm5zIEFsbCBjb250YWluZXJzIGluIHRoZSB3b3Jrc3BhY2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRBbGxDb250YWluZXJzKGFwcDogQXBwKTogV29ya3NwYWNlQ29udGFpbmVyW10ge1xuICBjb25zdCBjb250YWluZXJzID0gbmV3IFNldDxXb3Jrc3BhY2VDb250YWluZXI+KCk7XG4gIGFwcC53b3Jrc3BhY2UuaXRlcmF0ZUFsbExlYXZlcygobGVhZikgPT4ge1xuICAgIGNvbnRhaW5lcnMuYWRkKGxlYWYuZ2V0Q29udGFpbmVyKCkpO1xuICB9KTtcbiAgcmV0dXJuIEFycmF5LmZyb20oY29udGFpbmVycyk7XG59XG5cbi8qKlxuICogUmV0dXJucyBhbGwgRE9NIHdpbmRvd3MgaW4gdGhlIHdvcmtzcGFjZS5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcC5cbiAqIEByZXR1cm5zIEFsbCBET00gd2luZG93cyBpbiB0aGUgd29ya3NwYWNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0QWxsRG9tV2luZG93cyhhcHA6IEFwcCk6IFdpbmRvd1tdIHtcbiAgcmV0dXJuIGdldEFsbENvbnRhaW5lcnMoYXBwKS5tYXAoKGNvbnRhaW5lcikgPT4gY29udGFpbmVyLndpbik7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFtQk8sU0FBUyxpQkFBaUIsS0FBZ0M7QUFDL0QsUUFBTSxhQUFhLG9CQUFJLElBQXdCO0FBQy9DLE1BQUksVUFBVSxpQkFBaUIsQ0FBQyxTQUFTO0FBQ3ZDLGVBQVcsSUFBSSxLQUFLLGFBQWEsQ0FBQztBQUFBLEVBQ3BDLENBQUM7QUFDRCxTQUFPLE1BQU0sS0FBSyxVQUFVO0FBQzlCO0FBUU8sU0FBUyxpQkFBaUIsS0FBb0I7QUFDbkQsU0FBTyxpQkFBaUIsR0FBRyxFQUFFLElBQUksQ0FBQyxjQUFjLFVBQVUsR0FBRztBQUMvRDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/path.mjs

@@ -0,0 +1,90 @@
+/*
+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() {
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  globalThis.process = browserProcess;
+})();
+
+import pathBrowserify from "path-browserify";
+import {
+  ensureStartsWith,
+  replaceAll
+} from "./string.mjs";
+const WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\/[^:]*$/;
+const posix = pathBrowserify.posix;
+const delimiter = posix.delimiter;
+const sep = pathBrowserify.posix.sep;
+const basename = posix.basename;
+const dirname = posix.dirname;
+const extname = posix.extname;
+const format = posix.format;
+function isAbsolute(path) {
+  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;
+}
+const join = posix.join;
+const normalize = posix.normalize;
+const parse = posix.parse;
+const relative = posix.relative;
+function getFileName(importMetaUrl) {
+  return resolve(decodeURI(new URL(importMetaUrl).pathname));
+}
+function getFolderName(importMetaUrl) {
+  return dirname(getFileName(importMetaUrl));
+}
+function makeFileName(fileBaseName, fileExtension) {
+  return fileExtension ? `${fileBaseName}.${fileExtension}` : fileBaseName;
+}
+function normalizeIfRelative(path) {
+  if (path.startsWith("/") || path.includes(":")) {
+    return path;
+  }
+  return ensureStartsWith(path, "./");
+}
+function resolve(...pathSegments) {
+  let path = posix.resolve(...pathSegments);
+  path = toPosixPath(path);
+  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);
+  return match?.[0] ?? path;
+}
+function toPosixBuffer(buffer) {
+  return Buffer.from(toPosixPath(String(buffer)));
+}
+function toPosixPath(path) {
+  return replaceAll(path, "\\", "/");
+}
+export {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  getFileName,
+  getFolderName,
+  isAbsolute,
+  join,
+  makeFileName,
+  normalize,
+  normalizeIfRelative,
+  parse,
+  posix,
+  relative,
+  resolve,
+  sep,
+  toPosixBuffer,
+  toPosixPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/path.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for handling paths.\n */\n\nimport pathBrowserify from 'path-browserify';\n\nimport {\n  ensureStartsWith,\n  replaceAll\n} from './string.ts';\n\nconst WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\\/[^:]*$/;\n\n/**\n * Provides methods for handling POSIX paths.\n */\nexport const posix = pathBrowserify.posix;\n\n/**\n * A POSIX path delimiter.\n */\nexport const delimiter = posix.delimiter;\n\n/**\n * A POSIX segment separator.\n */\nexport const sep = pathBrowserify.posix.sep;\n\n/**\n * Returns the base name of a file, optionally removing the file extension.\n *\n * @param path - The path to get the base name from.\n * @param ext - An optional extension to remove from the base name.\n * @returns The base name of the file.\n */\nexport const basename = posix.basename;\n\n/**\n * Returns the directory name of a path.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:path` module.\n *\n * @param path - The path to get the directory name from.\n * @returns The directory name of the path.\n */\nexport const dirname = posix.dirname;\n\n/**\n * Returns the file extension of a path.\n *\n * @param path - The path to get the extension from.\n * @returns The file extension of the path.\n */\nexport const extname = posix.extname;\n\n/**\n * Formats a path object into a path string.\n *\n * @param pathObject - The path object to format.\n * @returns The formatted path string.\n */\nexport const format = posix.format;\n\n/**\n * Determines if a path is absolute.\n *\n * @param path - The path to check.\n * @returns `true` if the path is absolute, `false` otherwise.\n */\nexport function isAbsolute(path: string): boolean {\n  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;\n}\n\n/**\n * Joins multiple path segments into a single path.\n *\n * @param paths - The path segments to join.\n * @returns The joined path.\n */\nexport const join = posix.join;\n\n/**\n * Normalizes a path, resolving '..' and '.' segments.\n *\n * @param path - The path to normalize.\n * @returns The normalized path.\n */\nexport const normalize = posix.normalize;\n\n/**\n * Parses a path string into a path object.\n *\n * @param path - The path string to parse.\n * @returns The parsed path object.\n */\nexport const parse = posix.parse;\n\n/**\n * Returns the relative path from one path to another.\n *\n * @param from - The starting path.\n * @param to - The destination path.\n * @returns The relative path from `from` to `to`.\n */\nexport const relative = posix.relative;\n\n/**\n * Gets the file name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the file name.\n * @returns The POSIX-style file name.\n */\nexport function getFileName(importMetaUrl: string): string {\n  return resolve(decodeURI(new URL(importMetaUrl).pathname));\n}\n\n/**\n * Gets the folder name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the folder name.\n * @returns The POSIX-style folder name.\n */\nexport function getFolderName(importMetaUrl: string): string {\n  return dirname(getFileName(importMetaUrl));\n}\n\n/**\n * Makes a file name by appending an extension to a given file name.\n * If the extension is empty, the file name is returned as is.\n *\n * @param fileBaseName - The file name to append the extension to.\n * @param fileExtension - The extension to append to the file name.\n * @returns The file name with the extension appended.\n */\nexport function makeFileName(fileBaseName: string, fileExtension: string): string {\n  return fileExtension ? `${fileBaseName}.${fileExtension}` : fileBaseName;\n}\n\n/**\n * Normalizes a given path by ensuring it is relative, adding \"./\" if necessary.\n *\n * @param path - The path to normalize.\n * @returns The normalized path, starting with \"./\" if it was relative.\n */\nexport function normalizeIfRelative(path: string): string {\n  if (path.startsWith('/') || path.includes(':')) {\n    return path;\n  }\n\n  return ensureStartsWith(path, './');\n}\n\n/**\n * Resolves a sequence of paths or path segments into an absolute path.\n *\n * @param pathSegments - The sequence of path segments to resolve.\n * @returns The resolved absolute path.\n */\nexport function resolve(...pathSegments: string[]): string {\n  let path = posix.resolve(...pathSegments);\n  path = toPosixPath(path);\n  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);\n  return match?.[0] ?? path;\n}\n\n/**\n * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.\n *\n * @param buffer - The buffer to convert.\n * @returns A new buffer containing the POSIX-style path.\n */\nexport function toPosixBuffer(buffer: Buffer): Buffer {\n  return Buffer.from(toPosixPath(String(buffer)));\n}\n\n/**\n * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.\n *\n * @param path - The path to convert.\n * @returns The POSIX-style path.\n */\nexport function toPosixPath(path: string): string {\n  return replaceAll(path, '\\\\', '/');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAMA,OAAO,oBAAoB;AAE3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,kCAAkC;AAKjC,MAAM,QAAQ,eAAe;AAK7B,MAAM,YAAY,MAAM;AAKxB,MAAM,MAAM,eAAe,MAAM;AASjC,MAAM,WAAW,MAAM;AAUvB,MAAM,UAAU,MAAM;AAQtB,MAAM,UAAU,MAAM;AAQtB,MAAM,SAAS,MAAM;AAQrB,SAAS,WAAW,MAAuB;AAChD,SAAO,MAAM,WAAW,IAAI,KAAK,gCAAgC,KAAK,IAAI,IAAI,CAAC,MAAM;AACvF;AAQO,MAAM,OAAO,MAAM;AAQnB,MAAM,YAAY,MAAM;AAQxB,MAAM,QAAQ,MAAM;AASpB,MAAM,WAAW,MAAM;AAQvB,SAAS,YAAY,eAA+B;AACzD,SAAO,QAAQ,UAAU,IAAI,IAAI,aAAa,EAAE,QAAQ,CAAC;AAC3D;AAQO,SAAS,cAAc,eAA+B;AAC3D,SAAO,QAAQ,YAAY,aAAa,CAAC;AAC3C;AAUO,SAAS,aAAa,cAAsB,eAA+B;AAChF,SAAO,gBAAgB,GAAG,YAAY,IAAI,aAAa,KAAK;AAC9D;AAQO,SAAS,oBAAoB,MAAsB;AACxD,MAAI,KAAK,WAAW,GAAG,KAAK,KAAK,SAAS,GAAG,GAAG;AAC9C,WAAO;AAAA,EACT;AAEA,SAAO,iBAAiB,MAAM,IAAI;AACpC;AAQO,SAAS,WAAW,cAAgC;AACzD,MAAI,OAAO,MAAM,QAAQ,GAAG,YAAY;AACxC,SAAO,YAAY,IAAI;AACvB,QAAM,QAAQ,gCAAgC,KAAK,IAAI;AACvD,SAAO,QAAQ,CAAC,KAAK;AACvB;AAQO,SAAS,cAAc,QAAwB;AACpD,SAAO,OAAO,KAAK,YAAY,OAAO,MAAM,CAAC,CAAC;AAChD;AAQO,SAAS,YAAY,MAAsB;AAChD,SAAO,WAAW,MAAM,MAAM,GAAG;AACnC;",
  "names": []
}
