@huyooo/file-explorer-core 0.4.5 → 0.4.10

package/dist/index.cjs

@@ -1,2580 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  APP_PROTOCOL_HOST: () => APP_PROTOCOL_HOST,
-  APP_PROTOCOL_PREFIX: () => APP_PROTOCOL_PREFIX,
-  APP_PROTOCOL_SCHEME: () => APP_PROTOCOL_SCHEME,
-  FileType: () => FileType,
-  MediaService: () => MediaService,
-  SqliteThumbnailDatabase: () => SqliteThumbnailDatabase,
-  ThumbnailService: () => ThumbnailService,
-  WatchManager: () => WatchManager,
-  cleanupAllTranscodedFiles: () => cleanupAllTranscodedFiles,
-  cleanupTranscodedFile: () => cleanupTranscodedFile,
-  closeThumbnailDatabase: () => closeThumbnailDatabase,
-  compressFiles: () => compressFiles,
-  copyFiles: () => copyFiles,
-  copyFilesToClipboard: () => copyFilesToClipboard,
-  createFfmpegVideoProcessor: () => createFfmpegVideoProcessor,
-  createFile: () => createFile,
-  createFolder: () => createFolder,
-  createMediaService: () => createMediaService,
-  createSharpImageProcessor: () => createSharpImageProcessor,
-  createSqliteThumbnailDatabase: () => createSqliteThumbnailDatabase,
-  decodeFileUrl: () => decodeFileUrl,
-  deleteFiles: () => deleteFiles,
-  detectArchiveFormat: () => detectArchiveFormat,
-  detectTranscodeNeeds: () => detectTranscodeNeeds,
-  encodeFileUrl: () => encodeFileUrl,
-  exists: () => exists,
-  extractArchive: () => extractArchive,
-  formatDate: () => formatDate,
-  formatDateTime: () => formatDateTime,
-  formatFileSize: () => formatFileSize,
-  getAllSystemPaths: () => getAllSystemPaths,
-  getApplicationIcon: () => getApplicationIcon,
-  getClipboardFiles: () => getClipboardFiles,
-  getFileHash: () => getFileHash,
-  getFileInfo: () => getFileInfo,
-  getFileType: () => getFileType,
-  getHomeDirectory: () => getHomeDirectory,
-  getMediaFormat: () => getMediaFormat,
-  getMediaService: () => getMediaService,
-  getMediaTypeByExtension: () => getMediaTypeByExtension,
-  getPlatform: () => getPlatform2,
-  getSqliteThumbnailDatabase: () => getSqliteThumbnailDatabase,
-  getSystemPath: () => getSystemPath,
-  getThumbnailService: () => getThumbnailService,
-  getWatchManager: () => getWatchManager,
-  initMediaService: () => initMediaService,
-  initThumbnailService: () => initThumbnailService,
-  isAppProtocolUrl: () => isAppProtocolUrl,
-  isArchiveFile: () => isArchiveFile,
-  isDirectory: () => isDirectory,
-  isMediaFile: () => isMediaFile,
-  isPreviewable: () => isPreviewable,
-  moveFiles: () => moveFiles,
-  openInEditor: () => openInEditor,
-  openInTerminal: () => openInTerminal,
-  pasteFiles: () => pasteFiles,
-  readDirectory: () => readDirectory,
-  readFileContent: () => readFileContent,
-  readImageAsBase64: () => readImageAsBase64,
-  renameFile: () => renameFile,
-  revealInFileManager: () => revealInFileManager,
-  searchFiles: () => searchFiles,
-  searchFilesStream: () => searchFilesStream,
-  searchFilesSync: () => searchFilesSync,
-  showFileInfo: () => showFileInfo,
-  transcodeMedia: () => transcodeMedia,
-  watchDirectory: () => watchDirectory,
-  writeFileContent: () => writeFileContent
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types.ts
-var FileType = /* @__PURE__ */ ((FileType2) => {
-  FileType2["FOLDER"] = "folder";
-  FileType2["FILE"] = "file";
-  FileType2["IMAGE"] = "image";
-  FileType2["VIDEO"] = "video";
-  FileType2["MUSIC"] = "music";
-  FileType2["DOCUMENT"] = "document";
-  FileType2["CODE"] = "code";
-  FileType2["TEXT"] = "text";
-  FileType2["ARCHIVE"] = "archive";
-  FileType2["APPLICATION"] = "application";
-  FileType2["UNKNOWN"] = "unknown";
-  return FileType2;
-})(FileType || {});
-
-// src/protocol.ts
-var APP_PROTOCOL_SCHEME = "app";
-var APP_PROTOCOL_HOST = "file";
-var APP_PROTOCOL_PREFIX = `${APP_PROTOCOL_SCHEME}://${APP_PROTOCOL_HOST}`;
-function encodeFileUrl(filePath) {
-  if (!filePath) return "";
-  const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-  return `${APP_PROTOCOL_PREFIX}${encodedPath}`;
-}
-function decodeFileUrl(url) {
-  if (!url) return "";
-  let path18 = url;
-  if (path18.startsWith(APP_PROTOCOL_PREFIX)) {
-    path18 = path18.slice(APP_PROTOCOL_PREFIX.length);
-  }
-  const hashIndex = path18.indexOf("#");
-  if (hashIndex !== -1) {
-    path18 = path18.substring(0, hashIndex);
-  }
-  const queryIndex = path18.indexOf("?");
-  if (queryIndex !== -1) {
-    path18 = path18.substring(0, queryIndex);
-  }
-  try {
-    return decodeURIComponent(path18);
-  } catch {
-    return path18;
-  }
-}
-function isAppProtocolUrl(url) {
-  return url?.startsWith(APP_PROTOCOL_PREFIX) ?? false;
-}
-
-// src/utils/file-type.ts
-var import_node_path = __toESM(require("path"), 1);
-var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".jpg",
-  ".jpeg",
-  ".png",
-  ".gif",
-  ".bmp",
-  ".webp",
-  ".svg",
-  ".ico",
-  ".tiff",
-  ".tif",
-  ".heic",
-  ".heif"
-]);
-var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".mp4",
-  ".mov",
-  ".avi",
-  ".mkv",
-  ".wmv",
-  ".flv",
-  ".webm",
-  ".m4v",
-  ".3gp",
-  ".mpeg",
-  ".mpg"
-]);
-var MUSIC_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".mp3",
-  ".wav",
-  ".flac",
-  ".aac",
-  ".ogg",
-  ".wma",
-  ".m4a",
-  ".aiff",
-  ".alac"
-]);
-var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".odt",
-  ".ods",
-  ".odp",
-  ".rtf",
-  ".pages",
-  ".numbers",
-  ".key"
-]);
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".ts",
-  ".jsx",
-  ".tsx",
-  ".vue",
-  ".svelte",
-  ".py",
-  ".rb",
-  ".go",
-  ".rs",
-  ".java",
-  ".kt",
-  ".swift",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-  ".html",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".xml",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".ps1",
-  ".sql",
-  ".graphql",
-  ".prisma"
-]);
-var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".txt",
-  ".md",
-  ".markdown",
-  ".log",
-  ".ini",
-  ".conf",
-  ".cfg",
-  ".env"
-]);
-var ARCHIVE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".zip",
-  ".rar",
-  ".7z",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".xz",
-  ".dmg",
-  ".iso"
-]);
-var APPLICATION_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".app",
-  ".exe",
-  ".msi",
-  ".deb",
-  ".rpm",
-  ".pkg",
-  ".apk",
-  ".ipa"
-]);
-function getFileType(filePath, stats) {
-  if (stats.isDirectory()) {
-    if (filePath.endsWith(".app")) {
-      return "application" /* APPLICATION */;
-    }
-    return "folder" /* FOLDER */;
-  }
-  const ext = import_node_path.default.extname(filePath).toLowerCase();
-  if (IMAGE_EXTENSIONS.has(ext)) return "image" /* IMAGE */;
-  if (VIDEO_EXTENSIONS.has(ext)) return "video" /* VIDEO */;
-  if (MUSIC_EXTENSIONS.has(ext)) return "music" /* MUSIC */;
-  if (DOCUMENT_EXTENSIONS.has(ext)) return "document" /* DOCUMENT */;
-  if (CODE_EXTENSIONS.has(ext)) return "code" /* CODE */;
-  if (TEXT_EXTENSIONS.has(ext)) return "text" /* TEXT */;
-  if (ARCHIVE_EXTENSIONS.has(ext)) return "archive" /* ARCHIVE */;
-  if (APPLICATION_EXTENSIONS.has(ext)) return "application" /* APPLICATION */;
-  return "file" /* FILE */;
-}
-function isMediaFile(type) {
-  return type === "image" /* IMAGE */ || type === "video" /* VIDEO */ || type === "music" /* MUSIC */;
-}
-function isPreviewable(type) {
-  return type === "image" /* IMAGE */ || type === "video" /* VIDEO */ || type === "music" /* MUSIC */ || type === "text" /* TEXT */ || type === "code" /* CODE */;
-}
-
-// src/utils/formatters.ts
-function formatFileSize(bytes) {
-  if (bytes === 0) return "0 B";
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  const k = 1024;
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;
-}
-function formatDate(date) {
-  const now = /* @__PURE__ */ new Date();
-  const diff = now.getTime() - date.getTime();
-  const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
-  if (days === 0) {
-    return date.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
-  } else if (days === 1) {
-    return "\u6628\u5929";
-  } else if (days < 7) {
-    return `${days} \u5929\u524D`;
-  } else {
-    return date.toLocaleDateString("zh-CN", {
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit"
-    });
-  }
-}
-function formatDateTime(date) {
-  return date.toLocaleString("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit"
-  });
-}
-
-// src/operations/read.ts
-var import_node_fs = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
-var defaultUrlEncoder = (filePath) => `file://${encodeURIComponent(filePath)}`;
-async function readDirectory(dirPath, options = {}) {
-  const {
-    urlEncoder = defaultUrlEncoder,
-    includeHidden = false,
-    getThumbnailUrl
-  } = options;
-  try {
-    const entries = await import_node_fs.promises.readdir(dirPath, { withFileTypes: true });
-    const items = [];
-    for (const entry of entries) {
-      if (!includeHidden && entry.name.startsWith(".")) {
-        continue;
-      }
-      const fullPath = import_node_path2.default.join(dirPath, entry.name);
-      try {
-        let stats;
-        try {
-          stats = await import_node_fs.promises.lstat(fullPath);
-        } catch {
-          try {
-            stats = await import_node_fs.promises.stat(fullPath);
-          } catch (statError) {
-            const err = statError;
-            if (err.code !== "ENOENT") {
-              console.warn(`Cannot access file ${fullPath}:`, err.message);
-            }
-            continue;
-          }
-        }
-        const fileType = getFileType(fullPath, stats);
-        const fileUrl = urlEncoder(fullPath);
-        const item = {
-          id: fullPath,
-          name: entry.name,
-          type: fileType,
-          dateModified: formatDate(stats.mtime),
-          url: fileUrl
-        };
-        if (stats.isDirectory()) {
-          item.children = [];
-        } else {
-          item.size = formatFileSize(stats.size);
-          if (getThumbnailUrl && (fileType === "image" /* IMAGE */ || fileType === "video" /* VIDEO */)) {
-            const thumbUrl = await getThumbnailUrl(fullPath);
-            if (thumbUrl) {
-              item.thumbnailUrl = thumbUrl;
-            }
-          }
-        }
-        items.push(item);
-      } catch (itemError) {
-        const err = itemError;
-        if (err.code !== "ENOENT") {
-          console.warn(`Error processing file ${fullPath}:`, err.message);
-        }
-        continue;
-      }
-    }
-    items.sort((a, b) => {
-      if (a.type === "folder" /* FOLDER */ && b.type !== "folder" /* FOLDER */) return -1;
-      if (a.type !== "folder" /* FOLDER */ && b.type === "folder" /* FOLDER */) return 1;
-      return a.name.localeCompare(b.name, "zh-CN");
-    });
-    return items;
-  } catch (error) {
-    console.error(`Error reading directory ${dirPath}:`, error);
-    return [];
-  }
-}
-async function readFileContent(filePath) {
-  return await import_node_fs.promises.readFile(filePath, "utf-8");
-}
-async function readImageAsBase64(imagePath) {
-  try {
-    let actualPath = imagePath;
-    if (imagePath.startsWith("app://file")) {
-      const urlPath = imagePath.slice("app://file".length);
-      actualPath = decodeURIComponent(urlPath);
-    } else if (imagePath.startsWith("file://")) {
-      actualPath = decodeURIComponent(imagePath.replace("file://", ""));
-    }
-    const stats = await import_node_fs.promises.stat(actualPath);
-    if (!stats.isFile()) {
-      return { success: false, error: `\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${actualPath}` };
-    }
-    const buffer = await import_node_fs.promises.readFile(actualPath);
-    const base64 = buffer.toString("base64");
-    const ext = import_node_path2.default.extname(actualPath).toLowerCase().slice(1);
-    const mimeTypes = {
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      png: "image/png",
-      gif: "image/gif",
-      webp: "image/webp",
-      bmp: "image/bmp",
-      svg: "image/svg+xml"
-    };
-    const mimeType = mimeTypes[ext] || "image/jpeg";
-    return { success: true, base64, mimeType };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-
-// src/operations/write.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
-async function writeFileContent(filePath, content) {
-  try {
-    await import_node_fs2.promises.writeFile(filePath, content, "utf-8");
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function createFolder(folderPath) {
-  try {
-    try {
-      await import_node_fs2.promises.access(folderPath);
-    } catch {
-      await import_node_fs2.promises.mkdir(folderPath, { recursive: true });
-      return { success: true, data: { finalPath: folderPath } };
-    }
-    const dir = import_node_path3.default.dirname(folderPath);
-    const baseName = import_node_path3.default.basename(folderPath);
-    let counter = 2;
-    let finalPath = import_node_path3.default.join(dir, `${baseName} ${counter}`);
-    while (true) {
-      try {
-        await import_node_fs2.promises.access(finalPath);
-        counter++;
-        finalPath = import_node_path3.default.join(dir, `${baseName} ${counter}`);
-      } catch {
-        break;
-      }
-    }
-    await import_node_fs2.promises.mkdir(finalPath, { recursive: true });
-    return { success: true, data: { finalPath } };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function createFile(filePath, content = "") {
-  try {
-    const dir = import_node_path3.default.dirname(filePath);
-    await import_node_fs2.promises.mkdir(dir, { recursive: true });
-    try {
-      await import_node_fs2.promises.access(filePath);
-    } catch {
-      await import_node_fs2.promises.writeFile(filePath, content, "utf-8");
-      return { success: true, data: { finalPath: filePath } };
-    }
-    const dirname3 = import_node_path3.default.dirname(filePath);
-    const ext = import_node_path3.default.extname(filePath);
-    const basename2 = import_node_path3.default.basename(filePath, ext);
-    let counter = 2;
-    let finalPath = import_node_path3.default.join(dirname3, `${basename2} ${counter}${ext}`);
-    while (true) {
-      try {
-        await import_node_fs2.promises.access(finalPath);
-        counter++;
-        finalPath = import_node_path3.default.join(dirname3, `${basename2} ${counter}${ext}`);
-      } catch {
-        break;
-      }
-    }
-    await import_node_fs2.promises.writeFile(finalPath, content, "utf-8");
-    return { success: true, data: { finalPath } };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-
-// src/operations/delete.ts
-var import_node_fs3 = require("fs");
-async function deleteFiles(paths, options = {}) {
-  const { adapter, useTrash = true, onDeleted } = options;
-  try {
-    for (const filePath of paths) {
-      if (useTrash && adapter?.trashItem) {
-        await adapter.trashItem(filePath);
-      } else {
-        const stats = await import_node_fs3.promises.stat(filePath);
-        if (stats.isDirectory()) {
-          await import_node_fs3.promises.rm(filePath, { recursive: true, force: true });
-        } else {
-          await import_node_fs3.promises.unlink(filePath);
-        }
-      }
-      onDeleted?.(filePath);
-    }
-    return {
-      success: true,
-      message: useTrash ? "\u6587\u4EF6\u5DF2\u79FB\u52A8\u5230\u56DE\u6536\u7AD9" : "\u6587\u4EF6\u5DF2\u5220\u9664"
-    };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-
-// src/operations/rename.ts
-var import_node_fs4 = require("fs");
-async function renameFile(oldPath, newPath, options = {}) {
-  const { onRenamed } = options;
-  try {
-    await import_node_fs4.promises.rename(oldPath, newPath);
-    onRenamed?.(oldPath, newPath);
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-
-// src/operations/copy.ts
-var import_node_fs5 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
-async function copyFiles(sourcePaths, targetDir) {
-  try {
-    const copiedPaths = [];
-    for (const sourcePath of sourcePaths) {
-      const fileName = import_node_path4.default.basename(sourcePath);
-      let destPath = import_node_path4.default.join(targetDir, fileName);
-      let counter = 1;
-      while (true) {
-        try {
-          await import_node_fs5.promises.access(destPath);
-          const ext = import_node_path4.default.extname(fileName);
-          const baseName = import_node_path4.default.basename(fileName, ext);
-          destPath = import_node_path4.default.join(targetDir, `${baseName} ${++counter}${ext}`);
-        } catch {
-          break;
-        }
-      }
-      const stats = await import_node_fs5.promises.stat(sourcePath);
-      if (stats.isDirectory()) {
-        await copyDirectory(sourcePath, destPath);
-      } else {
-        await import_node_fs5.promises.copyFile(sourcePath, destPath);
-      }
-      copiedPaths.push(destPath);
-    }
-    return { success: true, data: { copiedPaths } };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function moveFiles(sourcePaths, targetDir) {
-  try {
-    const movedPaths = [];
-    for (const sourcePath of sourcePaths) {
-      const fileName = import_node_path4.default.basename(sourcePath);
-      let destPath = import_node_path4.default.join(targetDir, fileName);
-      let counter = 1;
-      while (true) {
-        try {
-          await import_node_fs5.promises.access(destPath);
-          const ext = import_node_path4.default.extname(fileName);
-          const baseName = import_node_path4.default.basename(fileName, ext);
-          destPath = import_node_path4.default.join(targetDir, `${baseName} ${++counter}${ext}`);
-        } catch {
-          break;
-        }
-      }
-      try {
-        await import_node_fs5.promises.rename(sourcePath, destPath);
-      } catch {
-        const stats = await import_node_fs5.promises.stat(sourcePath);
-        if (stats.isDirectory()) {
-          await copyDirectory(sourcePath, destPath);
-        } else {
-          await import_node_fs5.promises.copyFile(sourcePath, destPath);
-        }
-        await import_node_fs5.promises.rm(sourcePath, { recursive: true, force: true });
-      }
-      movedPaths.push(destPath);
-    }
-    return { success: true, data: { movedPaths } };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function copyDirectory(source, dest) {
-  await import_node_fs5.promises.mkdir(dest, { recursive: true });
-  const entries = await import_node_fs5.promises.readdir(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = import_node_path4.default.join(source, entry.name);
-    const destPath = import_node_path4.default.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDirectory(sourcePath, destPath);
-    } else {
-      await import_node_fs5.promises.copyFile(sourcePath, destPath);
-    }
-  }
-}
-
-// src/operations/info.ts
-var import_node_fs6 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
-async function getFileInfo(filePath) {
-  try {
-    const stats = await import_node_fs6.promises.stat(filePath);
-    const name = import_node_path5.default.basename(filePath);
-    const ext = import_node_path5.default.extname(name);
-    return {
-      success: true,
-      data: {
-        path: filePath,
-        name,
-        size: stats.size,
-        isFile: stats.isFile(),
-        isDirectory: stats.isDirectory(),
-        createdAt: stats.birthtime,
-        updatedAt: stats.mtime,
-        extension: ext || void 0
-      }
-    };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function exists(filePath) {
-  try {
-    await import_node_fs6.promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isDirectory(filePath) {
-  try {
-    const stats = await import_node_fs6.promises.stat(filePath);
-    return stats.isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-// src/operations/shell.ts
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var path6 = __toESM(require("path"), 1);
-var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-function getPlatform() {
-  switch (process.platform) {
-    case "darwin":
-      return "mac";
-    case "win32":
-      return "windows";
-    default:
-      return "linux";
-  }
-}
-async function showFileInfo(filePath) {
-  const platform2 = getPlatform();
-  try {
-    switch (platform2) {
-      case "mac": {
-        const script = `tell application "Finder"
-          activate
-          set theFile to POSIX file "${filePath}" as alias
-          open information window of theFile
-        end tell`;
-        await execAsync(`osascript -e '${script}'`);
-        break;
-      }
-      case "windows": {
-        const escapedPath = filePath.replace(/'/g, "''");
-        const psScript = `
-          $shell = New-Object -ComObject Shell.Application
-          $folder = $shell.Namespace((Split-Path '${escapedPath}'))
-          $item = $folder.ParseName((Split-Path '${escapedPath}' -Leaf))
-          $item.InvokeVerb('properties')
-        `;
-        await execAsync(`powershell -Command "${psScript.replace(/\n/g, " ")}"`);
-        break;
-      }
-      case "linux": {
-        const commands = [
-          `nautilus --select "${filePath}" && nautilus -q`,
-          // GNOME
-          `dolphin --select "${filePath}"`,
-          // KDE
-          `thunar --quit && thunar "${path6.dirname(filePath)}"`,
-          // XFCE
-          `xdg-open "${path6.dirname(filePath)}"`
-          // 通用
-        ];
-        let lastError = null;
-        for (const cmd of commands) {
-          try {
-            await execAsync(cmd);
-            return { success: true };
-          } catch (e) {
-            lastError = e;
-          }
-        }
-        throw lastError || new Error("No file manager found");
-      }
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function revealInFileManager(filePath) {
-  const platform2 = getPlatform();
-  try {
-    switch (platform2) {
-      case "mac": {
-        await execAsync(`open -R "${filePath}"`);
-        break;
-      }
-      case "windows": {
-        await execAsync(`explorer.exe /select,"${filePath}"`);
-        break;
-      }
-      case "linux": {
-        await execAsync(`xdg-open "${path6.dirname(filePath)}"`);
-        break;
-      }
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function openInTerminal(dirPath) {
-  const platform2 = getPlatform();
-  try {
-    switch (platform2) {
-      case "mac": {
-        try {
-          const itermScript = `tell application "iTerm"
-            activate
-            try
-              set newWindow to (create window with default profile)
-              tell current session of newWindow
-                write text "cd '${dirPath}'"
-              end tell
-            on error
-              tell current window
-                create tab with default profile
-                tell current session
-                  write text "cd '${dirPath}'"
-                end tell
-              end tell
-            end try
-          end tell`;
-          await execAsync(`osascript -e '${itermScript}'`);
-        } catch {
-          const terminalScript = `tell application "Terminal"
-            activate
-            do script "cd '${dirPath}'"
-          end tell`;
-          await execAsync(`osascript -e '${terminalScript}'`);
-        }
-        break;
-      }
-      case "windows": {
-        try {
-          await execAsync(`wt -d "${dirPath}"`);
-        } catch {
-          await execAsync(`start cmd /K "cd /d ${dirPath}"`);
-        }
-        break;
-      }
-      case "linux": {
-        const terminals = [
-          `gnome-terminal --working-directory="${dirPath}"`,
-          `konsole --workdir "${dirPath}"`,
-          `xfce4-terminal --working-directory="${dirPath}"`,
-          `xterm -e "cd '${dirPath}' && $SHELL"`
-        ];
-        let lastError = null;
-        for (const cmd of terminals) {
-          try {
-            await execAsync(cmd);
-            return { success: true };
-          } catch (e) {
-            lastError = e;
-          }
-        }
-        throw lastError || new Error("No terminal found");
-      }
-    }
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function openInEditor(targetPath) {
-  const platform2 = getPlatform();
-  try {
-    const editors = platform2 === "mac" ? [
-      // macOS: 优先 Cursor，回退到 VSCode
-      `open -a "Cursor" "${targetPath}"`,
-      `open -a "Visual Studio Code" "${targetPath}"`,
-      `code "${targetPath}"`
-    ] : platform2 === "windows" ? [
-      // Windows
-      `cursor "${targetPath}"`,
-      `code "${targetPath}"`
-    ] : [
-      // Linux
-      `cursor "${targetPath}"`,
-      `code "${targetPath}"`
-    ];
-    let lastError = null;
-    for (const cmd of editors) {
-      try {
-        await execAsync(cmd);
-        return { success: true };
-      } catch (e) {
-        lastError = e;
-      }
-    }
-    throw lastError || new Error("No editor found");
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-
-// src/operations/compress.ts
-var compressing = __toESM(require("compressing"), 1);
-var path7 = __toESM(require("path"), 1);
-var fs7 = __toESM(require("fs"), 1);
-var import_node_fs7 = require("fs");
-var import_promises = require("stream/promises");
-function getExtension(format) {
-  switch (format) {
-    case "zip":
-      return ".zip";
-    case "tar":
-      return ".tar";
-    case "tgz":
-      return ".tar.gz";
-    case "tarbz2":
-      return ".tar.bz2";
-    default:
-      return ".zip";
-  }
-}
-function detectArchiveFormat(filePath) {
-  const lowerPath = filePath.toLowerCase();
-  if (lowerPath.endsWith(".zip")) return "zip";
-  if (lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz")) return "tgz";
-  if (lowerPath.endsWith(".tar.bz2") || lowerPath.endsWith(".tbz2")) return "tarbz2";
-  if (lowerPath.endsWith(".tar")) return "tar";
-  return null;
-}
-function isArchiveFile(filePath) {
-  return detectArchiveFormat(filePath) !== null;
-}
-async function getAllFiles(dirPath) {
-  const files = [];
-  const entries = await import_node_fs7.promises.readdir(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path7.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await getAllFiles(fullPath));
-    } else {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-async function countFiles(sources) {
-  let count = 0;
-  for (const source of sources) {
-    const stats = await import_node_fs7.promises.stat(source);
-    if (stats.isDirectory()) {
-      const files = await getAllFiles(source);
-      count += files.length;
-    } else {
-      count += 1;
-    }
-  }
-  return count;
-}
-async function compressFiles(sources, options, onProgress) {
-  try {
-    const { format, level = "normal", outputName, outputDir, deleteSource } = options;
-    const ext = getExtension(format);
-    const finalName = outputName.endsWith(ext) ? outputName : outputName + ext;
-    const outputPath = path7.join(outputDir, finalName);
-    await import_node_fs7.promises.mkdir(outputDir, { recursive: true });
-    const totalCount = await countFiles(sources);
-    let processedCount = 0;
-    switch (format) {
-      case "zip": {
-        const stream = new compressing.zip.Stream();
-        for (const source of sources) {
-          const stats = await import_node_fs7.promises.stat(source);
-          const baseName = path7.basename(source);
-          if (stats.isDirectory()) {
-            const files = await getAllFiles(source);
-            for (const file of files) {
-              const relativePath = path7.relative(path7.dirname(source), file);
-              stream.addEntry(file, { relativePath });
-              processedCount++;
-              onProgress?.({
-                currentFile: path7.basename(file),
-                processedCount,
-                totalCount,
-                percent: Math.round(processedCount / totalCount * 100)
-              });
-            }
-          } else {
-            stream.addEntry(source, { relativePath: baseName });
-            processedCount++;
-            onProgress?.({
-              currentFile: baseName,
-              processedCount,
-              totalCount,
-              percent: Math.round(processedCount / totalCount * 100)
-            });
-          }
-        }
-        const destStream = fs7.createWriteStream(outputPath);
-        await (0, import_promises.pipeline)(stream, destStream);
-        break;
-      }
-      case "tar": {
-        const stream = new compressing.tar.Stream();
-        for (const source of sources) {
-          const stats = await import_node_fs7.promises.stat(source);
-          const baseName = path7.basename(source);
-          if (stats.isDirectory()) {
-            const files = await getAllFiles(source);
-            for (const file of files) {
-              const relativePath = path7.relative(path7.dirname(source), file);
-              stream.addEntry(file, { relativePath });
-              processedCount++;
-              onProgress?.({
-                currentFile: path7.basename(file),
-                processedCount,
-                totalCount,
-                percent: Math.round(processedCount / totalCount * 100)
-              });
-            }
-          } else {
-            stream.addEntry(source, { relativePath: baseName });
-            processedCount++;
-            onProgress?.({
-              currentFile: baseName,
-              processedCount,
-              totalCount,
-              percent: Math.round(processedCount / totalCount * 100)
-            });
-          }
-        }
-        const destStream = fs7.createWriteStream(outputPath);
-        await (0, import_promises.pipeline)(stream, destStream);
-        break;
-      }
-      case "tgz": {
-        const stream = new compressing.tgz.Stream();
-        for (const source of sources) {
-          const stats = await import_node_fs7.promises.stat(source);
-          const baseName = path7.basename(source);
-          if (stats.isDirectory()) {
-            const files = await getAllFiles(source);
-            for (const file of files) {
-              const relativePath = path7.relative(path7.dirname(source), file);
-              stream.addEntry(file, { relativePath });
-              processedCount++;
-              onProgress?.({
-                currentFile: path7.basename(file),
-                processedCount,
-                totalCount,
-                percent: Math.round(processedCount / totalCount * 100)
-              });
-            }
-          } else {
-            stream.addEntry(source, { relativePath: baseName });
-            processedCount++;
-            onProgress?.({
-              currentFile: baseName,
-              processedCount,
-              totalCount,
-              percent: Math.round(processedCount / totalCount * 100)
-            });
-          }
-        }
-        const destStream = fs7.createWriteStream(outputPath);
-        await (0, import_promises.pipeline)(stream, destStream);
-        break;
-      }
-      case "tarbz2": {
-        console.warn("tar.bz2 format not fully supported, using tgz instead");
-        const tgzStream = new compressing.tgz.Stream();
-        for (const source of sources) {
-          const stats = await import_node_fs7.promises.stat(source);
-          const baseName = path7.basename(source);
-          if (stats.isDirectory()) {
-            const files = await getAllFiles(source);
-            for (const file of files) {
-              const relativePath = path7.relative(path7.dirname(source), file);
-              tgzStream.addEntry(file, { relativePath });
-              processedCount++;
-              onProgress?.({
-                currentFile: path7.basename(file),
-                processedCount,
-                totalCount,
-                percent: Math.round(processedCount / totalCount * 100)
-              });
-            }
-          } else {
-            tgzStream.addEntry(source, { relativePath: baseName });
-            processedCount++;
-            onProgress?.({
-              currentFile: baseName,
-              processedCount,
-              totalCount,
-              percent: Math.round(processedCount / totalCount * 100)
-            });
-          }
-        }
-        const destStream = fs7.createWriteStream(outputPath.replace(".tar.bz2", ".tar.gz"));
-        await (0, import_promises.pipeline)(tgzStream, destStream);
-        break;
-      }
-    }
-    if (deleteSource) {
-      for (const source of sources) {
-        const stats = await import_node_fs7.promises.stat(source);
-        if (stats.isDirectory()) {
-          await import_node_fs7.promises.rm(source, { recursive: true });
-        } else {
-          await import_node_fs7.promises.unlink(source);
-        }
-      }
-    }
-    return { success: true, outputPath };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function extractArchive(archivePath, options, onProgress) {
-  try {
-    const { targetDir, deleteArchive } = options;
-    const format = detectArchiveFormat(archivePath);
-    if (!format) {
-      return { success: false, error: "\u4E0D\u652F\u6301\u7684\u538B\u7F29\u683C\u5F0F" };
-    }
-    await import_node_fs7.promises.mkdir(targetDir, { recursive: true });
-    onProgress?.({
-      currentFile: path7.basename(archivePath),
-      processedCount: 0,
-      totalCount: 1,
-      percent: 0
-    });
-    switch (format) {
-      case "zip":
-        await compressing.zip.uncompress(archivePath, targetDir);
-        break;
-      case "tar":
-        await compressing.tar.uncompress(archivePath, targetDir);
-        break;
-      case "tgz":
-        await compressing.tgz.uncompress(archivePath, targetDir);
-        break;
-      case "tarbz2":
-        console.warn("tar.bz2 format not fully supported");
-        return { success: false, error: "tar.bz2 \u683C\u5F0F\u6682\u4E0D\u652F\u6301" };
-    }
-    onProgress?.({
-      currentFile: path7.basename(archivePath),
-      processedCount: 1,
-      totalCount: 1,
-      percent: 100
-    });
-    if (deleteArchive) {
-      await import_node_fs7.promises.unlink(archivePath);
-    }
-    return { success: true, outputPath: targetDir };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-
-// src/system-paths.ts
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var platform = process.platform;
-function getSystemPath(pathId) {
-  const homeDir = import_node_os.default.homedir();
-  switch (pathId) {
-    case "desktop":
-      return import_node_path6.default.join(homeDir, "Desktop");
-    case "documents":
-      return import_node_path6.default.join(homeDir, "Documents");
-    case "downloads":
-      return import_node_path6.default.join(homeDir, "Downloads");
-    case "pictures":
-      return import_node_path6.default.join(homeDir, "Pictures");
-    case "music":
-      return import_node_path6.default.join(homeDir, "Music");
-    case "videos":
-      return platform === "darwin" ? import_node_path6.default.join(homeDir, "Movies") : import_node_path6.default.join(homeDir, "Videos");
-    case "applications":
-      return platform === "darwin" ? "/Applications" : platform === "win32" ? process.env.ProgramFiles || "C:\\Program Files" : "/usr/share/applications";
-    case "home":
-      return homeDir;
-    case "root":
-      return platform === "darwin" ? "/" : platform === "win32" ? "C:\\" : "/";
-    default:
-      return null;
-  }
-}
-function getAllSystemPaths() {
-  const pathIds = [
-    "desktop",
-    "documents",
-    "downloads",
-    "pictures",
-    "music",
-    "videos",
-    "applications",
-    "home",
-    "root"
-  ];
-  const result = {};
-  for (const id of pathIds) {
-    result[id] = getSystemPath(id);
-  }
-  return result;
-}
-function getHomeDirectory() {
-  return import_node_os.default.homedir();
-}
-function getPlatform2() {
-  return process.platform;
-}
-
-// src/search.ts
-var import_fdir = require("fdir");
-var import_node_path7 = __toESM(require("path"), 1);
-var import_node_fs8 = require("fs");
-function patternToRegex(pattern) {
-  return new RegExp(pattern.replace(/\*/g, ".*"), "i");
-}
-async function searchFiles(searchPath, pattern, maxDepth) {
-  const builder = new import_fdir.fdir().withFullPaths().withDirs();
-  if (maxDepth && maxDepth > 0) {
-    builder.withMaxDepth(maxDepth);
-  }
-  const api = builder.crawl(searchPath);
-  const files = await api.withPromise();
-  if (pattern) {
-    const regex = patternToRegex(pattern);
-    return files.filter((file) => regex.test(import_node_path7.default.basename(file)));
-  }
-  return files;
-}
-async function searchFilesStream(searchPath, pattern, onResults, maxResults = 100) {
-  const regex = patternToRegex(pattern);
-  const results = [];
-  let stopped = false;
-  async function searchDir(dirPath) {
-    if (stopped) return;
-    try {
-      const entries = await import_node_fs8.promises.readdir(dirPath, { withFileTypes: true });
-      const matched = [];
-      const subdirs = [];
-      for (const entry of entries) {
-        if (stopped) return;
-        const fullPath = import_node_path7.default.join(dirPath, entry.name);
-        if (regex.test(entry.name)) {
-          matched.push(fullPath);
-          results.push(fullPath);
-          if (results.length >= maxResults) {
-            stopped = true;
-            onResults(matched, true);
-            return;
-          }
-        }
-        if (entry.isDirectory()) {
-          subdirs.push(fullPath);
-        }
-      }
-      if (matched.length > 0) {
-        onResults(matched, false);
-      }
-      for (const subdir of subdirs) {
-        await searchDir(subdir);
-      }
-    } catch {
-    }
-  }
-  await searchDir(searchPath);
-  if (!stopped) {
-    onResults([], true);
-  }
-}
-function searchFilesSync(searchPath, pattern, maxDepth) {
-  const builder = new import_fdir.fdir().withFullPaths().withDirs();
-  if (maxDepth && maxDepth > 0) {
-    builder.withMaxDepth(maxDepth);
-  }
-  const api = builder.crawl(searchPath);
-  const files = api.sync();
-  if (pattern) {
-    const regex = new RegExp(pattern.replace(/\*/g, ".*"), "i");
-    return files.filter((file) => regex.test(import_node_path7.default.basename(file)));
-  }
-  return files;
-}
-
-// src/hash.ts
-var import_hash_wasm = require("hash-wasm");
-var import_promises2 = require("fs/promises");
-async function getFileHash(filePath, stats) {
-  const fileStats = stats || await (0, import_promises2.stat)(filePath);
-  const hashInput = `${filePath}:${fileStats.size}:${fileStats.mtime.getTime()}`;
-  return await (0, import_hash_wasm.xxhash64)(hashInput);
-}
-
-// src/clipboard.ts
-var import_node_fs9 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
-async function copyFilesToClipboard(filePaths, clipboard) {
-  try {
-    const cleanPaths = [];
-    for (const p of filePaths) {
-      try {
-        await import_node_fs9.promises.access(p);
-        cleanPaths.push(p);
-      } catch {
-      }
-    }
-    if (cleanPaths.length === 0) {
-      return { success: false, error: "\u6CA1\u6709\u627E\u5230\u6709\u6548\u7684\u6587\u4EF6" };
-    }
-    clipboard.writeFiles(cleanPaths);
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-function getClipboardFiles(clipboard) {
-  try {
-    const files = clipboard.readFiles();
-    if (files && Array.isArray(files) && files.length > 0) {
-      return { success: true, data: { files } };
-    }
-    return { success: false, error: "\u526A\u8D34\u677F\u4E2D\u6CA1\u6709\u6587\u4EF6" };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function pasteFiles(targetDir, sourcePaths) {
-  try {
-    if (!targetDir || typeof targetDir !== "string") {
-      return { success: false, error: "\u76EE\u6807\u76EE\u5F55\u8DEF\u5F84\u65E0\u6548" };
-    }
-    if (!sourcePaths || !Array.isArray(sourcePaths) || sourcePaths.length === 0) {
-      return { success: false, error: "\u6E90\u6587\u4EF6\u8DEF\u5F84\u5217\u8868\u65E0\u6548" };
-    }
-    const pastedPaths = [];
-    for (const sourcePath of sourcePaths) {
-      const fileName = import_node_path8.default.basename(sourcePath);
-      let destPath = import_node_path8.default.join(targetDir, fileName);
-      let counter = 1;
-      while (true) {
-        try {
-          await import_node_fs9.promises.access(destPath);
-          const ext = import_node_path8.default.extname(fileName);
-          const baseName = import_node_path8.default.basename(fileName, ext);
-          destPath = import_node_path8.default.join(targetDir, `${baseName} ${++counter}${ext}`);
-        } catch {
-          break;
-        }
-      }
-      const stats = await import_node_fs9.promises.stat(sourcePath);
-      if (stats.isDirectory()) {
-        await copyDirectory2(sourcePath, destPath);
-      } else {
-        await import_node_fs9.promises.copyFile(sourcePath, destPath);
-      }
-      pastedPaths.push(destPath);
-    }
-    return { success: true, data: { pastedPaths } };
-  } catch (error) {
-    return { success: false, error: String(error) };
-  }
-}
-async function copyDirectory2(source, dest) {
-  await import_node_fs9.promises.mkdir(dest, { recursive: true });
-  const entries = await import_node_fs9.promises.readdir(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = import_node_path8.default.join(source, entry.name);
-    const destPath = import_node_path8.default.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDirectory2(sourcePath, destPath);
-    } else {
-      await import_node_fs9.promises.copyFile(sourcePath, destPath);
-    }
-  }
-}
-
-// src/application-icon.ts
-var import_node_fs10 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
-var import_node_os2 = __toESM(require("os"), 1);
-var import_node_child_process2 = require("child_process");
-var import_node_util2 = require("util");
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
-async function findAppIconPath(appPath) {
-  const resourcesPath = import_node_path9.default.join(appPath, "Contents", "Resources");
-  try {
-    const commonIconNames = [
-      "AppIcon.icns",
-      "app.icns",
-      "application.icns",
-      "icon.icns"
-    ];
-    const infoPlistPath = import_node_path9.default.join(appPath, "Contents", "Info.plist");
-    try {
-      const infoPlistContent = await import_node_fs10.promises.readFile(infoPlistPath, "utf-8");
-      const iconFileMatch = infoPlistContent.match(/<key>CFBundleIconFile<\/key>\s*<string>([^<]+)<\/string>/);
-      if (iconFileMatch && iconFileMatch[1]) {
-        let iconFileName = iconFileMatch[1].trim();
-        if (!iconFileName.endsWith(".icns")) {
-          iconFileName += ".icns";
-        }
-        const iconPath = import_node_path9.default.join(resourcesPath, iconFileName);
-        try {
-          await import_node_fs10.promises.access(iconPath);
-          return iconPath;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    for (const iconName of commonIconNames) {
-      const iconPath = import_node_path9.default.join(resourcesPath, iconName);
-      try {
-        await import_node_fs10.promises.access(iconPath);
-        return iconPath;
-      } catch {
-        continue;
-      }
-    }
-    try {
-      const entries = await import_node_fs10.promises.readdir(resourcesPath);
-      const icnsFile = entries.find((entry) => entry.toLowerCase().endsWith(".icns"));
-      if (icnsFile) {
-        return import_node_path9.default.join(resourcesPath, icnsFile);
-      }
-    } catch {
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function getApplicationIcon(appPath) {
-  if (process.platform !== "darwin") {
-    return null;
-  }
-  try {
-    const stats = await import_node_fs10.promises.stat(appPath);
-    if (!stats.isDirectory() || !appPath.endsWith(".app")) {
-      return null;
-    }
-  } catch {
-    return null;
-  }
-  const iconPath = await findAppIconPath(appPath);
-  if (!iconPath) {
-    return null;
-  }
-  try {
-    const tempPngPath = import_node_path9.default.join(import_node_os2.default.tmpdir(), `app-icon-${Date.now()}.png`);
-    await execAsync2(
-      `sips -s format png "${iconPath}" --out "${tempPngPath}" --resampleHeightWidthMax 128`
-    );
-    const pngBuffer = await import_node_fs10.promises.readFile(tempPngPath);
-    try {
-      await import_node_fs10.promises.unlink(tempPngPath);
-    } catch {
-    }
-    const base64 = pngBuffer.toString("base64");
-    return `data:image/png;base64,${base64}`;
-  } catch {
-    return null;
-  }
-}
-
-// src/watch.ts
-var fs11 = __toESM(require("fs"), 1);
-var path12 = __toESM(require("path"), 1);
-var debounceTimers = /* @__PURE__ */ new Map();
-var DEBOUNCE_DELAY = 100;
-function watchDirectory(dirPath, callback) {
-  let watcher = null;
-  try {
-    watcher = fs11.watch(dirPath, { persistent: true }, (eventType, filename) => {
-      if (!filename) return;
-      const fullPath = path12.join(dirPath, filename);
-      const key = `${dirPath}:${filename}`;
-      const existingTimer = debounceTimers.get(key);
-      if (existingTimer) {
-        clearTimeout(existingTimer);
-      }
-      const timer = setTimeout(() => {
-        debounceTimers.delete(key);
-        fs11.access(fullPath, fs11.constants.F_OK, (err) => {
-          let type;
-          if (err) {
-            type = "remove";
-          } else if (eventType === "rename") {
-            type = "add";
-          } else {
-            type = "change";
-          }
-          callback({
-            type,
-            path: fullPath,
-            filename
-          });
-        });
-      }, DEBOUNCE_DELAY);
-      debounceTimers.set(key, timer);
-    });
-    watcher.on("error", (error) => {
-      console.error("Watch error:", error);
-    });
-  } catch (error) {
-    console.error("Failed to watch directory:", error);
-  }
-  return {
-    close: () => {
-      if (watcher) {
-        watcher.close();
-        watcher = null;
-      }
-      for (const [key, timer] of debounceTimers.entries()) {
-        if (key.startsWith(`${dirPath}:`)) {
-          clearTimeout(timer);
-          debounceTimers.delete(key);
-        }
-      }
-    },
-    path: dirPath
-  };
-}
-var WatchManager = class {
-  watchers = /* @__PURE__ */ new Map();
-  callbacks = /* @__PURE__ */ new Map();
-  /**
-   * 开始监听目录
-   */
-  watch(dirPath, callback) {
-    const normalizedPath = path12.normalize(dirPath);
-    let callbackSet = this.callbacks.get(normalizedPath);
-    if (!callbackSet) {
-      callbackSet = /* @__PURE__ */ new Set();
-      this.callbacks.set(normalizedPath, callbackSet);
-    }
-    callbackSet.add(callback);
-    let watcherInfo = this.watchers.get(normalizedPath);
-    if (watcherInfo) {
-      watcherInfo.refCount++;
-    } else {
-      const watcher = watchDirectory(normalizedPath, (event) => {
-        const callbacks = this.callbacks.get(normalizedPath);
-        if (callbacks) {
-          for (const cb of callbacks) {
-            try {
-              cb(event);
-            } catch (error) {
-              console.error("Watch callback error:", error);
-            }
-          }
-        }
-      });
-      watcherInfo = { watcher, refCount: 1 };
-      this.watchers.set(normalizedPath, watcherInfo);
-    }
-    return () => {
-      this.unwatch(normalizedPath, callback);
-    };
-  }
-  /**
-   * 停止监听
-   */
-  unwatch(dirPath, callback) {
-    const normalizedPath = path12.normalize(dirPath);
-    const callbackSet = this.callbacks.get(normalizedPath);
-    if (callbackSet) {
-      callbackSet.delete(callback);
-      if (callbackSet.size === 0) {
-        this.callbacks.delete(normalizedPath);
-      }
-    }
-    const watcherInfo = this.watchers.get(normalizedPath);
-    if (watcherInfo) {
-      watcherInfo.refCount--;
-      if (watcherInfo.refCount <= 0) {
-        watcherInfo.watcher.close();
-        this.watchers.delete(normalizedPath);
-      }
-    }
-  }
-  /**
-   * 关闭所有监听器
-   */
-  closeAll() {
-    for (const [, watcherInfo] of this.watchers) {
-      watcherInfo.watcher.close();
-    }
-    this.watchers.clear();
-    this.callbacks.clear();
-  }
-};
-var globalWatchManager = null;
-function getWatchManager() {
-  if (!globalWatchManager) {
-    globalWatchManager = new WatchManager();
-  }
-  return globalWatchManager;
-}
-
-// src/thumbnail/service.ts
-var import_node_fs11 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
-function isImageFile(filePath, fileType) {
-  return fileType === "image" /* IMAGE */;
-}
-function isVideoFile(filePath, fileType) {
-  return fileType === "video" /* VIDEO */;
-}
-var ThumbnailService = class {
-  database;
-  imageProcessor;
-  videoProcessor;
-  urlEncoder;
-  getApplicationIcon;
-  constructor(options) {
-    this.database = options.database;
-    this.imageProcessor = options.imageProcessor || null;
-    this.videoProcessor = options.videoProcessor || null;
-    this.urlEncoder = options.urlEncoder || ((p) => `file://${encodeURIComponent(p)}`);
-    this.getApplicationIcon = options.getApplicationIcon || null;
-  }
-  /**
-   * 获取缓存的缩略图 URL（不生成新的）
-   */
-  async getCachedThumbnailUrl(filePath) {
-    try {
-      const stats = await import_node_fs11.promises.stat(filePath);
-      const fileType = getFileType(filePath, stats);
-      if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
-        return await this.getApplicationIcon(filePath);
-      }
-      if (fileType !== "image" /* IMAGE */ && fileType !== "video" /* VIDEO */) {
-        return null;
-      }
-      const mtime = stats.mtime.getTime();
-      const cachedPath = this.database.getThumbnailPathFast(filePath, mtime);
-      if (cachedPath) {
-        return this.urlEncoder(cachedPath);
-      }
-      getFileHash(filePath, stats).then((fileHash) => {
-        this.generateThumbnail(filePath, fileHash, mtime).catch(() => {
-        });
-      }).catch(() => {
-      });
-      return null;
-    } catch (error) {
-      return null;
-    }
-  }
-  /**
-   * 获取缩略图 URL（如果没有缓存则生成）
-   */
-  async getThumbnailUrl(filePath) {
-    try {
-      const stats = await import_node_fs11.promises.stat(filePath);
-      const fileType = getFileType(filePath, stats);
-      if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
-        return await this.getApplicationIcon(filePath);
-      }
-      if (fileType !== "image" /* IMAGE */ && fileType !== "video" /* VIDEO */) {
-        return null;
-      }
-      const mtime = stats.mtime.getTime();
-      const cachedPath = this.database.getThumbnailPathFast(filePath, mtime);
-      if (cachedPath) {
-        return this.urlEncoder(cachedPath);
-      }
-      const fileHash = await getFileHash(filePath, stats);
-      const thumbnailPath = await this.generateThumbnail(filePath, fileHash, mtime);
-      if (thumbnailPath) {
-        return this.urlEncoder(thumbnailPath);
-      }
-      return null;
-    } catch (error) {
-      console.error(`Error getting thumbnail for ${filePath}:`, error);
-      return null;
-    }
-  }
-  /**
-   * 生成缩略图
-   */
-  async generateThumbnail(filePath, fileHash, mtime) {
-    const cachedPath = this.database.getThumbnailPath(filePath, fileHash, mtime);
-    if (cachedPath) {
-      return cachedPath;
-    }
-    try {
-      const stats = await import_node_fs11.promises.stat(filePath);
-      const fileType = getFileType(filePath, stats);
-      const hashPrefix = fileHash.substring(0, 16);
-      const thumbnailFileName = `${hashPrefix}.jpg`;
-      const thumbnailPath = import_node_path10.default.join(this.database.getCacheDir(), thumbnailFileName);
-      if (isImageFile(filePath, fileType) && this.imageProcessor) {
-        await this.imageProcessor.resize(filePath, thumbnailPath, 256);
-      } else if (isVideoFile(filePath, fileType) && this.videoProcessor) {
-        await this.videoProcessor.screenshot(filePath, thumbnailPath, "00:00:01", "256x256");
-      } else {
-        return null;
-      }
-      this.database.saveThumbnail(filePath, fileHash, mtime, thumbnailPath);
-      return thumbnailPath;
-    } catch (error) {
-      console.debug(`Error generating thumbnail for ${filePath}:`, error);
-      return null;
-    }
-  }
-  /**
-   * 批量生成缩略图（带并发限制，避免资源耗尽）
-   */
-  async generateThumbnailsBatch(files, concurrency = 3) {
-    const execute = async (file) => {
-      try {
-        await this.generateThumbnail(file.path, file.hash, file.mtime);
-      } catch (error) {
-        console.debug(`Failed to generate thumbnail for ${file.path}:`, error);
-      }
-    };
-    for (let i = 0; i < files.length; i += concurrency) {
-      const batch = files.slice(i, i + concurrency);
-      await Promise.allSettled(batch.map(execute));
-    }
-  }
-  /**
-   * 删除缩略图
-   */
-  deleteThumbnail(filePath) {
-    this.database.deleteThumbnail(filePath);
-  }
-  /**
-   * 清理旧缩略图
-   */
-  cleanupOldThumbnails() {
-    this.database.cleanupOldThumbnails();
-  }
-};
-var thumbnailService = null;
-function initThumbnailService(options) {
-  thumbnailService = new ThumbnailService(options);
-  return thumbnailService;
-}
-function getThumbnailService() {
-  return thumbnailService;
-}
-
-// src/thumbnail/database.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
-var import_node_fs12 = require("fs");
-var SqliteThumbnailDatabase = class {
-  db = null;
-  cacheDir;
-  dbPath;
-  constructor(userDataPath, options = {}) {
-    const defaultDirName = options.dirName || "thumbnails";
-    const defaultDbFileName = options.dbFileName || "thumbnails.db";
-    const inferredDirFromDbPath = options.dbPath ? import_node_path11.default.dirname(options.dbPath) : null;
-    this.cacheDir = options.thumbnailDir ? options.thumbnailDir : inferredDirFromDbPath || import_node_path11.default.join(userDataPath, defaultDirName);
-    this.dbPath = options.dbPath ? options.dbPath : import_node_path11.default.join(this.cacheDir, defaultDbFileName);
-    if (!(0, import_node_fs12.existsSync)(this.cacheDir)) {
-      (0, import_node_fs12.mkdirSync)(this.cacheDir, { recursive: true });
-    }
-  }
-  /**
-   * 初始化数据库
-   */
-  init() {
-    if (this.db) return;
-    this.db = new import_better_sqlite3.default(this.dbPath, {
-      fileMustExist: false
-    });
-    this.db.pragma("journal_mode = WAL");
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS thumbnails (
-        file_path TEXT PRIMARY KEY,
-        file_hash TEXT NOT NULL,
-        mtime INTEGER NOT NULL,
-        thumbnail_path TEXT NOT NULL,
-        created_at INTEGER NOT NULL
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_file_hash ON thumbnails(file_hash);
-      CREATE INDEX IF NOT EXISTS idx_mtime ON thumbnails(mtime);
-    `);
-  }
-  getCacheDir() {
-    return this.cacheDir;
-  }
-  /**
-   * 快速查询缩略图（用路径和修改时间，不需要哈希）
-   * 比计算文件哈希快很多
-   */
-  getThumbnailPathFast(filePath, mtime) {
-    if (!this.db) this.init();
-    const stmt = this.db.prepare(`
-      SELECT thumbnail_path 
-      FROM thumbnails 
-      WHERE file_path = ? AND mtime = ?
-    `);
-    const row = stmt.get(filePath, mtime);
-    if (row && (0, import_node_fs12.existsSync)(row.thumbnail_path)) {
-      return row.thumbnail_path;
-    }
-    return null;
-  }
-  getThumbnailPath(filePath, fileHash, mtime) {
-    if (!this.db) this.init();
-    const stmt = this.db.prepare(`
-      SELECT thumbnail_path, mtime 
-      FROM thumbnails 
-      WHERE file_path = ? AND file_hash = ?
-    `);
-    const row = stmt.get(filePath, fileHash);
-    if (row && row.mtime === mtime && (0, import_node_fs12.existsSync)(row.thumbnail_path)) {
-      return row.thumbnail_path;
-    }
-    return null;
-  }
-  saveThumbnail(filePath, fileHash, mtime, thumbnailPath) {
-    if (!this.db) this.init();
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO thumbnails 
-      (file_path, file_hash, mtime, thumbnail_path, created_at)
-      VALUES (?, ?, ?, ?, ?)
-    `);
-    stmt.run(filePath, fileHash, mtime, thumbnailPath, Date.now());
-  }
-  deleteThumbnail(filePath) {
-    if (!this.db) this.init();
-    const stmt = this.db.prepare("DELETE FROM thumbnails WHERE file_path = ?");
-    stmt.run(filePath);
-  }
-  cleanupOldThumbnails() {
-    if (!this.db) this.init();
-    const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
-    const stmt = this.db.prepare("DELETE FROM thumbnails WHERE created_at < ?");
-    stmt.run(thirtyDaysAgo);
-  }
-  close() {
-    if (this.db) {
-      try {
-        this.db.pragma("wal_checkpoint(TRUNCATE)");
-      } catch (error) {
-      }
-      this.db.close();
-      this.db = null;
-    }
-  }
-};
-var thumbnailDb = null;
-function createSqliteThumbnailDatabase(options) {
-  if (!thumbnailDb) {
-    thumbnailDb = new SqliteThumbnailDatabase(options.userDataPath, options);
-    thumbnailDb.init();
-  }
-  return thumbnailDb;
-}
-function getSqliteThumbnailDatabase() {
-  return thumbnailDb;
-}
-function closeThumbnailDatabase() {
-  if (thumbnailDb) {
-    thumbnailDb.close();
-    thumbnailDb = null;
-  }
-}
-
-// src/thumbnail/processors.ts
-var import_node_child_process3 = require("child_process");
-function createSharpImageProcessor(sharp) {
-  return {
-    async resize(filePath, outputPath, size) {
-      await sharp(filePath).resize({
-        width: size,
-        withoutEnlargement: true
-      }).jpeg({
-        quality: 80,
-        optimiseCoding: true
-        // 优化编码，提升压缩率
-      }).toFile(outputPath);
-    }
-  };
-}
-function createFfmpegVideoProcessor(ffmpegPath) {
-  return {
-    async screenshot(filePath, outputPath, timestamp, size) {
-      const width = size.split("x")[0];
-      return new Promise((resolve, reject) => {
-        const ffmpeg = (0, import_node_child_process3.spawn)(ffmpegPath, [
-          "-y",
-          "-ss",
-          timestamp,
-          "-i",
-          filePath,
-          "-vframes",
-          "1",
-          "-vf",
-          `thumbnail,scale=${width}:-1:force_original_aspect_ratio=decrease`,
-          // 使用 mjpeg 编码器，性能更好（借鉴 pixflow）
-          "-c:v",
-          "mjpeg",
-          "-q:v",
-          "6",
-          // 质量参数，6 表示中等质量（范围 2-31，数值越小质量越高）
-          outputPath
-        ]);
-        const timeout = setTimeout(() => {
-          ffmpeg.kill();
-          reject(new Error("Video thumbnail generation timeout"));
-        }, 3e4);
-        ffmpeg.stderr.on("data", (data) => {
-          const output = data.toString();
-          if (output.includes("Unsupported pixel format")) {
-            return;
-          }
-        });
-        ffmpeg.on("close", (code) => {
-          clearTimeout(timeout);
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error(`ffmpeg exited with code ${code}`));
-          }
-        });
-        ffmpeg.on("error", (error) => {
-          clearTimeout(timeout);
-          reject(error);
-        });
-      });
-    }
-  };
-}
-
-// src/media/format-detector.ts
-var import_node_child_process4 = require("child_process");
-var import_node_util3 = require("util");
-var import_node_path12 = __toESM(require("path"), 1);
-var execFileAsync = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
-var BROWSER_VIDEO_CONTAINERS = /* @__PURE__ */ new Set(["mp4", "webm", "ogg", "ogv"]);
-var BROWSER_VIDEO_CODECS = /* @__PURE__ */ new Set(["h264", "avc1", "vp8", "vp9", "theora", "av1"]);
-var BROWSER_AUDIO_CODECS = /* @__PURE__ */ new Set(["aac", "mp3", "opus", "vorbis", "flac"]);
-var BROWSER_AUDIO_CONTAINERS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "oga", "webm", "m4a", "aac", "flac"]);
-var BROWSER_AUDIO_ONLY_CODECS = /* @__PURE__ */ new Set(["mp3", "aac", "opus", "vorbis", "flac", "pcm_s16le", "pcm_s24le"]);
-var REMUXABLE_VIDEO_CODECS = /* @__PURE__ */ new Set(["h264", "avc1", "hevc", "h265"]);
-var REMUXABLE_AUDIO_CODECS = /* @__PURE__ */ new Set(["aac", "alac"]);
-var VIDEO_EXTENSIONS2 = /* @__PURE__ */ new Set([
-  "mp4",
-  "mkv",
-  "avi",
-  "mov",
-  "wmv",
-  "flv",
-  "webm",
-  "ogv",
-  "ogg",
-  "m4v",
-  "mpeg",
-  "mpg",
-  "3gp",
-  "ts",
-  "mts",
-  "m2ts",
-  "vob",
-  "rmvb",
-  "rm"
-]);
-var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
-  "mp3",
-  "wav",
-  "flac",
-  "aac",
-  "m4a",
-  "ogg",
-  "oga",
-  "wma",
-  "ape",
-  "alac",
-  "aiff",
-  "aif",
-  "opus",
-  "mid",
-  "midi",
-  "wv",
-  "mka"
-]);
-function getMediaTypeByExtension(filePath) {
-  const ext = import_node_path12.default.extname(filePath).toLowerCase().slice(1);
-  if (VIDEO_EXTENSIONS2.has(ext)) return "video";
-  if (AUDIO_EXTENSIONS.has(ext)) return "audio";
-  return null;
-}
-async function getMediaFormat(filePath, ffprobePath) {
-  try {
-    const { stdout } = await execFileAsync(ffprobePath, [
-      "-v",
-      "quiet",
-      "-print_format",
-      "json",
-      "-show_format",
-      "-show_streams",
-      filePath
-    ]);
-    const data = JSON.parse(stdout);
-    const format = data.format || {};
-    const streams = data.streams || [];
-    const videoStream = streams.find((s) => s.codec_type === "video");
-    const audioStream = streams.find((s) => s.codec_type === "audio");
-    const type = videoStream ? "video" : "audio";
-    const formatName = format.format_name || "";
-    const container = formatName.split(",")[0].toLowerCase();
-    return {
-      type,
-      container,
-      videoCodec: videoStream?.codec_name?.toLowerCase(),
-      audioCodec: audioStream?.codec_name?.toLowerCase(),
-      duration: parseFloat(format.duration) || void 0,
-      width: videoStream?.width,
-      height: videoStream?.height,
-      bitrate: parseInt(format.bit_rate) || void 0
-    };
-  } catch {
-    const type = getMediaTypeByExtension(filePath);
-    if (!type) return null;
-    const ext = import_node_path12.default.extname(filePath).toLowerCase().slice(1);
-    return {
-      type,
-      container: ext
-    };
-  }
-}
-function canPlayVideoDirectly(format) {
-  if (!BROWSER_VIDEO_CONTAINERS.has(format.container)) {
-    return false;
-  }
-  if (format.videoCodec && !BROWSER_VIDEO_CODECS.has(format.videoCodec)) {
-    return false;
-  }
-  if (format.audioCodec && !BROWSER_AUDIO_CODECS.has(format.audioCodec)) {
-    return false;
-  }
-  return true;
-}
-function canPlayAudioDirectly(format) {
-  if (!BROWSER_AUDIO_CONTAINERS.has(format.container)) {
-    return false;
-  }
-  if (format.audioCodec && !BROWSER_AUDIO_ONLY_CODECS.has(format.audioCodec)) {
-    return false;
-  }
-  return true;
-}
-function canRemuxVideo(format) {
-  if (!format.videoCodec || !REMUXABLE_VIDEO_CODECS.has(format.videoCodec)) {
-    return false;
-  }
-  if (format.audioCodec) {
-    const audioOk = BROWSER_AUDIO_CODECS.has(format.audioCodec) || REMUXABLE_AUDIO_CODECS.has(format.audioCodec);
-    if (!audioOk) {
-      return false;
-    }
-  }
-  return true;
-}
-function canRemuxAudio(format) {
-  return format.audioCodec ? REMUXABLE_AUDIO_CODECS.has(format.audioCodec) : false;
-}
-function estimateTranscodeTime(duration, method) {
-  if (!duration || method === "direct") return void 0;
-  if (method === "remux") {
-    return Math.ceil(duration / 50);
-  }
-  return Math.ceil(duration / 3);
-}
-async function detectTranscodeNeeds(filePath, ffprobePath) {
-  const formatInfo = await getMediaFormat(filePath, ffprobePath);
-  if (!formatInfo) {
-    const type2 = getMediaTypeByExtension(filePath) || "video";
-    return {
-      type: type2,
-      needsTranscode: false,
-      method: "direct"
-    };
-  }
-  const { type } = formatInfo;
-  if (type === "video") {
-    if (canPlayVideoDirectly(formatInfo)) {
-      return {
-        type,
-        needsTranscode: false,
-        method: "direct",
-        formatInfo
-      };
-    }
-    if (canRemuxVideo(formatInfo)) {
-      return {
-        type,
-        needsTranscode: true,
-        method: "remux",
-        formatInfo,
-        targetFormat: "mp4",
-        estimatedTime: estimateTranscodeTime(formatInfo.duration, "remux")
-      };
-    }
-    return {
-      type,
-      needsTranscode: true,
-      method: "transcode",
-      formatInfo,
-      targetFormat: "mp4",
-      estimatedTime: estimateTranscodeTime(formatInfo.duration, "transcode")
-    };
-  }
-  if (canPlayAudioDirectly(formatInfo)) {
-    return {
-      type,
-      needsTranscode: false,
-      method: "direct",
-      formatInfo
-    };
-  }
-  if (canRemuxAudio(formatInfo)) {
-    return {
-      type,
-      needsTranscode: true,
-      method: "remux",
-      formatInfo,
-      targetFormat: "m4a",
-      estimatedTime: estimateTranscodeTime(formatInfo.duration, "remux")
-    };
-  }
-  return {
-    type,
-    needsTranscode: true,
-    method: "transcode",
-    formatInfo,
-    targetFormat: "mp3",
-    estimatedTime: estimateTranscodeTime(formatInfo.duration, "transcode")
-  };
-}
-
-// src/media/transcoder.ts
-var import_node_child_process5 = require("child_process");
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
-var import_node_os3 = __toESM(require("os"), 1);
-async function getTempOutputPath(sourceFile, targetFormat, tempDir) {
-  const dir = tempDir || import_node_path13.default.join(import_node_os3.default.tmpdir(), "file-explorer-media");
-  await import_promises3.default.mkdir(dir, { recursive: true });
-  const baseName = import_node_path13.default.basename(sourceFile, import_node_path13.default.extname(sourceFile));
-  const timestamp = Date.now();
-  const outputName = `${baseName}_${timestamp}.${targetFormat}`;
-  return import_node_path13.default.join(dir, outputName);
-}
-function parseProgress(stderr, duration) {
-  const timeMatch = stderr.match(/time=(\d+):(\d+):(\d+)\.(\d+)/);
-  if (!timeMatch) return null;
-  const hours = parseInt(timeMatch[1]);
-  const minutes = parseInt(timeMatch[2]);
-  const seconds = parseInt(timeMatch[3]);
-  const ms = parseInt(timeMatch[4]);
-  const currentTime = hours * 3600 + minutes * 60 + seconds + ms / 100;
-  const speedMatch = stderr.match(/speed=\s*([\d.]+)x/);
-  const speed = speedMatch ? `${speedMatch[1]}x` : void 0;
-  let percent = 0;
-  if (duration && duration > 0) {
-    percent = Math.min(100, Math.round(currentTime / duration * 100));
-  }
-  return {
-    percent,
-    time: currentTime,
-    duration,
-    speed
-  };
-}
-async function remuxVideo(ffmpegPath, inputPath, outputPath, duration, onProgress) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "-i",
-      inputPath,
-      "-c",
-      "copy",
-      // 复制流，不重新编码
-      "-movflags",
-      "+faststart",
-      // 优化 MP4 播放
-      "-y",
-      // 覆盖输出文件
-      outputPath
-    ];
-    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
-    let stderrBuffer = "";
-    ffmpeg.stderr.on("data", (data) => {
-      stderrBuffer += data.toString();
-      if (onProgress) {
-        const progress = parseProgress(stderrBuffer, duration);
-        if (progress) {
-          onProgress(progress);
-        }
-      }
-    });
-    ffmpeg.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`ffmpeg exited with code ${code}`));
-      }
-    });
-    ffmpeg.on("error", reject);
-  });
-}
-async function transcodeVideo(ffmpegPath, inputPath, outputPath, duration, onProgress) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "-i",
-      inputPath,
-      "-c:v",
-      "libx264",
-      // H.264 编码
-      "-preset",
-      "fast",
-      // 编码速度预设
-      "-crf",
-      "23",
-      // 质量（18-28，越小越好）
-      "-c:a",
-      "aac",
-      // AAC 音频
-      "-b:a",
-      "192k",
-      // 音频比特率
-      "-movflags",
-      "+faststart",
-      "-y",
-      outputPath
-    ];
-    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
-    let stderrBuffer = "";
-    ffmpeg.stderr.on("data", (data) => {
-      stderrBuffer += data.toString();
-      if (onProgress) {
-        const progress = parseProgress(stderrBuffer, duration);
-        if (progress) {
-          onProgress(progress);
-        }
-      }
-    });
-    ffmpeg.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`ffmpeg exited with code ${code}`));
-      }
-    });
-    ffmpeg.on("error", reject);
-  });
-}
-async function remuxAudio(ffmpegPath, inputPath, outputPath, duration, onProgress) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "-i",
-      inputPath,
-      "-c",
-      "copy",
-      "-y",
-      outputPath
-    ];
-    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
-    let stderrBuffer = "";
-    ffmpeg.stderr.on("data", (data) => {
-      stderrBuffer += data.toString();
-      if (onProgress) {
-        const progress = parseProgress(stderrBuffer, duration);
-        if (progress) {
-          onProgress(progress);
-        }
-      }
-    });
-    ffmpeg.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`ffmpeg exited with code ${code}`));
-      }
-    });
-    ffmpeg.on("error", reject);
-  });
-}
-async function transcodeAudio(ffmpegPath, inputPath, outputPath, duration, onProgress) {
-  return new Promise((resolve, reject) => {
-    const ext = import_node_path13.default.extname(outputPath).toLowerCase();
-    const isM4a = ext === ".m4a";
-    const args = [
-      "-i",
-      inputPath,
-      "-c:a",
-      isM4a ? "aac" : "libmp3lame",
-      "-b:a",
-      "192k",
-      "-y",
-      outputPath
-    ];
-    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
-    let stderrBuffer = "";
-    ffmpeg.stderr.on("data", (data) => {
-      stderrBuffer += data.toString();
-      if (onProgress) {
-        const progress = parseProgress(stderrBuffer, duration);
-        if (progress) {
-          onProgress(progress);
-        }
-      }
-    });
-    ffmpeg.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`ffmpeg exited with code ${code}`));
-      }
-    });
-    ffmpeg.on("error", reject);
-  });
-}
-async function transcodeMedia(ffmpegPath, inputPath, transcodeInfo, tempDir, onProgress) {
-  try {
-    if (!transcodeInfo.needsTranscode) {
-      return {
-        success: true,
-        outputPath: inputPath
-      };
-    }
-    const targetFormat = transcodeInfo.targetFormat || (transcodeInfo.type === "video" ? "mp4" : "mp3");
-    const outputPath = await getTempOutputPath(inputPath, targetFormat, tempDir);
-    const duration = transcodeInfo.formatInfo?.duration;
-    if (transcodeInfo.type === "video") {
-      if (transcodeInfo.method === "remux") {
-        await remuxVideo(ffmpegPath, inputPath, outputPath, duration, onProgress);
-      } else {
-        await transcodeVideo(ffmpegPath, inputPath, outputPath, duration, onProgress);
-      }
-    } else {
-      if (transcodeInfo.method === "remux") {
-        await remuxAudio(ffmpegPath, inputPath, outputPath, duration, onProgress);
-      } else {
-        await transcodeAudio(ffmpegPath, inputPath, outputPath, duration, onProgress);
-      }
-    }
-    if (onProgress) {
-      onProgress({ percent: 100, duration });
-    }
-    return {
-      success: true,
-      outputPath
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-}
-async function cleanupTranscodedFile(filePath) {
-  try {
-    if (filePath.includes("file-explorer-media")) {
-      await import_promises3.default.unlink(filePath);
-    }
-  } catch {
-  }
-}
-async function cleanupAllTranscodedFiles(tempDir) {
-  const dir = tempDir || import_node_path13.default.join(import_node_os3.default.tmpdir(), "file-explorer-media");
-  try {
-    const files = await import_promises3.default.readdir(dir);
-    await Promise.all(
-      files.map((file) => import_promises3.default.unlink(import_node_path13.default.join(dir, file)).catch(() => {
-      }))
-    );
-  } catch {
-  }
-}
-
-// src/media/service.ts
-var import_node_path14 = __toESM(require("path"), 1);
-var import_node_child_process6 = require("child_process");
-var import_node_util4 = require("util");
-var execFileAsync2 = (0, import_node_util4.promisify)(import_node_child_process6.execFile);
-var mediaServiceInstance = null;
-var MediaService = class {
-  ffmpegPath;
-  ffprobePath;
-  tempDir;
-  urlEncoder;
-  // 缓存转码信息，避免重复检测
-  transcodeInfoCache = /* @__PURE__ */ new Map();
-  // 缓存已转码文件路径
-  transcodedFiles = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.ffmpegPath = options.ffmpegPath;
-    this.ffprobePath = options.ffprobePath || import_node_path14.default.join(import_node_path14.default.dirname(options.ffmpegPath), "ffprobe");
-    this.tempDir = options.tempDir;
-    this.urlEncoder = options.urlEncoder;
-  }
-  /**
-   * 检测文件是否需要转码
-   */
-  async needsTranscode(filePath) {
-    const cached = this.transcodeInfoCache.get(filePath);
-    if (cached) {
-      return cached;
-    }
-    const info = await detectTranscodeNeeds(filePath, this.ffprobePath);
-    this.transcodeInfoCache.set(filePath, info);
-    return info;
-  }
-  /**
-   * 执行转码并返回可播放的 URL
-   */
-  async transcode(filePath, onProgress) {
-    const existingOutput = this.transcodedFiles.get(filePath);
-    if (existingOutput) {
-      return {
-        success: true,
-        outputPath: existingOutput,
-        url: this.urlEncoder ? this.urlEncoder(existingOutput) : `file://${existingOutput}`
-      };
-    }
-    const transcodeInfo = await this.needsTranscode(filePath);
-    if (!transcodeInfo.needsTranscode) {
-      const url = this.urlEncoder ? this.urlEncoder(filePath) : `file://${filePath}`;
-      return {
-        success: true,
-        outputPath: filePath,
-        url
-      };
-    }
-    const result = await transcodeMedia(
-      this.ffmpegPath,
-      filePath,
-      transcodeInfo,
-      this.tempDir,
-      onProgress
-    );
-    if (result.success && result.outputPath) {
-      this.transcodedFiles.set(filePath, result.outputPath);
-      result.url = this.urlEncoder ? this.urlEncoder(result.outputPath) : `file://${result.outputPath}`;
-    }
-    return result;
-  }
-  /**
-   * 获取媒体元数据
-   */
-  async getMetadata(filePath) {
-    try {
-      const { stdout } = await execFileAsync2(this.ffprobePath, [
-        "-v",
-        "quiet",
-        "-print_format",
-        "json",
-        "-show_format",
-        "-show_streams",
-        filePath
-      ]);
-      const data = JSON.parse(stdout);
-      const format = data.format || {};
-      const tags = format.tags || {};
-      const formatInfo = await getMediaFormat(filePath, this.ffprobePath);
-      if (!formatInfo) return null;
-      return {
-        filePath,
-        type: formatInfo.type,
-        duration: parseFloat(format.duration) || 0,
-        format: formatInfo,
-        title: tags.title || tags.TITLE,
-        artist: tags.artist || tags.ARTIST,
-        album: tags.album || tags.ALBUM,
-        year: tags.date || tags.DATE || tags.year || tags.YEAR
-      };
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * 获取可播放的 URL
-   * 如果文件需要转码，则执行转码；否则直接返回文件 URL
-   */
-  async getPlayableUrl(filePath, onProgress) {
-    const result = await this.transcode(filePath, onProgress);
-    return result.success ? result.url || null : null;
-  }
-  /**
-   * 清理指定文件的转码缓存
-   */
-  async cleanupFile(filePath) {
-    const transcodedPath = this.transcodedFiles.get(filePath);
-    if (transcodedPath) {
-      await cleanupTranscodedFile(transcodedPath);
-      this.transcodedFiles.delete(filePath);
-    }
-    this.transcodeInfoCache.delete(filePath);
-  }
-  /**
-   * 清理所有转码缓存
-   */
-  async cleanup() {
-    await cleanupAllTranscodedFiles(this.tempDir);
-    this.transcodedFiles.clear();
-    this.transcodeInfoCache.clear();
-  }
-  /**
-   * 清除缓存（不删除文件）
-   */
-  clearCache() {
-    this.transcodeInfoCache.clear();
-  }
-};
-function initMediaService(options) {
-  mediaServiceInstance = new MediaService(options);
-  return mediaServiceInstance;
-}
-function getMediaService() {
-  return mediaServiceInstance;
-}
-function createMediaService(options) {
-  return new MediaService(options);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APP_PROTOCOL_HOST,
-  APP_PROTOCOL_PREFIX,
-  APP_PROTOCOL_SCHEME,
-  FileType,
-  MediaService,
-  SqliteThumbnailDatabase,
-  ThumbnailService,
-  WatchManager,
-  cleanupAllTranscodedFiles,
-  cleanupTranscodedFile,
-  closeThumbnailDatabase,
-  compressFiles,
-  copyFiles,
-  copyFilesToClipboard,
-  createFfmpegVideoProcessor,
-  createFile,
-  createFolder,
-  createMediaService,
-  createSharpImageProcessor,
-  createSqliteThumbnailDatabase,
-  decodeFileUrl,
-  deleteFiles,
-  detectArchiveFormat,
-  detectTranscodeNeeds,
-  encodeFileUrl,
-  exists,
-  extractArchive,
-  formatDate,
-  formatDateTime,
-  formatFileSize,
-  getAllSystemPaths,
-  getApplicationIcon,
-  getClipboardFiles,
-  getFileHash,
-  getFileInfo,
-  getFileType,
-  getHomeDirectory,
-  getMediaFormat,
-  getMediaService,
-  getMediaTypeByExtension,
-  getPlatform,
-  getSqliteThumbnailDatabase,
-  getSystemPath,
-  getThumbnailService,
-  getWatchManager,
-  initMediaService,
-  initThumbnailService,
-  isAppProtocolUrl,
-  isArchiveFile,
-  isDirectory,
-  isMediaFile,
-  isPreviewable,
-  moveFiles,
-  openInEditor,
-  openInTerminal,
-  pasteFiles,
-  readDirectory,
-  readFileContent,
-  readImageAsBase64,
-  renameFile,
-  revealInFileManager,
-  searchFiles,
-  searchFilesStream,
-  searchFilesSync,
-  showFileInfo,
-  transcodeMedia,
-  watchDirectory,
-  writeFileContent
-});
-//# sourceMappingURL=index.cjs.map