@huyooo/file-explorer-frontend-react 0.4.2

package/dist/index.js

@@ -0,0 +1,3453 @@
+// src/types/index.ts
+var FileType = {
+  FOLDER: "folder",
+  FILE: "file",
+  IMAGE: "image",
+  VIDEO: "video",
+  MUSIC: "music",
+  DOCUMENT: "document",
+  CODE: "code",
+  TEXT: "text",
+  PDF: "pdf",
+  ARCHIVE: "archive",
+  APPLICATION: "application",
+  UNKNOWN: "unknown"
+};
+
+// src/components/FileListView.tsx
+import { useState, useCallback, useImperativeHandle, forwardRef } from "react";
+import { Icon as Icon3 } from "@iconify/react";
+
+// src/components/FileGrid.tsx
+import { useRef, useMemo as useMemo2 } from "react";
+
+// src/components/FileIcon.tsx
+import { useMemo } from "react";
+import { Icon } from "@iconify/react";
+
+// src/utils/fileTypeIcon.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "3d",
+  "actionscript",
+  "ada",
+  "adobe-illustrator",
+  "adobe-photoshop",
+  "android",
+  "angular",
+  "applescript",
+  "arduino",
+  "asciidoc",
+  "assembly",
+  "astro",
+  "audio",
+  "aurelia",
+  "babel",
+  "ballerina",
+  "bazel",
+  "biome",
+  "blender",
+  "bower",
+  "bun",
+  "c",
+  "cabal",
+  "caddy",
+  "cake",
+  "certificate",
+  "changelog",
+  "circleci",
+  "claude",
+  "clojure",
+  "cmake",
+  "cobol",
+  "coffee",
+  "command",
+  "conduct",
+  "contributing",
+  "controller",
+  "copilot",
+  "cpp",
+  "crystal",
+  "csharp",
+  "css",
+  "css-map",
+  "cucumber",
+  "cuda",
+  "cursor",
+  "cypress",
+  "d",
+  "dart",
+  "database",
+  "deno",
+  "dependabot",
+  "diff",
+  "django",
+  "docker",
+  "document",
+  "drawio",
+  "drizzle",
+  "editorconfig",
+  "ejs",
+  "elixir",
+  "elm",
+  "email",
+  "ember",
+  "epub",
+  "erlang",
+  "esbuild",
+  "eslint",
+  "excalidraw",
+  "exe",
+  "favicon",
+  "figma",
+  "firebase",
+  "flash",
+  "flow",
+  "font",
+  "forth",
+  "fortran",
+  "freemarker",
+  "fsharp",
+  "gamemaker",
+  "gatsby",
+  "gcp",
+  "gemfile",
+  "gemini",
+  "git",
+  "gitlab",
+  "gleam",
+  "go",
+  "go-mod",
+  "godot",
+  "gradle",
+  "graphql",
+  "groovy",
+  "grunt",
+  "gulp",
+  "h",
+  "haml",
+  "handlebars",
+  "hardhat",
+  "haskell",
+  "haxe",
+  "hcl",
+  "helm",
+  "hjson",
+  "hosts",
+  "hpp",
+  "html",
+  "http",
+  "husky",
+  "i18n",
+  "image",
+  "imba",
+  "ionic",
+  "jar",
+  "java",
+  "javaclass",
+  "javascript",
+  "javascript-map",
+  "jenkins",
+  "jest",
+  "jinja",
+  "jsconfig",
+  "json",
+  "julia",
+  "jupyter",
+  "just",
+  "karma",
+  "key",
+  "kotlin",
+  "kubernetes",
+  "laravel",
+  "lean",
+  "lefthook",
+  "lerna",
+  "less",
+  "lib",
+  "license",
+  "lighthouse",
+  "liquid",
+  "lisp",
+  "livescript",
+  "lock",
+  "log",
+  "lua",
+  "luau",
+  "makefile",
+  "markdown",
+  "markdownlint",
+  "matlab",
+  "maven",
+  "mdx",
+  "mercurial",
+  "mermaid",
+  "meson",
+  "minecraft",
+  "mjml",
+  "mocha",
+  "mojo",
+  "nest",
+  "netlify",
+  "next",
+  "nginx",
+  "nim",
+  "nix",
+  "nodejs",
+  "nodemon",
+  "npm",
+  "nuget",
+  "nunjucks",
+  "nuxt",
+  "nx",
+  "objective-c",
+  "objective-cpp",
+  "ocaml",
+  "odin",
+  "openapi",
+  "opentofu",
+  "pascal",
+  "pdf",
+  "perl",
+  "php",
+  "phpstan",
+  "phpunit",
+  "pipeline",
+  "playwright",
+  "pnpm",
+  "postcss",
+  "powerpoint",
+  "powershell",
+  "prettier",
+  "prisma",
+  "processing",
+  "prolog",
+  "proto",
+  "pug",
+  "puppet",
+  "purescript",
+  "python",
+  "pytorch",
+  "quasar",
+  "r",
+  "racket",
+  "razor",
+  "react",
+  "react-ts",
+  "readme",
+  "reason",
+  "remark",
+  "remix",
+  "renovate",
+  "replit",
+  "rescript",
+  "riot",
+  "roadmap",
+  "robot",
+  "robots",
+  "rollup",
+  "routing",
+  "rspec",
+  "rubocop",
+  "ruby",
+  "ruff",
+  "rust",
+  "salt",
+  "san",
+  "sas",
+  "sass",
+  "sbt",
+  "scala",
+  "scheme",
+  "search",
+  "sentry",
+  "sequelize",
+  "serverless",
+  "settings",
+  "shader",
+  "shellcheck",
+  "sketch",
+  "slim",
+  "slint",
+  "smarty",
+  "snakemake",
+  "snapcraft",
+  "snyk",
+  "solidity",
+  "spwn",
+  "stackblitz",
+  "stan",
+  "stencil",
+  "storybook",
+  "stryker",
+  "stylelint",
+  "stylus",
+  "sublime",
+  "subtitles",
+  "supabase",
+  "svelte",
+  "svg",
+  "svgo",
+  "swagger",
+  "swc",
+  "swift",
+  "tailwindcss",
+  "taskfile",
+  "tauri",
+  "tcl",
+  "teal",
+  "templ",
+  "template",
+  "terraform",
+  "test-js",
+  "test-jsx",
+  "test-ts",
+  "tex",
+  "todo",
+  "toml",
+  "travis",
+  "tree",
+  "tsconfig",
+  "tsdoc",
+  "turborepo",
+  "twig",
+  "typescript",
+  "typescript-def",
+  "unity",
+  "unocss",
+  "vagrant",
+  "vanilla-extract",
+  "vercel",
+  "verilog",
+  "video",
+  "vim",
+  "vite",
+  "vitest",
+  "vlang",
+  "vscode",
+  "vue",
+  "vue-config",
+  "wakatime",
+  "wallaby",
+  "webassembly",
+  "webhint",
+  "webpack",
+  "windicss",
+  "word",
+  "wrangler",
+  "wxt",
+  "xaml",
+  "xmake",
+  "xml",
+  "yaml",
+  "yarn",
+  "zig",
+  "zip"
+]);
+var EXT_MAP = {
+  // JavaScript/TypeScript
+  "js": "javascript",
+  "mjs": "javascript",
+  "cjs": "javascript",
+  "jsx": "react",
+  "ts": "typescript",
+  "mts": "typescript",
+  "cts": "typescript",
+  "tsx": "react-ts",
+  // 前端框架
+  "vue": "vue",
+  "svelte": "svelte",
+  "astro": "astro",
+  // 后端语言
+  "py": "python",
+  "pyw": "python",
+  "pyi": "python",
+  "pyc": "python",
+  "java": "java",
+  "class": "javaclass",
+  "jar": "jar",
+  "c": "c",
+  "h": "h",
+  "cpp": "cpp",
+  "cc": "cpp",
+  "cxx": "cpp",
+  "hpp": "hpp",
+  "hh": "hpp",
+  "hxx": "hpp",
+  "cs": "csharp",
+  "csx": "csharp",
+  "go": "go",
+  "rs": "rust",
+  "php": "php",
+  "phtml": "php",
+  "rb": "ruby",
+  "rake": "ruby",
+  "swift": "swift",
+  "kt": "kotlin",
+  "kts": "kotlin",
+  "scala": "scala",
+  "dart": "dart",
+  "lua": "lua",
+  "luau": "luau",
+  "r": "r",
+  "rdata": "r",
+  "rds": "r",
+  "pl": "perl",
+  "pm": "perl",
+  "sh": "command",
+  "bash": "command",
+  "zsh": "command",
+  "fish": "command",
+  "ps1": "powershell",
+  "psm1": "powershell",
+  "psd1": "powershell",
+  "bat": "command",
+  "cmd": "command",
+  // 样式
+  "css": "css",
+  "scss": "sass",
+  "sass": "sass",
+  "less": "less",
+  "styl": "stylus",
+  // 标记/配置
+  "html": "html",
+  "htm": "html",
+  "xhtml": "html",
+  "xml": "xml",
+  "xsl": "xml",
+  "xslt": "xml",
+  "json": "json",
+  "jsonc": "json",
+  "json5": "json",
+  "yaml": "yaml",
+  "yml": "yaml",
+  "toml": "toml",
+  "ini": "settings",
+  "conf": "settings",
+  "config": "settings",
+  // 文档
+  "md": "markdown",
+  "markdown": "markdown",
+  "mdx": "mdx",
+  "txt": "document",
+  "pdf": "pdf",
+  "doc": "word",
+  "docx": "word",
+  "dot": "word",
+  "dotx": "word",
+  "odt": "word",
+  "xls": "table",
+  "xlsx": "table",
+  "xlsm": "table",
+  "ods": "table",
+  "csv": "table",
+  "ppt": "powerpoint",
+  "pptx": "powerpoint",
+  "odp": "powerpoint",
+  // 图片
+  "jpg": "image",
+  "jpeg": "image",
+  "png": "image",
+  "gif": "image",
+  "webp": "image",
+  "ico": "image",
+  "bmp": "image",
+  "tiff": "image",
+  "tif": "image",
+  "heic": "image",
+  "heif": "image",
+  "svg": "svg",
+  "psd": "adobe-photoshop",
+  "ai": "adobe-illustrator",
+  "sketch": "sketch",
+  "fig": "figma",
+  "figma": "figma",
+  // 视频/音频
+  "mp4": "video",
+  "mov": "video",
+  "avi": "video",
+  "mkv": "video",
+  "webm": "video",
+  "flv": "video",
+  "wmv": "video",
+  "m4v": "video",
+  "3gp": "video",
+  "mpeg": "video",
+  "mpg": "video",
+  "mp3": "audio",
+  "wav": "audio",
+  "flac": "audio",
+  "aac": "audio",
+  "ogg": "audio",
+  "wma": "audio",
+  "m4a": "audio",
+  "aiff": "audio",
+  // 压缩
+  "zip": "zip",
+  "rar": "zip",
+  "7z": "zip",
+  "tar": "zip",
+  "gz": "zip",
+  "bz2": "zip",
+  "xz": "zip",
+  "tgz": "zip",
+  "tbz2": "zip",
+  // 数据库
+  "sql": "database",
+  "db": "database",
+  "sqlite": "database",
+  "sqlite3": "database",
+  "prisma": "prisma",
+  // 其他
+  "log": "log",
+  "lock": "lock",
+  "env": "settings",
+  "graphql": "graphql",
+  "gql": "graphql",
+  "proto": "proto",
+  "wasm": "webassembly",
+  "zig": "zig",
+  "nim": "nim",
+  "nix": "nix",
+  "hcl": "hcl",
+  "tf": "terraform",
+  "sol": "solidity",
+  "ex": "elixir",
+  "exs": "elixir",
+  "erl": "erlang",
+  "hrl": "erlang",
+  "hs": "haskell",
+  "lhs": "haskell",
+  "ml": "ocaml",
+  "mli": "ocaml",
+  "clj": "clojure",
+  "cljs": "clojure",
+  "cljc": "clojure",
+  "lisp": "lisp",
+  "lsp": "lisp",
+  "el": "lisp",
+  "vim": "vim",
+  "dockerfile": "docker"
+};
+var SPECIAL_FILES = {
+  // Git
+  ".gitignore": "git",
+  ".gitattributes": "git",
+  ".gitmodules": "git",
+  ".gitkeep": "git",
+  // 环境
+  ".env": "settings",
+  ".env.local": "settings",
+  ".env.development": "settings",
+  ".env.production": "settings",
+  ".env.test": "settings",
+  ".env.example": "settings",
+  // Node/包管理
+  "package.json": "nodejs",
+  "package-lock.json": "npm",
+  "yarn.lock": "yarn",
+  ".yarnrc": "yarn",
+  ".yarnrc.yml": "yarn",
+  "pnpm-lock.yaml": "pnpm",
+  ".pnpmfile.cjs": "pnpm",
+  "bun.lockb": "bun",
+  "bunfig.toml": "bun",
+  // Python
+  "requirements.txt": "python",
+  "pipfile": "python",
+  "pipfile.lock": "python",
+  "pyproject.toml": "python",
+  "poetry.lock": "python",
+  "setup.py": "python",
+  // Rust
+  "cargo.toml": "rust",
+  "cargo.lock": "rust",
+  // Go
+  "go.mod": "go-mod",
+  "go.sum": "go-mod",
+  "go.work": "go-mod",
+  // PHP
+  "composer.json": "php",
+  "composer.lock": "php",
+  // Ruby
+  "gemfile": "gemfile",
+  "gemfile.lock": "gemfile",
+  "rakefile": "ruby",
+  // Docker
+  "dockerfile": "docker",
+  "docker-compose.yml": "docker",
+  "docker-compose.yaml": "docker",
+  ".dockerignore": "docker",
+  // 构建工具
+  "makefile": "makefile",
+  "gnumakefile": "makefile",
+  "cmakelists.txt": "cmake",
+  "build.gradle": "gradle",
+  "build.gradle.kts": "gradle",
+  "settings.gradle": "gradle",
+  "pom.xml": "maven",
+  // 配置
+  "tsconfig.json": "tsconfig",
+  "jsconfig.json": "jsconfig",
+  ".prettierrc": "prettier",
+  ".prettierrc.json": "prettier",
+  ".prettierrc.js": "prettier",
+  ".prettierignore": "prettier",
+  "prettier.config.js": "prettier",
+  ".eslintrc": "eslint",
+  ".eslintrc.json": "eslint",
+  ".eslintrc.js": "eslint",
+  ".eslintignore": "eslint",
+  "eslint.config.js": "eslint",
+  "eslint.config.mjs": "eslint",
+  ".editorconfig": "editorconfig",
+  "vite.config.ts": "vite",
+  "vite.config.js": "vite",
+  "webpack.config.js": "webpack",
+  "webpack.config.ts": "webpack",
+  "rollup.config.js": "rollup",
+  "rollup.config.ts": "rollup",
+  "esbuild.config.js": "esbuild",
+  "tailwind.config.js": "tailwindcss",
+  "tailwind.config.ts": "tailwindcss",
+  "postcss.config.js": "postcss",
+  "postcss.config.cjs": "postcss",
+  "babel.config.js": "babel",
+  ".babelrc": "babel",
+  "jest.config.js": "jest",
+  "jest.config.ts": "jest",
+  "vitest.config.ts": "vitest",
+  "vitest.config.js": "vitest",
+  "playwright.config.ts": "playwright",
+  "playwright.config.js": "playwright",
+  "cypress.config.ts": "cypress",
+  "cypress.config.js": "cypress",
+  ".swcrc": "swc",
+  "swc.config.js": "swc",
+  "turbo.json": "turborepo",
+  "nx.json": "nx",
+  "biome.json": "biome",
+  ".nvmrc": "nodejs",
+  ".node-version": "nodejs",
+  // 框架配置
+  "nuxt.config.ts": "nuxt",
+  "nuxt.config.js": "nuxt",
+  "next.config.js": "next",
+  "next.config.mjs": "next",
+  "next.config.ts": "next",
+  "svelte.config.js": "svelte",
+  "astro.config.mjs": "astro",
+  "astro.config.ts": "astro",
+  "vue.config.js": "vue-config",
+  "angular.json": "angular",
+  "nest-cli.json": "nest",
+  "tauri.conf.json": "tauri",
+  // CI/CD
+  ".travis.yml": "travis",
+  ".gitlab-ci.yml": "gitlab",
+  "vercel.json": "vercel",
+  "netlify.toml": "netlify",
+  // 其他
+  "license": "license",
+  "license.md": "license",
+  "license.txt": "license",
+  "readme": "readme",
+  "readme.md": "readme",
+  "readme.txt": "readme",
+  "changelog": "changelog",
+  "changelog.md": "changelog",
+  ".npmrc": "npm",
+  ".npmignore": "npm",
+  "robots.txt": "robots",
+  ".htaccess": "nginx",
+  "vagrantfile": "vagrant",
+  ".stylelintrc": "stylelint",
+  ".stylelintrc.json": "stylelint",
+  "nodemon.json": "nodemon",
+  ".huskyrc": "husky",
+  "renovate.json": "renovate",
+  ".snyk": "snyk",
+  "deno.json": "deno",
+  "deno.jsonc": "deno"
+};
+function getFileTypeIcon(fileName, fallbackType) {
+  const lowerName = fileName.toLowerCase();
+  if (SPECIAL_FILES[lowerName]) {
+    const type = SPECIAL_FILES[lowerName];
+    if (KNOWN_TYPES.has(type)) {
+      return `material-icon-theme:${type}`;
+    }
+  }
+  if (lowerName === "dockerfile" || lowerName.startsWith("dockerfile.")) {
+    return "material-icon-theme:docker";
+  }
+  if (lowerName === ".env" || lowerName.startsWith(".env.")) {
+    return "material-icon-theme:settings";
+  }
+  const lastDotIndex = fileName.lastIndexOf(".");
+  const ext = lastDotIndex > 0 ? fileName.substring(lastDotIndex + 1).toLowerCase() : "";
+  if (ext === "ts" || ext === "js") {
+    const baseName = fileName.substring(0, lastDotIndex).toLowerCase();
+    if (baseName.endsWith(".d")) {
+      return "material-icon-theme:typescript-def";
+    }
+    if (baseName.endsWith(".test") || baseName.endsWith(".spec")) {
+      return ext === "ts" ? "material-icon-theme:test-ts" : "material-icon-theme:test-js";
+    }
+  }
+  if (ext === "jsx" || ext === "tsx") {
+    const baseName = fileName.substring(0, lastDotIndex).toLowerCase();
+    if (baseName.endsWith(".test") || baseName.endsWith(".spec")) {
+      return ext === "tsx" ? "material-icon-theme:test-ts" : "material-icon-theme:test-jsx";
+    }
+  }
+  if (ext && EXT_MAP[ext]) {
+    const type = EXT_MAP[ext];
+    if (KNOWN_TYPES.has(type)) {
+      return `material-icon-theme:${type}`;
+    }
+  }
+  if (fallbackType) {
+    return getFallbackIcon(fallbackType);
+  }
+  return "material-icon-theme:document";
+}
+function getFallbackIcon(type) {
+  switch (type) {
+    case FileType.IMAGE:
+      return "material-icon-theme:image";
+    case FileType.VIDEO:
+      return "material-icon-theme:video";
+    case FileType.MUSIC:
+      return "material-icon-theme:audio";
+    case FileType.CODE:
+      return "material-icon-theme:javascript";
+    case FileType.TEXT:
+      return "material-icon-theme:document";
+    case FileType.DOCUMENT:
+      return "material-icon-theme:word";
+    case FileType.PDF:
+      return "material-icon-theme:pdf";
+    case FileType.ARCHIVE:
+      return "material-icon-theme:zip";
+    case FileType.APPLICATION:
+      return "material-icon-theme:exe";
+    default:
+      return "material-icon-theme:document";
+  }
+}
+
+// src/utils/folderTypeIcon.ts
+var KNOWN_TYPES2 = /* @__PURE__ */ new Set([
+  "admin",
+  "android",
+  "angular",
+  "animation",
+  "ansible",
+  "api",
+  "apollo",
+  "app",
+  "archive",
+  "astro",
+  "atom",
+  "attachment",
+  "audio",
+  "aurelia",
+  "aws",
+  "azure-pipelines",
+  "backup",
+  "base",
+  "batch",
+  "benchmark",
+  "bibliography",
+  "bicep",
+  "blender",
+  "bloc",
+  "bower",
+  "buildkite",
+  "cart",
+  "changesets",
+  "ci",
+  "circleci",
+  "class",
+  "claude",
+  "client",
+  "cline",
+  "cloud-functions",
+  "cloudflare",
+  "cluster",
+  "cobol",
+  "command",
+  "components",
+  "config",
+  "connection",
+  "console",
+  "constant",
+  "container",
+  "content",
+  "context",
+  "contract",
+  "controller",
+  "core",
+  "coverage",
+  "css",
+  "cue",
+  "cursor",
+  "custom",
+  "cypress",
+  "dal",
+  "dart",
+  "database",
+  "debug",
+  "decorators",
+  "delta",
+  "desktop",
+  "directive",
+  "dist",
+  "docker",
+  "docs",
+  "download",
+  "drizzle",
+  "dump",
+  "element",
+  "enum",
+  "environment",
+  "error",
+  "eslint",
+  "event",
+  "examples",
+  "expo",
+  "export",
+  "fastlane",
+  "favicon",
+  "features",
+  "filter",
+  "firebase",
+  "firestore",
+  "flow",
+  "flutter",
+  "font",
+  "forgejo",
+  "functions",
+  "gamemaker",
+  "generator",
+  "gh-workflows",
+  "git",
+  "gitea",
+  "github",
+  "gitlab",
+  "global",
+  "godot",
+  "gradle",
+  "graphql",
+  "guard",
+  "gulp",
+  "helm",
+  "helper",
+  "home",
+  "hook",
+  "husky",
+  "i18n",
+  "images",
+  "import",
+  "include",
+  "input",
+  "intellij",
+  "interceptor",
+  "interface",
+  "ios",
+  "java",
+  "javascript",
+  "jinja",
+  "job",
+  "json",
+  "jupyter",
+  "keys",
+  "kubernetes",
+  "kusto",
+  "layout",
+  "lefthook",
+  "less",
+  "lib",
+  "license",
+  "link",
+  "linux",
+  "liquibase",
+  "log",
+  "lottie",
+  "lua",
+  "luau",
+  "macos",
+  "mail",
+  "mappings",
+  "markdown",
+  "mercurial",
+  "messages",
+  "meta",
+  "metro",
+  "middleware",
+  "migrations",
+  "mjml",
+  "mobile",
+  "mock",
+  "mojo",
+  "molecule",
+  "moon",
+  "netlify",
+  "next",
+  "ngrx-store",
+  "node",
+  "nuxt",
+  "obsidian",
+  "organism",
+  "other",
+  "packages",
+  "pdf",
+  "pdm",
+  "php",
+  "phpmailer",
+  "pipe",
+  "plastic",
+  "plugin",
+  "policy",
+  "powershell",
+  "prisma",
+  "private",
+  "project",
+  "prompts",
+  "proto",
+  "public",
+  "python",
+  "pytorch",
+  "quasar",
+  "queue",
+  "react-components",
+  "redux-reducer",
+  "repository",
+  "resolver",
+  "resource",
+  "review",
+  "robot",
+  "routes",
+  "rules",
+  "rust",
+  "salt",
+  "sandbox",
+  "sass",
+  "scala",
+  "scons",
+  "scripts",
+  "secure",
+  "seeders",
+  "server",
+  "serverless",
+  "shader",
+  "shared",
+  "simulations",
+  "snapcraft",
+  "snippet",
+  "src",
+  "src-tauri",
+  "stack",
+  "stencil",
+  "store",
+  "storybook",
+  "stylus",
+  "sublime",
+  "supabase",
+  "svelte",
+  "svg",
+  "syntax",
+  "target",
+  "taskfile",
+  "tasks",
+  "television",
+  "temp",
+  "template",
+  "terraform",
+  "test",
+  "theme",
+  "toc",
+  "tools",
+  "trash",
+  "trigger",
+  "turborepo",
+  "typescript",
+  "ui",
+  "unity",
+  "update",
+  "upload",
+  "utils",
+  "vercel",
+  "verdaccio",
+  "video",
+  "views",
+  "vm",
+  "vscode",
+  "vue",
+  "vue-directives",
+  "vuepress",
+  "vuex-store",
+  "wakatime",
+  "webpack",
+  "windows",
+  "wordpress",
+  "yarn",
+  "zeabur"
+]);
+var ALIASES = {
+  // 复数/变体
+  "tests": "test",
+  "__tests__": "test",
+  "__test__": "test",
+  "spec": "test",
+  "specs": "test",
+  "script": "scripts",
+  "configs": "config",
+  "configuration": "config",
+  "configurations": "config",
+  "route": "routes",
+  "routing": "routes",
+  "stories": "storybook",
+  "story": "storybook",
+  "templates": "template",
+  "themes": "theme",
+  "videos": "video",
+  "imgs": "images",
+  "img": "images",
+  "image": "images",
+  "fonts": "font",
+  "styles": "css",
+  "style": "css",
+  "styling": "css",
+  "stylesheets": "css",
+  "view": "views",
+  "pages": "views",
+  "page": "views",
+  "layouts": "layout",
+  "models": "database",
+  "model": "database",
+  "modules": "lib",
+  "module": "lib",
+  "mods": "lib",
+  "plugins": "plugin",
+  "addons": "plugin",
+  "extensions": "plugin",
+  "middlewares": "middleware",
+  "helpers": "helper",
+  "utilities": "utils",
+  "util": "utils",
+  "tool": "tools",
+  "tooling": "tools",
+  "resources": "resource",
+  "res": "resource",
+  "assets": "resource",
+  "asset": "resource",
+  "hooks": "hook",
+  "composables": "hook",
+  "mocks": "mock",
+  "__mocks__": "mock",
+  "fixtures": "mock",
+  "__fixtures__": "mock",
+  "logs": "log",
+  "uploads": "upload",
+  "function": "functions",
+  "func": "functions",
+  "fns": "functions",
+  "services": "server",
+  "service": "server",
+  "component": "components",
+  "comp": "components",
+  "comps": "components",
+  "controllers": "controller",
+  // 常见变体
+  "source": "src",
+  "sources": "src",
+  "distribution": "dist",
+  "build": "dist",
+  "builds": "dist",
+  "out": "dist",
+  "output": "dist",
+  "documentation": "docs",
+  "doc": "docs",
+  "document": "docs",
+  "documents": "docs",
+  "static": "public",
+  "statics": "public",
+  "publics": "public",
+  "libs": "lib",
+  "library": "lib",
+  "vendor": "lib",
+  "vendors": "lib",
+  "bin": "scripts",
+  "binaries": "scripts",
+  "tmp": "temp",
+  "temporary": "temp",
+  "cache": "temp",
+  "caches": "temp",
+  ".cache": "temp",
+  ".turbo": "temp",
+  "types": "typescript",
+  "@types": "typescript",
+  "typings": "typescript",
+  "dts": "typescript",
+  "locales": "i18n",
+  "locale": "i18n",
+  "lang": "i18n",
+  "languages": "i18n",
+  "translations": "i18n",
+  "db": "database",
+  "databases": "database",
+  "sql": "database",
+  "queries": "database",
+  "migration": "migrations",
+  "seeds": "seeders",
+  "seed": "seeders",
+  // 技术栈
+  ".vscode": "vscode",
+  ".github": "github",
+  ".gitlab": "gitlab",
+  ".circleci": "circleci",
+  ".husky": "husky",
+  ".docker": "docker",
+  "node_modules": "node",
+  "scss": "sass",
+  "renderer": "client",
+  "frontend": "client",
+  "web": "client",
+  "webapp": "client",
+  "website": "client",
+  "backend": "server",
+  "main": "server",
+  "preload": "scripts",
+  ".idea": "intellij",
+  ".git": "git",
+  "k8s": "kubernetes",
+  "kube": "kubernetes",
+  "mongo": "database",
+  "mongodb": "database",
+  "mysql": "database",
+  "postgres": "database",
+  "api": "api",
+  "apis": "api",
+  "interfaces": "interface",
+  "notebook": "jupyter",
+  "notebooks": "jupyter",
+  "ipynb": "jupyter",
+  "notification": "messages",
+  "notifications": "messages",
+  "env": "environment",
+  "envs": "environment",
+  "redux": "redux-reducer",
+  "store": "store",
+  "stores": "store",
+  "electron": "desktop",
+  "tauri": "src-tauri"
+};
+function getFolderTypeIcon(folderName) {
+  const name = (folderName || "").trim();
+  if (!name) return void 0;
+  const lower = name.replace(/[\\/]+$/, "").toLowerCase();
+  const standardName = ALIASES[lower] ?? lower;
+  if (KNOWN_TYPES2.has(standardName)) {
+    return `material-icon-theme:folder-${standardName}`;
+  }
+  return void 0;
+}
+
+// src/components/FileIcon.tsx
+import { jsx } from "react/jsx-runtime";
+function FileIcon({ type, name, className = "", size = 24 }) {
+  const iconName = useMemo(() => {
+    if (type === FileType.FOLDER) {
+      const folderIcon = name ? getFolderTypeIcon(name) : void 0;
+      return folderIcon ?? "flat-color-icons:folder";
+    }
+    if (name) {
+      return getFileTypeIcon(name, type);
+    }
+    switch (type) {
+      case FileType.IMAGE:
+        return "material-icon-theme:image";
+      case FileType.TEXT:
+        return "material-icon-theme:document";
+      case FileType.CODE:
+        return "material-icon-theme:javascript";
+      case FileType.MUSIC:
+        return "material-icon-theme:audio";
+      case FileType.VIDEO:
+        return "material-icon-theme:video";
+      case FileType.PDF:
+        return "material-icon-theme:pdf";
+      case FileType.DOCUMENT:
+        return "material-icon-theme:word";
+      case FileType.APPLICATION:
+        return "material-icon-theme:exe";
+      case FileType.ARCHIVE:
+        return "material-icon-theme:zip";
+      default:
+        return "material-icon-theme:document";
+    }
+  }, [type, name]);
+  const iconClass = useMemo(() => {
+    const base = "file-icon";
+    switch (type) {
+      case FileType.FOLDER:
+        return `${base} file-icon--folder`;
+      case FileType.IMAGE:
+        return `${base} file-icon--image`;
+      case FileType.TEXT:
+        return `${base} file-icon--text`;
+      case FileType.CODE:
+        return `${base} file-icon--code`;
+      case FileType.MUSIC:
+        return `${base} file-icon--music`;
+      case FileType.VIDEO:
+        return `${base} file-icon--video`;
+      case FileType.PDF:
+      case FileType.DOCUMENT:
+        return `${base} file-icon--pdf`;
+      case FileType.APPLICATION:
+        return `${base} file-icon--application`;
+      case FileType.ARCHIVE:
+        return `${base} file-icon--archive`;
+      default:
+        return `${base} file-icon--default`;
+    }
+  }, [type]);
+  return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(Icon, { icon: iconName, width: size, height: size, className: iconClass }) });
+}
+
+// src/components/FileGrid.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function splitFileName(name, isFolder) {
+  if (isFolder) {
+    return { baseName: name, ext: "" };
+  }
+  const lastDot = name.lastIndexOf(".");
+  if (lastDot <= 0) {
+    return { baseName: name, ext: "" };
+  }
+  return {
+    baseName: name.substring(0, lastDot),
+    ext: name.substring(lastDot)
+    // 包含点号
+  };
+}
+function FileName({
+  name,
+  isFolder,
+  isSelected,
+  onClick
+}) {
+  const { baseName, ext } = useMemo2(() => splitFileName(name, isFolder), [name, isFolder]);
+  return /* @__PURE__ */ jsx2(
+    "span",
+    {
+      onClick,
+      className: `file-grid-item-name ${isSelected ? "file-grid-item-name--selected" : ""}`,
+      title: name,
+      children: ext ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("span", { className: "file-grid-item-name-base", children: baseName }),
+        /* @__PURE__ */ jsx2("span", { className: "file-grid-item-name-ext", children: ext })
+      ] }) : name
+    }
+  );
+}
+function FileGrid({
+  items,
+  selectedIds,
+  editingId,
+  dragOverId,
+  getAppIconUrl,
+  onSelect,
+  onOpen,
+  onContextMenu,
+  onContextMenuEmpty,
+  onNameClick,
+  onRename,
+  onRenameCancel,
+  onDragStart,
+  onDragOver,
+  onDragLeave,
+  onDrop,
+  onThumbnailError
+}) {
+  const renameInputRef = useRef(null);
+  const handleEmptyContextMenu = (e) => {
+    const target = e.target;
+    if (!target.closest(".file-grid-item")) {
+      onContextMenuEmpty?.(e);
+    }
+  };
+  const hasThumbnail = (item) => {
+    if (item.type === FileType.APPLICATION && getAppIconUrl?.(item)) {
+      return true;
+    }
+    if (item.type === FileType.IMAGE) {
+      return !!item.thumbnailUrl;
+    }
+    if (item.type === FileType.VIDEO) {
+      return !!item.thumbnailUrl;
+    }
+    return false;
+  };
+  const handleVideoHover = (e, isHover) => {
+    const video = e.currentTarget;
+    if (isHover) {
+      video.play().catch(() => {
+      });
+    } else {
+      video.pause();
+      video.currentTime = 0;
+    }
+  };
+  const handleRename = (item, e) => {
+    const input = e.target;
+    const newName = input.value.trim();
+    if (newName && newName !== item.name) {
+      onRename?.(item, newName);
+    } else {
+      onRenameCancel?.(item);
+    }
+  };
+  const handleEnterKey = (e) => {
+    e.currentTarget.blur();
+  };
+  const handleEscapeKey = (e) => {
+    const input = e.currentTarget;
+    const item = items.find((i) => i.id === editingId);
+    if (item) {
+      input.value = item.name;
+    }
+    input.blur();
+  };
+  return /* @__PURE__ */ jsx2("div", { className: "file-grid", onContextMenu: (e) => {
+    e.preventDefault();
+    handleEmptyContextMenu(e);
+  }, children: items.map((item) => {
+    const isSelected = selectedIds.has(item.id);
+    const isEditing = editingId === item.id;
+    const isDragOver = dragOverId === item.id;
+    const hasThumb = hasThumbnail(item);
+    const appIconUrl = item.type === FileType.APPLICATION ? getAppIconUrl?.(item) : void 0;
+    let itemClassName = "file-grid-item";
+    if (isSelected && !isEditing) {
+      itemClassName += " file-grid-item--selected";
+    } else if (isDragOver) {
+      itemClassName += " file-grid-item--drag-over";
+    } else {
+      itemClassName += " file-grid-item--normal";
+    }
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        draggable: !isEditing,
+        onDragStart: (e) => onDragStart?.(e, item),
+        onDragOver: (e) => {
+          e.preventDefault();
+          onDragOver?.(e, item);
+        },
+        onDragLeave: (e) => onDragLeave?.(e),
+        onDrop: (e) => {
+          e.preventDefault();
+          onDrop?.(e, item);
+        },
+        onClick: (e) => {
+          e.stopPropagation();
+          onSelect?.(item, e);
+        },
+        onDoubleClick: (e) => {
+          e.stopPropagation();
+          onOpen?.(item);
+        },
+        onContextMenu: (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+          onContextMenu?.(item, e);
+        },
+        className: itemClassName,
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "file-grid-item-icon", children: [
+            appIconUrl && /* @__PURE__ */ jsx2(
+              "img",
+              {
+                src: appIconUrl,
+                alt: item.name,
+                className: `file-grid-item-thumbnail file-grid-item-thumbnail--application ${isSelected && !isEditing ? "file-grid-item-thumbnail--selected" : ""}`
+              }
+            ),
+            !appIconUrl && item.type === FileType.VIDEO && item.thumbnailUrl && hasThumb && /* @__PURE__ */ jsxs("div", { className: "file-grid-item-thumbnail file-grid-item-thumbnail--video", children: [
+              /* @__PURE__ */ jsx2(
+                "img",
+                {
+                  src: item.thumbnailUrl,
+                  alt: item.name,
+                  className: "file-grid-item-thumbnail",
+                  onError: (e) => onThumbnailError?.(item, e)
+                }
+              ),
+              /* @__PURE__ */ jsx2("div", { className: "file-grid-item-video-play", children: /* @__PURE__ */ jsx2("div", { className: "file-grid-item-video-play-icon" }) })
+            ] }),
+            !appIconUrl && item.type === FileType.IMAGE && item.thumbnailUrl && hasThumb && /* @__PURE__ */ jsx2(
+              "img",
+              {
+                src: item.thumbnailUrl,
+                alt: item.name,
+                className: "file-grid-item-thumbnail",
+                onError: (e) => onThumbnailError?.(item, e)
+              }
+            ),
+            !appIconUrl && !hasThumb && /* @__PURE__ */ jsx2(FileIcon, { type: item.type, name: item.name, size: 48 })
+          ] }),
+          /* @__PURE__ */ jsx2("div", { className: "file-grid-item-name-wrapper", children: isEditing ? /* @__PURE__ */ jsx2(
+            "input",
+            {
+              ref: renameInputRef,
+              type: "text",
+              className: "file-grid-item-rename-input",
+              defaultValue: item.name,
+              onBlur: (e) => handleRename(item, e),
+              onKeyDown: (e) => {
+                if (e.key === "Enter") {
+                  handleEnterKey(e);
+                } else if (e.key === "Escape") {
+                  handleEscapeKey(e);
+                }
+              },
+              autoFocus: true
+            }
+          ) : /* @__PURE__ */ jsx2(
+            FileName,
+            {
+              name: item.name,
+              isFolder: item.type === FileType.FOLDER,
+              isSelected,
+              onClick: (e) => {
+                e.stopPropagation();
+                onNameClick?.(item, e);
+              }
+            }
+          ) })
+        ]
+      },
+      item.id
+    );
+  }) });
+}
+
+// src/components/FileList.tsx
+import { useRef as useRef2 } from "react";
+
+// src/components/SortIndicator.tsx
+import { Icon as Icon2 } from "@iconify/react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function SortIndicator({ direction }) {
+  return /* @__PURE__ */ jsx3("span", { className: "sort-indicator", children: /* @__PURE__ */ jsx3(
+    Icon2,
+    {
+      icon: direction === "asc" ? "lucide:chevron-up" : "lucide:chevron-down",
+      width: 12,
+      height: 12
+    }
+  ) });
+}
+
+// src/components/FileList.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function getTypeLabel(type) {
+  const labels = {
+    [FileType.FOLDER]: "\u6587\u4EF6\u5939",
+    [FileType.FILE]: "\u6587\u4EF6",
+    [FileType.IMAGE]: "\u56FE\u7247",
+    [FileType.VIDEO]: "\u89C6\u9891",
+    [FileType.MUSIC]: "\u97F3\u9891",
+    [FileType.DOCUMENT]: "\u6587\u6863",
+    [FileType.CODE]: "\u4EE3\u7801",
+    [FileType.TEXT]: "\u6587\u672C",
+    [FileType.PDF]: "PDF",
+    [FileType.ARCHIVE]: "\u538B\u7F29\u5305",
+    [FileType.APPLICATION]: "\u5E94\u7528\u7A0B\u5E8F",
+    [FileType.UNKNOWN]: "\u672A\u77E5"
+  };
+  return labels[type] || type;
+}
+function FileList({
+  items,
+  selectedIds,
+  sortConfig,
+  editingId,
+  dragOverId,
+  onSelect,
+  onOpen,
+  onContextMenu,
+  onContextMenuEmpty,
+  onNameClick,
+  onRename,
+  onRenameCancel,
+  onSort,
+  onDragStart,
+  onDragOver,
+  onDragLeave,
+  onDrop
+}) {
+  const renameInputRef = useRef2(null);
+  const handleEmptyContextMenu = (e) => {
+    const target = e.target;
+    if (!target.closest("tr")) {
+      onContextMenuEmpty?.(e);
+    }
+  };
+  const handleRename = (item, e) => {
+    const input = e.target;
+    const newName = input.value.trim();
+    if (newName && newName !== item.name) {
+      onRename?.(item, newName);
+    } else {
+      onRenameCancel?.(item);
+    }
+  };
+  const handleEnterKey = (e) => {
+    e.currentTarget.blur();
+  };
+  const handleEscapeKey = (e) => {
+    const input = e.currentTarget;
+    const item = items.find((i) => i.id === editingId);
+    if (item) {
+      input.value = item.name;
+    }
+    input.blur();
+  };
+  return /* @__PURE__ */ jsx4("div", { className: "file-list", onContextMenu: (e) => {
+    e.preventDefault();
+    handleEmptyContextMenu(e);
+  }, children: /* @__PURE__ */ jsxs2("table", { className: "file-list-table", children: [
+    /* @__PURE__ */ jsx4("thead", { className: "file-list-header", children: /* @__PURE__ */ jsxs2("tr", { children: [
+      /* @__PURE__ */ jsxs2(
+        "th",
+        {
+          className: "file-list-header-cell file-list-header-cell--name",
+          onClick: () => onSort?.("name"),
+          children: [
+            "\u540D\u79F0",
+            sortConfig?.field === "name" && /* @__PURE__ */ jsx4(SortIndicator, { direction: sortConfig.direction })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "th",
+        {
+          className: "file-list-header-cell",
+          onClick: () => onSort?.("dateModified"),
+          children: [
+            "\u4FEE\u6539\u65E5\u671F",
+            sortConfig?.field === "dateModified" && /* @__PURE__ */ jsx4(SortIndicator, { direction: sortConfig.direction })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "th",
+        {
+          className: "file-list-header-cell",
+          onClick: () => onSort?.("size"),
+          children: [
+            "\u5927\u5C0F",
+            sortConfig?.field === "size" && /* @__PURE__ */ jsx4(SortIndicator, { direction: sortConfig.direction })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "th",
+        {
+          className: "file-list-header-cell",
+          onClick: () => onSort?.("type"),
+          children: [
+            "\u7C7B\u578B",
+            sortConfig?.field === "type" && /* @__PURE__ */ jsx4(SortIndicator, { direction: sortConfig.direction })
+          ]
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx4("tbody", { className: "file-list-body", children: items.map((item, index) => {
+      const isSelected = selectedIds.has(item.id);
+      const isEditing = editingId === item.id;
+      const isDragOver = dragOverId === item.id;
+      let rowClassName = "file-list-row";
+      if (isSelected) {
+        rowClassName += " file-list-row--selected";
+      } else if (isDragOver) {
+        rowClassName += " file-list-row--drag-over";
+      } else if (index % 2 === 0) {
+        rowClassName += " file-list-row--even";
+      } else {
+        rowClassName += " file-list-row--odd";
+      }
+      return /* @__PURE__ */ jsxs2(
+        "tr",
+        {
+          draggable: !isEditing,
+          onDragStart: (e) => onDragStart?.(e, item),
+          onDragOver: (e) => {
+            e.preventDefault();
+            onDragOver?.(e, item);
+          },
+          onDragLeave: (e) => onDragLeave?.(e),
+          onDrop: (e) => {
+            e.preventDefault();
+            onDrop?.(e, item);
+          },
+          onClick: (e) => {
+            e.stopPropagation();
+            onSelect?.(item, e);
+          },
+          onDoubleClick: (e) => {
+            e.stopPropagation();
+            onOpen?.(item);
+          },
+          onContextMenu: (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            onContextMenu?.(item, e);
+          },
+          className: rowClassName,
+          children: [
+            /* @__PURE__ */ jsxs2("td", { className: `file-list-cell file-list-cell--name ${isSelected ? "file-list-cell--selected" : ""}`, children: [
+              /* @__PURE__ */ jsx4(FileIcon, { type: item.type, name: item.name, size: 16 }),
+              isEditing ? /* @__PURE__ */ jsx4(
+                "input",
+                {
+                  ref: renameInputRef,
+                  type: "text",
+                  className: "file-list-rename-input",
+                  defaultValue: item.name,
+                  onBlur: (e) => handleRename(item, e),
+                  onKeyDown: (e) => {
+                    if (e.key === "Enter") {
+                      handleEnterKey(e);
+                    } else if (e.key === "Escape") {
+                      handleEscapeKey(e);
+                    }
+                  },
+                  autoFocus: true
+                }
+              ) : /* @__PURE__ */ jsx4(
+                "span",
+                {
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    onNameClick?.(item, e);
+                  },
+                  className: `file-list-name ${isSelected ? "file-list-name--selected" : ""}`,
+                  children: item.name
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx4("td", { className: `file-list-cell ${isSelected ? "file-list-cell--selected" : ""}`, children: item.dateModified || "--" }),
+            /* @__PURE__ */ jsx4("td", { className: `file-list-cell file-list-cell--size ${isSelected ? "file-list-cell--selected" : ""}`, children: item.size || "--" }),
+            /* @__PURE__ */ jsx4("td", { className: `file-list-cell ${isSelected ? "file-list-cell--selected" : ""}`, children: getTypeLabel(item.type) })
+          ]
+        },
+        item.id
+      );
+    }) })
+  ] }) });
+}
+
+// src/components/FileListView.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var FileListView = forwardRef(
+  ({
+    items,
+    viewMode = "grid",
+    loading = false,
+    adapter,
+    currentPath,
+    getAppIconUrl,
+    onOpen,
+    onSelectionChange,
+    onContextMenu,
+    onContextMenuEmpty,
+    onRename,
+    onSortChange,
+    onMove
+  }, ref) => {
+    const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+    const [editingId, setEditingId] = useState(null);
+    const [dragOverId, setDragOverId] = useState(null);
+    const [sortConfig, setSortConfig] = useState({
+      field: "name",
+      direction: "asc"
+    });
+    const selectedItems = items.filter((item) => selectedIds.has(item.id));
+    const handleSelect = useCallback(
+      (item, e) => {
+        if (e.metaKey || e.ctrlKey) {
+          setSelectedIds((prev) => {
+            const newSet = new Set(prev);
+            if (newSet.has(item.id)) {
+              newSet.delete(item.id);
+            } else {
+              newSet.add(item.id);
+            }
+            const newItems = items.filter((i) => newSet.has(i.id));
+            onSelectionChange?.(newSet, newItems);
+            return newSet;
+          });
+        } else if (e.shiftKey && selectedIds.size > 0) {
+          const lastId = Array.from(selectedIds).pop();
+          const lastIndex = items.findIndex((i) => i.id === lastId);
+          const currentIndex = items.findIndex((i) => i.id === item.id);
+          const start = Math.min(lastIndex, currentIndex);
+          const end = Math.max(lastIndex, currentIndex);
+          const newSet = /* @__PURE__ */ new Set();
+          for (let i = start; i <= end; i++) {
+            newSet.add(items[i].id);
+          }
+          setSelectedIds(newSet);
+          const newItems = items.filter((i) => newSet.has(i.id));
+          onSelectionChange?.(newSet, newItems);
+        } else {
+          const newSet = /* @__PURE__ */ new Set([item.id]);
+          setSelectedIds(newSet);
+          onSelectionChange?.(newSet, [item]);
+        }
+      },
+      [items, selectedIds, onSelectionChange]
+    );
+    const handleEmptyClick = useCallback(
+      (e) => {
+        if (e.target === e.currentTarget) {
+          clearSelection();
+        }
+      },
+      []
+    );
+    const clearSelection = useCallback(() => {
+      setSelectedIds(/* @__PURE__ */ new Set());
+      onSelectionChange?.(/* @__PURE__ */ new Set(), []);
+    }, [onSelectionChange]);
+    const handleOpen = useCallback(
+      (item) => {
+        onOpen?.(item);
+      },
+      [onOpen]
+    );
+    const handleContextMenu = useCallback(
+      (item, e) => {
+        if (!selectedIds.has(item.id)) {
+          const newSet = /* @__PURE__ */ new Set([item.id]);
+          setSelectedIds(newSet);
+          onSelectionChange?.(newSet, [item]);
+        }
+        onContextMenu?.(e, item);
+      },
+      [selectedIds, onSelectionChange, onContextMenu]
+    );
+    const handleEmptyContextMenu = useCallback(
+      (e) => {
+        const target = e.target;
+        if (!target.closest(".file-grid-item") && !target.closest(".file-list-row")) {
+          clearSelection();
+          onContextMenuEmpty?.(e);
+        }
+      },
+      [clearSelection, onContextMenuEmpty]
+    );
+    const handleEmptyContextMenuFromChild = useCallback(
+      (e) => {
+        clearSelection();
+        onContextMenuEmpty?.(e);
+      },
+      [clearSelection, onContextMenuEmpty]
+    );
+    const handleNameClick = useCallback(
+      (item, e) => {
+        if (selectedIds.has(item.id) && selectedIds.size === 1) {
+          setTimeout(() => {
+            if (selectedIds.has(item.id)) {
+              setEditingId(item.id);
+            }
+          }, 500);
+        }
+      },
+      [selectedIds]
+    );
+    const handleRename = useCallback(
+      (item, newName) => {
+        if (newName && newName !== item.name) {
+          onRename?.(item, newName);
+        }
+        setEditingId(null);
+      },
+      [onRename]
+    );
+    const handleRenameCancel = useCallback(() => {
+      setEditingId(null);
+    }, []);
+    const handleSort = useCallback(
+      (field) => {
+        setSortConfig((prev) => {
+          const newConfig = prev.field === field ? { ...prev, direction: prev.direction === "asc" ? "desc" : "asc" } : { field, direction: "asc" };
+          onSortChange?.(newConfig);
+          return newConfig;
+        });
+      },
+      [onSortChange]
+    );
+    const handleDragStart = useCallback(
+      (e, item) => {
+        if (!selectedIds.has(item.id)) {
+          const newSet = /* @__PURE__ */ new Set([item.id]);
+          setSelectedIds(newSet);
+          onSelectionChange?.(newSet, [item]);
+        }
+        e.dataTransfer.setData(
+          "text/plain",
+          JSON.stringify([...selectedIds])
+        );
+      },
+      [selectedIds, onSelectionChange]
+    );
+    const handleDragOver = useCallback(
+      (e, item) => {
+        if (item.type === FileType.FOLDER && !selectedIds.has(item.id)) {
+          setDragOverId(item.id);
+        }
+      },
+      [selectedIds]
+    );
+    const handleDragLeave = useCallback(() => {
+      setDragOverId(null);
+    }, []);
+    const handleDrop = useCallback(
+      (e, targetItem) => {
+        setDragOverId(null);
+        if (targetItem.type !== FileType.FOLDER) return;
+        const data = e.dataTransfer.getData("text/plain");
+        if (!data) return;
+        try {
+          const draggedIds = JSON.parse(data);
+          if (draggedIds.includes(targetItem.id)) return;
+          onMove?.(draggedIds, targetItem.id);
+          clearSelection();
+        } catch (error) {
+          console.error("\u62D6\u62FD\u89E3\u6790\u5931\u8D25:", error);
+        }
+      },
+      [onMove, clearSelection]
+    );
+    const startRename = useCallback((id) => {
+      setEditingId(id);
+    }, []);
+    const selectAll = useCallback(() => {
+      const newSet = new Set(items.map((i) => i.id));
+      setSelectedIds(newSet);
+      onSelectionChange?.(newSet, items);
+    }, [items, onSelectionChange]);
+    useImperativeHandle(
+      ref,
+      () => ({
+        clearSelection,
+        startRename,
+        selectAll,
+        selectedIds,
+        selectedItems
+      }),
+      [selectedIds, selectedItems, clearSelection, startRename, selectAll]
+    );
+    return /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        className: "file-list-view",
+        onClick: handleEmptyClick,
+        onContextMenu: (e) => {
+          e.preventDefault();
+          handleEmptyContextMenu(e);
+        },
+        children: [
+          loading && /* @__PURE__ */ jsxs3("div", { className: "file-list-view-loading", children: [
+            /* @__PURE__ */ jsx5("div", { className: "file-list-view-spinner" }),
+            /* @__PURE__ */ jsx5("p", { children: "\u52A0\u8F7D\u4E2D..." })
+          ] }),
+          !loading && items.length === 0 && /* @__PURE__ */ jsxs3("div", { className: "file-list-view-empty", children: [
+            /* @__PURE__ */ jsx5(Icon3, { icon: "lucide:folder-open", width: 64, height: 64, className: "file-list-view-empty-icon" }),
+            /* @__PURE__ */ jsx5("p", { children: "\u6587\u4EF6\u5939\u4E3A\u7A7A" })
+          ] }),
+          !loading && items.length > 0 && viewMode === "grid" && /* @__PURE__ */ jsx5(
+            FileGrid,
+            {
+              items,
+              selectedIds,
+              editingId,
+              dragOverId,
+              getAppIconUrl,
+              onSelect: handleSelect,
+              onOpen: handleOpen,
+              onContextMenu: handleContextMenu,
+              onContextMenuEmpty: handleEmptyContextMenuFromChild,
+              onNameClick: handleNameClick,
+              onRename: handleRename,
+              onRenameCancel: handleRenameCancel,
+              onDragStart: handleDragStart,
+              onDragOver: handleDragOver,
+              onDragLeave: handleDragLeave,
+              onDrop: handleDrop
+            }
+          ),
+          !loading && items.length > 0 && viewMode === "list" && /* @__PURE__ */ jsx5(
+            FileList,
+            {
+              items,
+              selectedIds,
+              editingId,
+              dragOverId,
+              sortConfig,
+              onSelect: handleSelect,
+              onOpen: handleOpen,
+              onContextMenu: handleContextMenu,
+              onContextMenuEmpty: handleEmptyContextMenuFromChild,
+              onNameClick: handleNameClick,
+              onRename: handleRename,
+              onRenameCancel: handleRenameCancel,
+              onSort: handleSort,
+              onDragStart: handleDragStart,
+              onDragOver: handleDragOver,
+              onDragLeave: handleDragLeave,
+              onDrop: handleDrop
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+FileListView.displayName = "FileListView";
+
+// src/components/FileSidebar.tsx
+import { Icon as Icon4 } from "@iconify/react";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function FileSidebar({ sections, activeId, onNavigate }) {
+  const handleNavigate = (item) => {
+    onNavigate?.(item);
+  };
+  const getIconName = (iconName) => {
+    if (!iconName) return "mdi:folder";
+    if (iconName.includes(":")) return iconName;
+    return `lucide:${iconName.toLowerCase()}`;
+  };
+  return /* @__PURE__ */ jsx6("div", { className: "file-sidebar", children: sections.map((section) => /* @__PURE__ */ jsxs4("div", { className: "file-sidebar-section", children: [
+    /* @__PURE__ */ jsx6("div", { className: "file-sidebar-section-title", children: section.title }),
+    /* @__PURE__ */ jsx6("ul", { className: "file-sidebar-list", children: section.items.map((item) => {
+      const isActive = activeId === item.id;
+      return /* @__PURE__ */ jsxs4(
+        "li",
+        {
+          onClick: () => handleNavigate(item),
+          className: `file-sidebar-item ${isActive ? "file-sidebar-item--active" : ""}`,
+          children: [
+            /* @__PURE__ */ jsx6(
+              Icon4,
+              {
+                icon: getIconName(item.icon),
+                width: 18,
+                height: 18,
+                className: isActive ? "file-sidebar-item-icon--active" : "file-sidebar-item-icon"
+              }
+            ),
+            /* @__PURE__ */ jsx6("span", { children: item.label })
+          ]
+        },
+        item.id
+      );
+    }) })
+  ] }, section.id)) });
+}
+
+// src/components/Toolbar.tsx
+import { Icon as Icon6 } from "@iconify/react";
+
+// src/components/Breadcrumb.tsx
+import { Icon as Icon5 } from "@iconify/react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function Breadcrumb({ items, onNavigate }) {
+  const handleClick = (item, index) => {
+    if (index < items.length - 1) {
+      onNavigate?.(item, index);
+    }
+  };
+  return /* @__PURE__ */ jsx7("div", { className: "file-breadcrumb", children: items.map((item, index) => /* @__PURE__ */ jsxs5("span", { className: "file-breadcrumb-item", children: [
+    /* @__PURE__ */ jsx7(
+      "span",
+      {
+        onClick: () => handleClick(item, index),
+        className: `file-breadcrumb-link ${index === items.length - 1 ? "file-breadcrumb-link--current" : ""}`,
+        children: item.name
+      }
+    ),
+    index < items.length - 1 && /* @__PURE__ */ jsx7(Icon5, { icon: "lucide:chevron-right", width: 14, height: 14, className: "file-breadcrumb-separator" })
+  ] }, item.id)) });
+}
+
+// src/components/Toolbar.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function Toolbar({
+  canGoBack = false,
+  canGoForward = false,
+  breadcrumbs = [],
+  viewMode = "grid",
+  searchQuery = "",
+  showSearch = false,
+  showViewToggle = true,
+  draggable = false,
+  onBack,
+  onForward,
+  onBreadcrumbNavigate,
+  onViewModeChange,
+  onSearchQueryChange,
+  children,
+  breadcrumbSlot,
+  actionsSlot
+}) {
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      className: `file-toolbar ${draggable ? "file-toolbar--draggable" : ""}`,
+      children: [
+        /* @__PURE__ */ jsxs6("div", { className: "file-toolbar-nav", children: [
+          /* @__PURE__ */ jsx8(
+            "button",
+            {
+              className: "file-toolbar-button",
+              onClick: onBack,
+              disabled: !canGoBack,
+              title: "\u540E\u9000",
+              children: /* @__PURE__ */ jsx8(Icon6, { icon: "lucide:chevron-left", width: 18, height: 18 })
+            }
+          ),
+          /* @__PURE__ */ jsx8(
+            "button",
+            {
+              className: "file-toolbar-button",
+              onClick: onForward,
+              disabled: !canGoForward,
+              title: "\u524D\u8FDB",
+              children: /* @__PURE__ */ jsx8(Icon6, { icon: "lucide:chevron-right", width: 18, height: 18 })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx8("div", { className: "file-toolbar-breadcrumb", children: breadcrumbSlot || breadcrumbs.length > 0 && /* @__PURE__ */ jsx8(
+          Breadcrumb,
+          {
+            items: breadcrumbs,
+            onNavigate: onBreadcrumbNavigate
+          }
+        ) }),
+        children && /* @__PURE__ */ jsx8("div", { className: "file-toolbar-custom", children }),
+        /* @__PURE__ */ jsxs6("div", { className: "file-toolbar-actions", children: [
+          showSearch && /* @__PURE__ */ jsxs6("div", { className: "file-toolbar-search", children: [
+            /* @__PURE__ */ jsx8(Icon6, { icon: "lucide:search", width: 16, height: 16, className: "file-toolbar-search-icon" }),
+            /* @__PURE__ */ jsx8(
+              "input",
+              {
+                type: "text",
+                value: searchQuery,
+                onChange: (e) => onSearchQueryChange?.(e.target.value),
+                placeholder: "\u641C\u7D22",
+                className: "file-toolbar-search-input"
+              }
+            )
+          ] }),
+          showViewToggle && /* @__PURE__ */ jsxs6("div", { className: "file-toolbar-view-toggle", children: [
+            /* @__PURE__ */ jsx8(
+              "button",
+              {
+                onClick: () => onViewModeChange?.("grid"),
+                className: `file-toolbar-button ${viewMode === "grid" ? "file-toolbar-button--active" : ""}`,
+                title: "\u7F51\u683C\u89C6\u56FE",
+                children: /* @__PURE__ */ jsx8(Icon6, { icon: "lucide:layout-grid", width: 18, height: 18 })
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              "button",
+              {
+                onClick: () => onViewModeChange?.("list"),
+                className: `file-toolbar-button ${viewMode === "list" ? "file-toolbar-button--active" : ""}`,
+                title: "\u5217\u8868\u89C6\u56FE",
+                children: /* @__PURE__ */ jsx8(Icon6, { icon: "lucide:list", width: 18, height: 18 })
+              }
+            )
+          ] }),
+          actionsSlot
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/StatusBar.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function StatusBar({ itemCount = 0, selectedCount = 0, children }) {
+  return /* @__PURE__ */ jsx9("div", { className: "file-status-bar", children: children || /* @__PURE__ */ jsxs7(Fragment2, { children: [
+    /* @__PURE__ */ jsxs7("span", { children: [
+      itemCount,
+      " \u4E2A\u9879\u76EE"
+    ] }),
+    selectedCount > 0 && /* @__PURE__ */ jsxs7("span", { children: [
+      " \u2022 \u5DF2\u9009\u62E9 ",
+      selectedCount,
+      " \u4E2A"
+    ] })
+  ] }) });
+}
+
+// src/components/ContextMenu.tsx
+import { createPortal } from "react-dom";
+import { useMemo as useMemo3, useEffect, useRef as useRef3, useCallback as useCallback2, useState as useState2 } from "react";
+import { Icon as Icon7 } from "@iconify/react";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var MARGIN = 8;
+var MENU_WIDTH = 220;
+var MENU_ITEM_HEIGHT = 32;
+var SEPARATOR_HEIGHT = 9;
+var MENU_PADDING = 8;
+var SUBMENU_GAP = 0;
+function estimateMenuHeight(items) {
+  let height = MENU_PADDING;
+  for (const item of items) {
+    height += item.separator ? SEPARATOR_HEIGHT : MENU_ITEM_HEIGHT;
+  }
+  return height;
+}
+function calculateMenuPosition(clickX, clickY, menuHeight) {
+  const viewportWidth = window.innerWidth;
+  const viewportHeight = window.innerHeight;
+  let adjustedX = clickX;
+  let adjustedY = clickY;
+  const spaceRight = viewportWidth - clickX;
+  const spaceLeft = clickX;
+  if (spaceRight < MENU_WIDTH + MARGIN) {
+    if (spaceLeft >= MENU_WIDTH + MARGIN) {
+      adjustedX = clickX - MENU_WIDTH;
+    } else {
+      if (spaceRight > spaceLeft) {
+        adjustedX = viewportWidth - MENU_WIDTH - MARGIN;
+      } else {
+        adjustedX = MARGIN;
+      }
+    }
+  }
+  const spaceBottom = viewportHeight - clickY;
+  const spaceTop = clickY;
+  if (spaceBottom < menuHeight + MARGIN) {
+    if (spaceTop >= menuHeight + MARGIN) {
+      adjustedY = clickY - menuHeight;
+    } else {
+      if (spaceBottom > spaceTop) {
+        adjustedY = viewportHeight - menuHeight - MARGIN;
+      } else {
+        adjustedY = MARGIN;
+      }
+    }
+  }
+  adjustedX = Math.max(MARGIN, Math.min(adjustedX, viewportWidth - MENU_WIDTH - MARGIN));
+  adjustedY = Math.max(MARGIN, Math.min(adjustedY, viewportHeight - menuHeight - MARGIN));
+  return { x: adjustedX, y: adjustedY };
+}
+function calculateSubmenuPosition(parentRect, submenuHeight) {
+  const viewportWidth = window.innerWidth;
+  const viewportHeight = window.innerHeight;
+  const spaceRight = viewportWidth - parentRect.right;
+  const spaceLeft = parentRect.left;
+  let submenuX;
+  let submenuY;
+  if (spaceRight >= MENU_WIDTH + SUBMENU_GAP + MARGIN) {
+    submenuX = parentRect.right + SUBMENU_GAP;
+  } else if (spaceLeft >= MENU_WIDTH + SUBMENU_GAP + MARGIN) {
+    submenuX = parentRect.left - MENU_WIDTH - SUBMENU_GAP;
+  } else {
+    if (spaceRight > spaceLeft) {
+      submenuX = viewportWidth - MENU_WIDTH - MARGIN;
+    } else {
+      submenuX = MARGIN;
+    }
+  }
+  submenuY = parentRect.top;
+  if (submenuY + submenuHeight > viewportHeight - MARGIN) {
+    submenuY = viewportHeight - submenuHeight - MARGIN;
+  }
+  if (submenuY < MARGIN) {
+    submenuY = MARGIN;
+  }
+  return { x: submenuX, y: submenuY };
+}
+function ContextMenu({
+  visible,
+  x,
+  y,
+  options,
+  onClose,
+  onSelect
+}) {
+  const menuRef = useRef3(null);
+  const [hoveredItemId, setHoveredItemId] = useState2(null);
+  const [submenuPosition, setSubmenuPosition] = useState2(null);
+  const itemRefs = useRef3(/* @__PURE__ */ new Map());
+  const position = useMemo3(() => {
+    const estimatedHeight = estimateMenuHeight(options);
+    return calculateMenuPosition(x, y, estimatedHeight);
+  }, [x, y, options]);
+  const menuStyle = useMemo3(
+    () => ({
+      left: `${position.x}px`,
+      top: `${position.y}px`
+    }),
+    [position]
+  );
+  const hoveredItem = useMemo3(() => {
+    if (!hoveredItemId) return null;
+    return options.find((opt) => opt.id === hoveredItemId && opt.children && opt.children.length > 0);
+  }, [hoveredItemId, options]);
+  useEffect(() => {
+    if (!hoveredItemId || !hoveredItem) {
+      setSubmenuPosition(null);
+      return;
+    }
+    const itemEl = itemRefs.current.get(hoveredItemId);
+    if (!itemEl) {
+      setSubmenuPosition(null);
+      return;
+    }
+    const rect = itemEl.getBoundingClientRect();
+    const submenuHeight = estimateMenuHeight(hoveredItem.children || []);
+    const pos = calculateSubmenuPosition(rect, submenuHeight);
+    setSubmenuPosition(pos);
+  }, [hoveredItemId, hoveredItem]);
+  useEffect(() => {
+    if (!visible) return;
+    const handleClickOutside = (e) => {
+      const target = e.target;
+      const menuContainer = document.querySelector(".context-menu-container");
+      if (menuContainer && menuContainer.contains(target)) {
+        return;
+      }
+      onClose?.();
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        onClose?.();
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [visible, onClose]);
+  useEffect(() => {
+    if (!visible) {
+      setHoveredItemId(null);
+      setSubmenuPosition(null);
+    }
+  }, [visible]);
+  const renderIcon = (iconName) => {
+    if (!iconName) return null;
+    return /* @__PURE__ */ jsx10(Icon7, { icon: iconName, width: 16, height: 16, className: "context-menu-item-icon" });
+  };
+  const handleOptionClick = useCallback2(
+    (option) => {
+      if (option.disabled) return;
+      if (option.children && option.children.length > 0) {
+        return;
+      }
+      if (option.action) {
+        option.action();
+      }
+      onSelect?.(option);
+      onClose?.();
+    },
+    [onClose, onSelect]
+  );
+  const handleItemMouseEnter = useCallback2((option) => {
+    if (option.children && option.children.length > 0) {
+      setHoveredItemId(option.id);
+    } else {
+      setHoveredItemId(null);
+    }
+  }, []);
+  if (!visible) return null;
+  return createPortal(
+    /* @__PURE__ */ jsxs8("div", { className: "context-menu-container", children: [
+      /* @__PURE__ */ jsx10("div", { ref: menuRef, className: "context-menu", style: menuStyle, children: options.map((option, index) => {
+        if (option.separator) {
+          return /* @__PURE__ */ jsx10("div", { className: "context-menu-separator" }, index);
+        }
+        const hasChildren = option.children && option.children.length > 0;
+        const isHovered = hoveredItemId === option.id;
+        return /* @__PURE__ */ jsxs8(
+          "div",
+          {
+            ref: (el) => {
+              if (el) {
+                itemRefs.current.set(option.id, el);
+              } else {
+                itemRefs.current.delete(option.id);
+              }
+            },
+            className: `context-menu-item ${option.disabled ? "context-menu-item--disabled" : ""} ${option.danger ? "context-menu-item--danger" : ""} ${hasChildren ? "context-menu-item--has-children" : ""} ${isHovered ? "context-menu-item--active" : ""}`,
+            onClick: () => handleOptionClick(option),
+            onMouseEnter: () => handleItemMouseEnter(option),
+            children: [
+              option.icon && renderIcon(option.icon),
+              /* @__PURE__ */ jsx10("span", { className: "context-menu-item-label", children: option.label }),
+              option.checked && /* @__PURE__ */ jsx10(Icon7, { icon: "lucide:check", width: 14, height: 14, className: "context-menu-item-check" }),
+              option.shortcut && !hasChildren && /* @__PURE__ */ jsx10("span", { className: "context-menu-item-shortcut", children: option.shortcut }),
+              hasChildren && /* @__PURE__ */ jsx10(Icon7, { icon: "lucide:chevron-right", width: 14, height: 14, className: "context-menu-item-arrow" })
+            ]
+          },
+          option.id || index
+        );
+      }) }),
+      hoveredItem && submenuPosition && /* @__PURE__ */ jsx10(
+        "div",
+        {
+          className: "context-menu context-menu-submenu",
+          style: {
+            left: `${submenuPosition.x}px`,
+            top: `${submenuPosition.y}px`
+          },
+          onMouseEnter: () => setHoveredItemId(hoveredItem.id),
+          onMouseLeave: () => setHoveredItemId(null),
+          children: hoveredItem.children.map((child, childIndex) => {
+            if (child.separator) {
+              return /* @__PURE__ */ jsx10("div", { className: "context-menu-separator" }, `child-sep-${childIndex}`);
+            }
+            return /* @__PURE__ */ jsxs8(
+              "div",
+              {
+                className: `context-menu-item ${child.disabled ? "context-menu-item--disabled" : ""} ${child.danger ? "context-menu-item--danger" : ""}`,
+                onClick: () => handleOptionClick(child),
+                children: [
+                  child.icon && renderIcon(child.icon),
+                  /* @__PURE__ */ jsx10("span", { className: "context-menu-item-label", children: child.label }),
+                  child.checked && /* @__PURE__ */ jsx10(Icon7, { icon: "lucide:check", width: 14, height: 14, className: "context-menu-item-check" }),
+                  child.shortcut && /* @__PURE__ */ jsx10("span", { className: "context-menu-item-shortcut", children: child.shortcut })
+                ]
+              },
+              child.id || childIndex
+            );
+          })
+        }
+      )
+    ] }),
+    document.body
+  );
+}
+
+// src/components/Window.tsx
+import { createPortal as createPortal2 } from "react-dom";
+import { useMemo as useMemo4, useRef as useRef4, useEffect as useEffect4 } from "react";
+import { Icon as Icon8 } from "@iconify/react";
+
+// src/hooks/useWindowDrag.ts
+import { useState as useState3, useCallback as useCallback3, useEffect as useEffect2 } from "react";
+function useWindowDrag() {
+  const [position, setPosition] = useState3({ x: 0, y: 0 });
+  const [isDragging, setIsDragging] = useState3(false);
+  const handleMouseMove = useCallback3((e) => {
+    if (!isDragging) return;
+    setPosition((prev) => ({
+      x: prev.x + e.movementX,
+      y: prev.y + e.movementY
+    }));
+  }, [isDragging]);
+  const handleMouseUp = useCallback3(() => {
+    setIsDragging(false);
+  }, []);
+  const startDrag = useCallback3((e) => {
+    const target = e.target;
+    if (target.closest(".draggable-area") && !target.closest("button")) {
+      e.preventDefault();
+      setIsDragging(true);
+    }
+  }, []);
+  useEffect2(() => {
+    if (isDragging) {
+      window.addEventListener("mousemove", handleMouseMove);
+      window.addEventListener("mouseup", handleMouseUp);
+      return () => {
+        window.removeEventListener("mousemove", handleMouseMove);
+        window.removeEventListener("mouseup", handleMouseUp);
+      };
+    }
+  }, [isDragging, handleMouseMove, handleMouseUp]);
+  return {
+    position,
+    isDragging,
+    startDrag
+  };
+}
+
+// src/hooks/useWindowResize.ts
+import { useState as useState4, useCallback as useCallback4, useEffect as useEffect3 } from "react";
+function useWindowResize(initialWidth, initialHeight, minWidth, minHeight, maxWidth, maxHeight) {
+  const [width, setWidth] = useState4(initialWidth);
+  const [height, setHeight] = useState4(initialHeight);
+  const [isResizing, setIsResizing] = useState4(false);
+  const [resizeDirection, setResizeDirection] = useState4(null);
+  const [startX, setStartX] = useState4(0);
+  const [startY, setStartY] = useState4(0);
+  const [startWidth, setStartWidth] = useState4(0);
+  const [startHeight, setStartHeight] = useState4(0);
+  const handleMouseMove = useCallback4((e) => {
+    if (!isResizing || !resizeDirection) return;
+    const deltaX = e.clientX - startX;
+    const deltaY = e.clientY - startY;
+    let newWidth = startWidth;
+    let newHeight = startHeight;
+    const direction = resizeDirection;
+    if (direction.includes("e")) {
+      newWidth = Math.min(Math.max(startWidth + deltaX, minWidth), maxWidth);
+    } else if (direction.includes("w")) {
+      newWidth = Math.min(Math.max(startWidth - deltaX, minWidth), maxWidth);
+    }
+    if (direction.includes("s")) {
+      newHeight = Math.min(Math.max(startHeight + deltaY, minHeight), maxHeight);
+    } else if (direction.includes("n")) {
+      newHeight = Math.min(Math.max(startHeight - deltaY, minHeight), maxHeight);
+    }
+    setWidth(newWidth);
+    setHeight(newHeight);
+  }, [isResizing, resizeDirection, startX, startY, startWidth, startHeight, minWidth, minHeight, maxWidth, maxHeight]);
+  const handleMouseUp = useCallback4(() => {
+    setIsResizing(false);
+    setResizeDirection(null);
+  }, []);
+  const startResize = useCallback4((e, direction, currentWidth, currentHeight) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsResizing(true);
+    setResizeDirection(direction);
+    setStartX(e.clientX);
+    setStartY(e.clientY);
+    setStartWidth(currentWidth);
+    setStartHeight(currentHeight);
+  }, []);
+  const getCursorForDirection = useCallback4((direction) => {
+    const cursors = {
+      n: "n-resize",
+      s: "s-resize",
+      e: "e-resize",
+      w: "w-resize",
+      ne: "ne-resize",
+      nw: "nw-resize",
+      se: "se-resize",
+      sw: "sw-resize"
+    };
+    return cursors[direction];
+  }, []);
+  useEffect3(() => {
+    if (isResizing) {
+      window.addEventListener("mousemove", handleMouseMove);
+      window.addEventListener("mouseup", handleMouseUp);
+      document.body.style.cursor = getCursorForDirection(resizeDirection || "se");
+      document.body.style.userSelect = "none";
+      return () => {
+        window.removeEventListener("mousemove", handleMouseMove);
+        window.removeEventListener("mouseup", handleMouseUp);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+      };
+    }
+  }, [isResizing, resizeDirection, handleMouseMove, handleMouseUp, getCursorForDirection]);
+  return {
+    width,
+    height,
+    isResizing,
+    startResize
+  };
+}
+
+// src/components/Window.tsx
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function Window({
+  title,
+  showTitleBar = true,
+  showMinimize = false,
+  showMaximize = false,
+  draggable = true,
+  resizable = true,
+  closeOnBackdrop = true,
+  width = "auto",
+  height = "auto",
+  minWidth = 300,
+  minHeight = 200,
+  maxWidth = "80vw",
+  maxHeight = "80vh",
+  fitContent = false,
+  onClose,
+  onMinimize,
+  onMaximize,
+  children,
+  titleSlot,
+  actionsSlot
+}) {
+  const windowContainerRef = useRef4(null);
+  const windowDrag = draggable ? useWindowDrag() : null;
+  const isAutoSize = useMemo4(() => {
+    return fitContent || width === "auto" || width === "fit-content" || height === "auto" || height === "fit-content";
+  }, [fitContent, width, height]);
+  const getInitialSize = () => {
+    if (isAutoSize) {
+      return { initialWidth: 0, initialHeight: 0 };
+    }
+    const defaultWidth = 600;
+    const defaultHeight = 500;
+    let initialWidth2 = defaultWidth;
+    let initialHeight2 = defaultHeight;
+    if (width !== "auto" && width !== "fit-content") {
+      initialWidth2 = typeof width === "number" ? width : parseInt(width);
+    }
+    if (height !== "auto" && height !== "fit-content") {
+      initialHeight2 = typeof height === "number" ? height : parseInt(height);
+    }
+    return { initialWidth: initialWidth2, initialHeight: initialHeight2 };
+  };
+  const parseSize = (size, defaultPx) => {
+    if (typeof size === "number") return size;
+    if (typeof size === "string") {
+      if (size.endsWith("px")) return parseInt(size);
+      if (size.endsWith("vw"))
+        return parseInt(size) / 100 * window.innerWidth;
+      if (size.endsWith("vh"))
+        return parseInt(size) / 100 * window.innerHeight;
+    }
+    return defaultPx;
+  };
+  const { initialWidth, initialHeight } = getInitialSize();
+  const minW = parseSize(minWidth, 500);
+  const minH = parseSize(minHeight, 350);
+  const maxW = parseSize(maxWidth, window.innerWidth * 0.8);
+  const maxH = parseSize(maxHeight, window.innerHeight * 0.8);
+  const windowResize = resizable ? useWindowResize(initialWidth, initialHeight, minW, minH, maxW, maxH) : null;
+  const windowStyle = useMemo4(() => {
+    const baseStyle = {
+      left: "50%",
+      top: "50%"
+    };
+    let translateX = "-50%";
+    let translateY = "-50%";
+    if (draggable && windowDrag) {
+      translateX = `calc(-50% + ${windowDrag.position.x}px)`;
+      translateY = `calc(-50% + ${windowDrag.position.y}px)`;
+    }
+    baseStyle.transform = `translate(${translateX}, ${translateY})`;
+    baseStyle.transformOrigin = "center center";
+    if (isAutoSize) {
+      if (resizable && windowResize && windowResize.width > 0) {
+        baseStyle.width = `${windowResize.width}px`;
+        baseStyle.height = `${windowResize.height}px`;
+      }
+    } else {
+      if (resizable && windowResize) {
+        baseStyle.width = `${windowResize.width}px`;
+        baseStyle.height = `${windowResize.height}px`;
+      } else {
+        if (width !== "auto" && width !== "fit-content") {
+          baseStyle.width = typeof width === "number" ? `${width}px` : width;
+        }
+        if (height !== "auto" && height !== "fit-content") {
+          baseStyle.height = typeof height === "number" ? `${height}px` : height;
+        }
+      }
+    }
+    if (minWidth) {
+      baseStyle.minWidth = typeof minWidth === "number" ? `${minWidth}px` : minWidth;
+    }
+    if (minHeight) {
+      baseStyle.minHeight = typeof minHeight === "number" ? `${minHeight}px` : minHeight;
+    }
+    if (maxWidth) {
+      baseStyle.maxWidth = typeof maxWidth === "number" ? `${maxWidth}px` : maxWidth;
+    }
+    if (maxHeight) {
+      baseStyle.maxHeight = typeof maxHeight === "number" ? `${maxHeight}px` : maxHeight;
+    }
+    return baseStyle;
+  }, [
+    draggable,
+    windowDrag,
+    isAutoSize,
+    resizable,
+    windowResize,
+    width,
+    height,
+    minWidth,
+    minHeight,
+    maxWidth,
+    maxHeight
+  ]);
+  const handleBackdropClick = (e) => {
+    if (closeOnBackdrop && e.target === e.currentTarget) {
+      onClose?.();
+    }
+  };
+  const handleDragStart = (e) => {
+    if (draggable && windowDrag) {
+      windowDrag.startDrag(e);
+    }
+  };
+  const handleResizeStart = (e, direction) => {
+    if (!resizable || !windowResize || !windowContainerRef.current) return;
+    const rect = windowContainerRef.current.getBoundingClientRect();
+    const currentWidth = rect.width;
+    const currentHeight = rect.height;
+    windowResize.startResize(e, direction, currentWidth, currentHeight);
+  };
+  useEffect4(() => {
+    const handleEsc = (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        onClose?.();
+      }
+    };
+    window.addEventListener("keydown", handleEsc);
+    return () => {
+      window.removeEventListener("keydown", handleEsc);
+    };
+  }, [onClose]);
+  return createPortal2(
+    /* @__PURE__ */ jsx11("div", { className: "window-overlay", onClick: handleBackdropClick, children: /* @__PURE__ */ jsxs9(
+      "div",
+      {
+        ref: windowContainerRef,
+        className: "window-container",
+        style: windowStyle,
+        onClick: (e) => e.stopPropagation(),
+        children: [
+          showTitleBar && /* @__PURE__ */ jsxs9(
+            "div",
+            {
+              className: "window-title-bar draggable-area",
+              onMouseDown: handleDragStart,
+              children: [
+                /* @__PURE__ */ jsxs9("div", { className: "window-controls", children: [
+                  /* @__PURE__ */ jsx11(
+                    "button",
+                    {
+                      onClick: (e) => {
+                        e.stopPropagation();
+                        onClose?.();
+                      },
+                      className: "window-control-button window-control-button--close",
+                      children: /* @__PURE__ */ jsx11(Icon8, { icon: "lucide:x", width: 7, height: 7, className: "window-control-icon" })
+                    }
+                  ),
+                  showMinimize && /* @__PURE__ */ jsx11(
+                    "button",
+                    {
+                      onClick: (e) => {
+                        e.stopPropagation();
+                        onMinimize?.();
+                      },
+                      className: "window-control-button window-control-button--minimize",
+                      children: /* @__PURE__ */ jsx11(Icon8, { icon: "lucide:minus", width: 7, height: 7, className: "window-control-icon" })
+                    }
+                  ),
+                  showMaximize && /* @__PURE__ */ jsx11(
+                    "button",
+                    {
+                      onClick: (e) => {
+                        e.stopPropagation();
+                        onMaximize?.();
+                      },
+                      className: "window-control-button window-control-button--maximize",
+                      children: /* @__PURE__ */ jsx11(Icon8, { icon: "lucide:maximize-2", width: 7, height: 7, className: "window-control-icon" })
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsx11("div", { className: "window-title-info", children: titleSlot || /* @__PURE__ */ jsx11("span", { className: "window-title-text", children: title }) }),
+                /* @__PURE__ */ jsx11("div", { className: "window-title-actions", children: actionsSlot })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx11("div", { className: "window-content", children }),
+          resizable && /* @__PURE__ */ jsxs9(Fragment3, { children: [
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--n",
+                onMouseDown: (e) => handleResizeStart(e, "n")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--s",
+                onMouseDown: (e) => handleResizeStart(e, "s")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--e",
+                onMouseDown: (e) => handleResizeStart(e, "e")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--w",
+                onMouseDown: (e) => handleResizeStart(e, "w")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--ne",
+                onMouseDown: (e) => handleResizeStart(e, "ne")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--nw",
+                onMouseDown: (e) => handleResizeStart(e, "nw")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--se",
+                onMouseDown: (e) => handleResizeStart(e, "se")
+              }
+            ),
+            /* @__PURE__ */ jsx11(
+              "div",
+              {
+                className: "window-resize-handle window-resize-handle--sw",
+                onMouseDown: (e) => handleResizeStart(e, "sw")
+              }
+            )
+          ] })
+        ]
+      }
+    ) }),
+    document.body
+  );
+}
+
+// src/components/CompressDialog.tsx
+import { useState as useState6, useMemo as useMemo5, useEffect as useEffect5 } from "react";
+import { createPortal as createPortal3 } from "react-dom";
+import { Icon as Icon9 } from "@iconify/react";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+var FORMAT_OPTIONS = [
+  { value: "zip", label: "ZIP", ext: ".zip" },
+  { value: "tgz", label: "TAR.GZ (gzip)", ext: ".tar.gz" },
+  { value: "tarbz2", label: "TAR.BZ2 (bzip2)", ext: ".tar.bz2" },
+  { value: "tar", label: "TAR (\u65E0\u538B\u7F29)", ext: ".tar" }
+];
+var LEVEL_OPTIONS = [
+  { value: "fast", label: "\u5FEB\u901F", desc: "\u538B\u7F29\u901F\u5EA6\u5FEB\uFF0C\u6587\u4EF6\u8F83\u5927" },
+  { value: "normal", label: "\u6807\u51C6", desc: "\u5E73\u8861\u901F\u5EA6\u548C\u5927\u5C0F" },
+  { value: "best", label: "\u6700\u4F73", desc: "\u6587\u4EF6\u6700\u5C0F\uFF0C\u901F\u5EA6\u8F83\u6162" }
+];
+function CompressDialog({
+  visible,
+  filePaths,
+  outputDir,
+  onConfirm,
+  onCancel
+}) {
+  const [format, setFormat] = useState6("zip");
+  const [level, setLevel] = useState6("normal");
+  const [outputName, setOutputName] = useState6("");
+  const [deleteSource, setDeleteSource] = useState6(false);
+  const [password, setPassword] = useState6("");
+  const [showPassword, setShowPassword] = useState6(false);
+  const defaultOutputName = useMemo5(() => {
+    if (filePaths.length === 0) return "archive";
+    if (filePaths.length === 1) {
+      const name = filePaths[0].split("/").pop() || "archive";
+      return name.replace(/\.[^.]+$/, "");
+    }
+    return "\u538B\u7F29\u6587\u4EF6";
+  }, [filePaths]);
+  useEffect5(() => {
+    if (visible) {
+      setOutputName(defaultOutputName);
+      setFormat("zip");
+      setLevel("normal");
+      setDeleteSource(false);
+      setPassword("");
+    }
+  }, [visible, defaultOutputName]);
+  const currentExt = FORMAT_OPTIONS.find((f) => f.value === format)?.ext || ".zip";
+  const fullOutputPath = `${outputDir}/${outputName}${currentExt}`;
+  const handleConfirm = () => {
+    onConfirm({
+      format,
+      level,
+      outputName: outputName + currentExt,
+      deleteSource
+    });
+  };
+  const supportsPassword = false;
+  if (!visible) return null;
+  return createPortal3(
+    /* @__PURE__ */ jsx12("div", { className: "compress-dialog-overlay", onClick: onCancel, children: /* @__PURE__ */ jsxs10("div", { className: "compress-dialog", onClick: (e) => e.stopPropagation(), children: [
+      /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-header", children: [
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-title", children: [
+          /* @__PURE__ */ jsx12(Icon9, { icon: "lucide:archive", width: 20, height: 20 }),
+          /* @__PURE__ */ jsx12("span", { children: "\u538B\u7F29\u6587\u4EF6" })
+        ] }),
+        /* @__PURE__ */ jsx12("button", { className: "compress-dialog-close", onClick: onCancel, children: /* @__PURE__ */ jsx12(Icon9, { icon: "lucide:x", width: 18, height: 18 }) })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-content", children: [
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-info", children: [
+          /* @__PURE__ */ jsx12(Icon9, { icon: "lucide:file-archive", width: 16, height: 16 }),
+          /* @__PURE__ */ jsx12("span", { children: filePaths.length === 1 ? filePaths[0].split("/").pop() : `${filePaths.length} \u4E2A\u9879\u76EE` })
+        ] }),
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-field", children: [
+          /* @__PURE__ */ jsx12("label", { children: "\u6587\u4EF6\u540D" }),
+          /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-input-group", children: [
+            /* @__PURE__ */ jsx12(
+              "input",
+              {
+                type: "text",
+                value: outputName,
+                onChange: (e) => setOutputName(e.target.value),
+                placeholder: "\u8F93\u5165\u6587\u4EF6\u540D"
+              }
+            ),
+            /* @__PURE__ */ jsx12("span", { className: "compress-dialog-ext", children: currentExt })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-field", children: [
+          /* @__PURE__ */ jsx12("label", { children: "\u538B\u7F29\u683C\u5F0F" }),
+          /* @__PURE__ */ jsx12("select", { value: format, onChange: (e) => setFormat(e.target.value), children: FORMAT_OPTIONS.map((opt) => /* @__PURE__ */ jsx12("option", { value: opt.value, children: opt.label }, opt.value)) })
+        ] }),
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-field", children: [
+          /* @__PURE__ */ jsx12("label", { children: "\u538B\u7F29\u7EA7\u522B" }),
+          /* @__PURE__ */ jsx12("div", { className: "compress-dialog-levels", children: LEVEL_OPTIONS.map((opt) => /* @__PURE__ */ jsxs10("label", { className: "compress-dialog-level", children: [
+            /* @__PURE__ */ jsx12(
+              "input",
+              {
+                type: "radio",
+                name: "level",
+                value: opt.value,
+                checked: level === opt.value,
+                onChange: () => setLevel(opt.value)
+              }
+            ),
+            /* @__PURE__ */ jsx12("span", { className: "compress-dialog-level-label", children: opt.label }),
+            /* @__PURE__ */ jsx12("span", { className: "compress-dialog-level-desc", children: opt.desc })
+          ] }, opt.value)) })
+        ] }),
+        supportsPassword && /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-field", children: [
+          /* @__PURE__ */ jsx12("label", { children: "\u5BC6\u7801\u4FDD\u62A4\uFF08\u53EF\u9009\uFF09" }),
+          /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-input-group", children: [
+            /* @__PURE__ */ jsx12(
+              "input",
+              {
+                type: showPassword ? "text" : "password",
+                value: password,
+                onChange: (e) => setPassword(e.target.value),
+                placeholder: "\u8BBE\u7F6E\u5BC6\u7801"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              "button",
+              {
+                type: "button",
+                className: "compress-dialog-toggle-password",
+                onClick: () => setShowPassword(!showPassword),
+                children: showPassword ? "\u9690\u85CF" : "\u663E\u793A"
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx12("div", { className: "compress-dialog-field compress-dialog-checkbox", children: /* @__PURE__ */ jsxs10("label", { children: [
+          /* @__PURE__ */ jsx12(
+            "input",
+            {
+              type: "checkbox",
+              checked: deleteSource,
+              onChange: (e) => setDeleteSource(e.target.checked)
+            }
+          ),
+          /* @__PURE__ */ jsx12("span", { children: "\u538B\u7F29\u540E\u5220\u9664\u6E90\u6587\u4EF6" })
+        ] }) }),
+        /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-preview", children: [
+          /* @__PURE__ */ jsx12("span", { className: "compress-dialog-preview-label", children: "\u8F93\u51FA\u4F4D\u7F6E:" }),
+          /* @__PURE__ */ jsx12("span", { className: "compress-dialog-preview-path", children: fullOutputPath })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { className: "compress-dialog-footer", children: [
+        /* @__PURE__ */ jsx12("button", { className: "compress-dialog-btn compress-dialog-btn-cancel", onClick: onCancel, children: "\u53D6\u6D88" }),
+        /* @__PURE__ */ jsx12(
+          "button",
+          {
+            className: "compress-dialog-btn compress-dialog-btn-confirm",
+            onClick: handleConfirm,
+            disabled: !outputName.trim(),
+            children: "\u538B\u7F29"
+          }
+        )
+      ] })
+    ] }) }),
+    document.body
+  );
+}
+
+// src/components/ProgressDialog.tsx
+import { createPortal as createPortal4 } from "react-dom";
+import { Icon as Icon10 } from "@iconify/react";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function ProgressDialog({
+  visible,
+  progress,
+  onCancel,
+  onClose,
+  onOpenFolder
+}) {
+  const { type, status, percent, currentFile, processedCount, totalCount, error, outputPath } = progress;
+  const title = type === "compress" ? "\u538B\u7F29\u6587\u4EF6" : "\u89E3\u538B\u6587\u4EF6";
+  const isCompleted = status === "success" || status === "error";
+  const StatusIcon = () => {
+    switch (status) {
+      case "processing":
+        return /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:loader-2", width: 24, height: 24, className: "progress-dialog-icon-spin" });
+      case "success":
+        return /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:check-circle", width: 24, height: 24, className: "progress-dialog-icon-success" });
+      case "error":
+        return /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:x-circle", width: 24, height: 24, className: "progress-dialog-icon-error" });
+      default:
+        return /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:archive", width: 24, height: 24 });
+    }
+  };
+  const getStatusText = () => {
+    switch (status) {
+      case "pending":
+        return "\u51C6\u5907\u4E2D...";
+      case "processing":
+        return type === "compress" ? "\u6B63\u5728\u538B\u7F29..." : "\u6B63\u5728\u89E3\u538B...";
+      case "success":
+        return type === "compress" ? "\u538B\u7F29\u5B8C\u6210" : "\u89E3\u538B\u5B8C\u6210";
+      case "error":
+        return "\u64CD\u4F5C\u5931\u8D25";
+      default:
+        return "";
+    }
+  };
+  const handleClose = () => {
+    if (isCompleted) {
+      onClose?.();
+    } else {
+      onCancel?.();
+    }
+  };
+  if (!visible) return null;
+  return createPortal4(
+    /* @__PURE__ */ jsx13("div", { className: "progress-dialog-overlay", children: /* @__PURE__ */ jsxs11("div", { className: "progress-dialog", children: [
+      /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-header", children: [
+        /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-title", children: [
+          /* @__PURE__ */ jsx13(StatusIcon, {}),
+          /* @__PURE__ */ jsx13("span", { children: title })
+        ] }),
+        isCompleted && /* @__PURE__ */ jsx13("button", { className: "progress-dialog-close", onClick: handleClose, children: /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:x", width: 18, height: 18 }) })
+      ] }),
+      /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-content", children: [
+        /* @__PURE__ */ jsx13("div", { className: "progress-dialog-status", children: getStatusText() }),
+        status === "processing" && /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-bar-container", children: [
+          /* @__PURE__ */ jsx13("div", { className: "progress-dialog-bar", children: /* @__PURE__ */ jsx13(
+            "div",
+            {
+              className: "progress-dialog-bar-fill",
+              style: { width: `${percent}%` }
+            }
+          ) }),
+          /* @__PURE__ */ jsxs11("span", { className: "progress-dialog-percent", children: [
+            percent,
+            "%"
+          ] })
+        ] }),
+        currentFile && status === "processing" && /* @__PURE__ */ jsx13("div", { className: "progress-dialog-current-file", children: currentFile }),
+        totalCount && totalCount > 0 && status === "processing" && /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-count", children: [
+          processedCount || 0,
+          " / ",
+          totalCount,
+          " \u4E2A\u6587\u4EF6"
+        ] }),
+        error && /* @__PURE__ */ jsx13("div", { className: "progress-dialog-error", children: error }),
+        status === "success" && outputPath && /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-output", children: [
+          /* @__PURE__ */ jsx13("span", { className: "progress-dialog-output-label", children: "\u8F93\u51FA\u4F4D\u7F6E:" }),
+          /* @__PURE__ */ jsx13("span", { className: "progress-dialog-output-path", children: outputPath })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs11("div", { className: "progress-dialog-footer", children: [
+        status === "processing" && onCancel && /* @__PURE__ */ jsx13("button", { className: "progress-dialog-btn progress-dialog-btn-cancel", onClick: onCancel, children: "\u53D6\u6D88" }),
+        status === "success" && outputPath && onOpenFolder && /* @__PURE__ */ jsxs11(
+          "button",
+          {
+            className: "progress-dialog-btn progress-dialog-btn-folder",
+            onClick: () => onOpenFolder(outputPath),
+            children: [
+              /* @__PURE__ */ jsx13(Icon10, { icon: "lucide:folder-open", width: 16, height: 16 }),
+              "\u6253\u5F00\u6587\u4EF6\u5939"
+            ]
+          }
+        ),
+        isCompleted && /* @__PURE__ */ jsx13("button", { className: "progress-dialog-btn progress-dialog-btn-close", onClick: handleClose, children: "\u5173\u95ED" })
+      ] })
+    ] }) }),
+    document.body
+  );
+}
+
+// src/components/FileInfoDialog.tsx
+import React from "react";
+import { Icon as Icon11 } from "@iconify/react";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function getFileIcon(type, name) {
+  if (type === FileType.FOLDER) {
+    return /* @__PURE__ */ jsx14(Icon11, { icon: "flat-color-icons:folder", width: 48, height: 48, className: "file-info-icon" });
+  }
+  if (name) {
+    const iconName2 = getFileTypeIcon(name, type);
+    return /* @__PURE__ */ jsx14(Icon11, { icon: iconName2, width: 48, height: 48, className: "file-info-icon" });
+  }
+  const iconMap = {
+    [FileType.IMAGE]: "material-icon-theme:image",
+    [FileType.VIDEO]: "material-icon-theme:video",
+    [FileType.MUSIC]: "material-icon-theme:audio",
+    [FileType.DOCUMENT]: "material-icon-theme:word",
+    [FileType.CODE]: "material-icon-theme:javascript",
+    [FileType.ARCHIVE]: "material-icon-theme:zip",
+    [FileType.PDF]: "material-icon-theme:pdf",
+    [FileType.TEXT]: "material-icon-theme:document",
+    [FileType.APPLICATION]: "material-icon-theme:exe"
+  };
+  const iconName = iconMap[type] || "material-icon-theme:document";
+  return /* @__PURE__ */ jsx14(Icon11, { icon: iconName, width: 48, height: 48, className: "file-info-icon" });
+}
+function getFileTypeName(type, extension) {
+  switch (type) {
+    case FileType.FOLDER:
+      return "\u6587\u4EF6\u5939";
+    case FileType.IMAGE:
+      return `\u56FE\u7247${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    case FileType.VIDEO:
+      return `\u89C6\u9891${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    case FileType.MUSIC:
+      return `\u97F3\u9891${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    case FileType.DOCUMENT:
+      return `\u6587\u6863${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    case FileType.CODE:
+      return `\u4EE3\u7801\u6587\u4EF6${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    case FileType.ARCHIVE:
+      return `\u538B\u7F29\u5305${extension ? ` (${extension.toUpperCase()})` : ""}`;
+    default:
+      return extension ? `${extension.toUpperCase()} \u6587\u4EF6` : "\u6587\u4EF6";
+  }
+}
+function getExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === 0) return void 0;
+  return filename.substring(lastDot + 1).toLowerCase();
+}
+function getDirectory(path) {
+  const lastSlash = path.lastIndexOf("/");
+  if (lastSlash === -1) return path;
+  return path.substring(0, lastSlash) || "/";
+}
+function FileInfoDialog({ visible, item, onClose }) {
+  if (!visible || !item) return null;
+  const extension = getExtension(item.name);
+  const directory = getDirectory(item.id);
+  const handleBackdropClick = (e) => {
+    if (e.target === e.currentTarget) {
+      onClose();
+    }
+  };
+  React.useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        onClose();
+      }
+    };
+    if (visible) {
+      document.addEventListener("keydown", handleKeyDown);
+    }
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [visible, onClose]);
+  return /* @__PURE__ */ jsx14("div", { className: "file-info-dialog-overlay", onClick: handleBackdropClick, children: /* @__PURE__ */ jsxs12("div", { className: "file-info-dialog", children: [
+    /* @__PURE__ */ jsxs12("div", { className: "file-info-dialog-header", children: [
+      /* @__PURE__ */ jsxs12("div", { className: "file-info-dialog-title", children: [
+        getFileIcon(item.type, item.name),
+        /* @__PURE__ */ jsx14("span", { className: "file-info-dialog-name", title: item.name, children: item.name })
+      ] }),
+      /* @__PURE__ */ jsx14("button", { className: "file-info-dialog-close", onClick: onClose, children: /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:x", width: 18, height: 18 }) })
+    ] }),
+    /* @__PURE__ */ jsxs12("div", { className: "file-info-dialog-content", children: [
+      /* @__PURE__ */ jsxs12("div", { className: "file-info-row", children: [
+        /* @__PURE__ */ jsxs12("div", { className: "file-info-label", children: [
+          /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:file", width: 14, height: 14 }),
+          /* @__PURE__ */ jsx14("span", { children: "\u7C7B\u578B" })
+        ] }),
+        /* @__PURE__ */ jsx14("div", { className: "file-info-value", children: getFileTypeName(item.type, extension) })
+      ] }),
+      item.type !== FileType.FOLDER && item.size && /* @__PURE__ */ jsxs12("div", { className: "file-info-row", children: [
+        /* @__PURE__ */ jsxs12("div", { className: "file-info-label", children: [
+          /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:hard-drive", width: 14, height: 14 }),
+          /* @__PURE__ */ jsx14("span", { children: "\u5927\u5C0F" })
+        ] }),
+        /* @__PURE__ */ jsx14("div", { className: "file-info-value", children: item.size })
+      ] }),
+      /* @__PURE__ */ jsxs12("div", { className: "file-info-row", children: [
+        /* @__PURE__ */ jsxs12("div", { className: "file-info-label", children: [
+          /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:map-pin", width: 14, height: 14 }),
+          /* @__PURE__ */ jsx14("span", { children: "\u4F4D\u7F6E" })
+        ] }),
+        /* @__PURE__ */ jsx14("div", { className: "file-info-value file-info-value--path", title: directory, children: directory })
+      ] }),
+      /* @__PURE__ */ jsxs12("div", { className: "file-info-row", children: [
+        /* @__PURE__ */ jsxs12("div", { className: "file-info-label", children: [
+          /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:map-pin", width: 14, height: 14 }),
+          /* @__PURE__ */ jsx14("span", { children: "\u5B8C\u6574\u8DEF\u5F84" })
+        ] }),
+        /* @__PURE__ */ jsx14("div", { className: "file-info-value file-info-value--path", title: item.id, children: item.id })
+      ] }),
+      item.dateModified && /* @__PURE__ */ jsxs12("div", { className: "file-info-row", children: [
+        /* @__PURE__ */ jsxs12("div", { className: "file-info-label", children: [
+          /* @__PURE__ */ jsx14(Icon11, { icon: "lucide:clock", width: 14, height: 14 }),
+          /* @__PURE__ */ jsx14("span", { children: "\u4FEE\u6539\u65F6\u95F4" })
+        ] }),
+        /* @__PURE__ */ jsx14("div", { className: "file-info-value", children: item.dateModified })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx14("div", { className: "file-info-dialog-footer", children: /* @__PURE__ */ jsx14("button", { className: "file-info-dialog-btn", onClick: onClose, children: "\u5173\u95ED" }) })
+  ] }) });
+}
+
+// src/hooks/useSelection.ts
+import { useState as useState7, useCallback as useCallback5 } from "react";
+function useSelection() {
+  const [selectedIds, setSelectedIds] = useState7(/* @__PURE__ */ new Set());
+  const [lastSelectedId, setLastSelectedId] = useState7(null);
+  const [editingId, setEditingId] = useState7(null);
+  const clearSelection = useCallback5(() => {
+    setSelectedIds(/* @__PURE__ */ new Set());
+    setLastSelectedId(null);
+  }, []);
+  const selectItem = useCallback5((id, items, multi = false, range = false) => {
+    if (!id) {
+      clearSelection();
+      return;
+    }
+    setSelectedIds((prev) => {
+      setLastSelectedId((prevLast) => {
+        if (range && prevLast) {
+          const indexA = items.findIndex((i) => i.id === prevLast);
+          const indexB = items.findIndex((i) => i.id === id);
+          if (indexA !== -1 && indexB !== -1) {
+            const start = Math.min(indexA, indexB);
+            const end = Math.max(indexA, indexB);
+            const newSet = new Set(multi ? prev : []);
+            for (let i = start; i <= end; i++) {
+              const item = items[i];
+              if (item) {
+                newSet.add(item.id);
+              }
+            }
+            setSelectedIds(newSet);
+            return id;
+          }
+        }
+        if (multi) {
+          const newSet = new Set(prev);
+          if (newSet.has(id)) {
+            newSet.delete(id);
+          } else {
+            newSet.add(id);
+          }
+          setSelectedIds(newSet);
+          return id;
+        }
+        setSelectedIds(/* @__PURE__ */ new Set([id]));
+        return id;
+      });
+      return prev;
+    });
+  }, [clearSelection]);
+  const selectAll = useCallback5((items) => {
+    setSelectedIds(new Set(items.map((i) => i.id)));
+  }, []);
+  const setEditing = useCallback5((id) => {
+    setEditingId(id);
+  }, []);
+  const isSelected = useCallback5((id) => {
+    return selectedIds.has(id);
+  }, [selectedIds]);
+  return {
+    selectedIds,
+    lastSelectedId,
+    editingId,
+    clearSelection,
+    selectItem,
+    selectAll,
+    setEditing,
+    isSelected
+  };
+}
+
+// src/hooks/useDragAndDrop.ts
+import { useState as useState8, useCallback as useCallback6 } from "react";
+function useDragAndDrop(getSelectedIds, onSelect, onMove) {
+  const [dragOverId, setDragOverId] = useState8(null);
+  const [isDragging, setIsDragging] = useState8(false);
+  const handleDragStart = useCallback6((e, itemId) => {
+    if (!e.dataTransfer) return;
+    const selectedIds = getSelectedIds();
+    if (!selectedIds.has(itemId)) {
+      onSelect(itemId, false, false);
+    }
+    const draggedIds = selectedIds.has(itemId) ? selectedIds : /* @__PURE__ */ new Set([itemId]);
+    e.dataTransfer.setData("text/plain", JSON.stringify([...draggedIds]));
+    e.dataTransfer.effectAllowed = "move";
+    setIsDragging(true);
+  }, [getSelectedIds, onSelect]);
+  const handleDragOver = useCallback6((e, item) => {
+    if (!isDragging) return;
+    if (item.type === FileType.FOLDER) {
+      const selectedIds = getSelectedIds();
+      if (!selectedIds.has(item.id)) {
+        e.preventDefault();
+        setDragOverId(item.id);
+      }
+    }
+  }, [isDragging, getSelectedIds]);
+  const handleDragLeave = useCallback6(() => {
+    setDragOverId(null);
+  }, []);
+  const handleDrop = useCallback6((e, targetItem) => {
+    setDragOverId(null);
+    setIsDragging(false);
+    if (!e.dataTransfer || targetItem.type !== FileType.FOLDER) return;
+    const data = e.dataTransfer.getData("text/plain");
+    if (!data) return;
+    try {
+      const draggedIds = JSON.parse(data);
+      const itemIds = new Set(draggedIds);
+      if (itemIds.has(targetItem.id)) return;
+      onMove(targetItem.id, itemIds);
+    } catch {
+    }
+  }, [onMove]);
+  const handleDragEnd = useCallback6(() => {
+    setDragOverId(null);
+    setIsDragging(false);
+  }, []);
+  return {
+    dragOverId,
+    isDragging,
+    handleDragStart,
+    handleDragOver,
+    handleDragLeave,
+    handleDrop,
+    handleDragEnd
+  };
+}
+
+// src/hooks/useMediaPlayer.ts
+import { useState as useState9, useCallback as useCallback7, useEffect as useEffect6 } from "react";
+function useMediaPlayer(mediaType, mediaRef) {
+  const [isPlaying, setIsPlaying] = useState9(false);
+  const [progress, setProgress] = useState9(0);
+  const [currentTime, setCurrentTime] = useState9(0);
+  const [duration, setDuration] = useState9(0);
+  const [isMuted, setIsMuted] = useState9(false);
+  const [volume, setVolume] = useState9(1);
+  const [lastVolume, setLastVolume] = useState9(1);
+  const [showControls, setShowControls] = useState9(false);
+  const isAudio = mediaType === FileType.MUSIC;
+  const updateProgress = useCallback7(() => {
+    const media = mediaRef.current;
+    if (media) {
+      const curr = media.currentTime;
+      const dur = media.duration;
+      setCurrentTime(curr);
+      if (dur && !isNaN(dur)) {
+        setDuration(dur);
+        setProgress(curr / dur * 100);
+      }
+    }
+  }, [mediaRef]);
+  const togglePlay = useCallback7(() => {
+    const media = mediaRef.current;
+    if (media) {
+      if (isPlaying) {
+        media.pause();
+        setIsPlaying(false);
+      } else {
+        media.play();
+        setIsPlaying(true);
+      }
+    }
+  }, [isPlaying, mediaRef]);
+  const toggleMute = useCallback7(() => {
+    const media = mediaRef.current;
+    if (media) {
+      if (isMuted) {
+        const volToRestore = lastVolume || 1;
+        media.volume = volToRestore;
+        media.muted = false;
+        setVolume(volToRestore);
+        setIsMuted(false);
+      } else {
+        setLastVolume(volume);
+        media.volume = 0;
+        media.muted = true;
+        setVolume(0);
+        setIsMuted(true);
+      }
+    }
+  }, [isMuted, lastVolume, volume, mediaRef]);
+  const handleVolumeChange = useCallback7((val) => {
+    setVolume(val);
+    const media = mediaRef.current;
+    if (media) {
+      media.volume = val;
+      if (val === 0) {
+        setIsMuted(true);
+        media.muted = true;
+      } else {
+        setIsMuted(false);
+        media.muted = false;
+      }
+    }
+  }, [mediaRef]);
+  const seekTo = useCallback7((time) => {
+    const media = mediaRef.current;
+    if (media && duration) {
+      media.currentTime = time;
+      setCurrentTime(time);
+      setProgress(time / duration * 100);
+    }
+  }, [duration, mediaRef]);
+  const formatTime = useCallback7((time) => {
+    if (isNaN(time)) return "0:00";
+    const minutes = Math.floor(time / 60);
+    const seconds = Math.floor(time % 60);
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }, []);
+  const autoPlay = useCallback7(() => {
+    const media = mediaRef.current;
+    if ((mediaType === FileType.VIDEO || isAudio) && media) {
+      media.volume = volume;
+      media.play().catch(() => {
+      });
+      setIsPlaying(true);
+    }
+  }, [mediaType, isAudio, volume, mediaRef]);
+  useEffect6(() => {
+    const media = mediaRef.current;
+    if (media) {
+      media.addEventListener("timeupdate", updateProgress);
+      media.addEventListener("loadedmetadata", updateProgress);
+      media.addEventListener("ended", () => {
+        setIsPlaying(false);
+      });
+      return () => {
+        media.removeEventListener("timeupdate", updateProgress);
+        media.removeEventListener("loadedmetadata", updateProgress);
+      };
+    }
+  }, [mediaRef, updateProgress]);
+  return {
+    isPlaying,
+    progress,
+    currentTime,
+    duration,
+    isMuted,
+    volume,
+    showControls,
+    isAudio,
+    togglePlay,
+    toggleMute,
+    handleVolumeChange,
+    seekTo,
+    formatTime,
+    autoPlay,
+    updateProgress
+  };
+}
+
+// src/hooks/useApplicationIcon.ts
+import { useState as useState10, useCallback as useCallback8, useEffect as useEffect7 } from "react";
+function useApplicationIcon(items) {
+  const appIconCache = /* @__PURE__ */ new Map();
+  const [appIconUrls, setAppIconUrls] = useState10(/* @__PURE__ */ new Map());
+  const loadApplicationIcon = useCallback8(async (item) => {
+    if (item.type !== FileType.APPLICATION || !item.id) return;
+    if (appIconCache.has(item.id)) {
+      const cachedUrl = appIconCache.get(item.id);
+      if (cachedUrl) {
+        setAppIconUrls((prev) => new Map(prev).set(item.id, cachedUrl));
+      }
+      return;
+    }
+    if (appIconUrls.has(item.id)) {
+      return;
+    }
+    if (typeof window.fileExplorerAPI !== "undefined" && window.fileExplorerAPI.getApplicationIcon) {
+      try {
+        const iconUrl = await window.fileExplorerAPI.getApplicationIcon(item.id);
+        if (iconUrl) {
+          appIconCache.set(item.id, iconUrl);
+          setAppIconUrls((prev) => new Map(prev).set(item.id, iconUrl));
+        }
+      } catch (error) {
+        console.error(`Failed to load application icon for ${item.name}:`, error);
+      }
+    }
+  }, [appIconUrls]);
+  useEffect7(() => {
+    items.forEach((item) => {
+      if (item.type === FileType.APPLICATION && !appIconUrls.has(item.id)) {
+        loadApplicationIcon(item);
+      }
+    });
+  }, [items, appIconUrls, loadApplicationIcon]);
+  const getAppIconUrl = useCallback8((item) => {
+    return appIconUrls.get(item.id);
+  }, [appIconUrls]);
+  return {
+    getAppIconUrl,
+    loadApplicationIcon
+  };
+}
+export {
+  Breadcrumb,
+  CompressDialog,
+  ContextMenu,
+  FileGrid,
+  FileIcon,
+  FileInfoDialog,
+  FileList,
+  FileListView,
+  FileSidebar,
+  FileType,
+  ProgressDialog,
+  SortIndicator,
+  StatusBar,
+  Toolbar,
+  Window,
+  useApplicationIcon,
+  useDragAndDrop,
+  useMediaPlayer,
+  useSelection,
+  useWindowDrag,
+  useWindowResize
+};
+//# sourceMappingURL=index.js.map