react-upload-pro 0.1.0

package/dist/chunk-VVMPVTIX.cjs

@@ -0,0 +1,3030 @@
+"use client";
+'use strict';
+
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+
+// src/utils/id.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `rup-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/utils/files.ts
+var SSR = typeof window === "undefined";
+function wrapFile(file, metadata = {}) {
+  const path = typeof file.webkitRelativePath === "string" ? file.webkitRelativePath : "";
+  return {
+    id: generateId(),
+    file,
+    name: file.name,
+    size: file.size,
+    type: file.type,
+    path,
+    status: "idle",
+    progress: 0,
+    bytesUploaded: 0,
+    speed: 0,
+    eta: Infinity,
+    addedAt: Date.now(),
+    attempts: 0,
+    metadata
+  };
+}
+function generatePreview(file) {
+  if (SSR) return void 0;
+  if (typeof URL === "undefined" || typeof URL.createObjectURL !== "function") return void 0;
+  try {
+    return URL.createObjectURL(file);
+  } catch {
+    return void 0;
+  }
+}
+function revokePreview(url) {
+  if (!url || SSR) return;
+  if (typeof URL === "undefined" || typeof URL.revokeObjectURL !== "function") return;
+  try {
+    URL.revokeObjectURL(url);
+  } catch {
+  }
+}
+function getFileCategory(file) {
+  const name = "file" in file ? file.file.name : file.name;
+  const type = "file" in file ? file.file.type : file.type;
+  if (type.startsWith("image/")) return "image";
+  if (type.startsWith("video/")) return "video";
+  if (type.startsWith("audio/")) return "audio";
+  if (type === "application/pdf") return "pdf";
+  if (type.startsWith("text/") || type === "application/json" || type === "application/xml") {
+    return "text";
+  }
+  const ext = name.toLowerCase().split(".").pop() ?? "";
+  if (["doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp"].includes(ext)) {
+    return "office";
+  }
+  if (["zip", "rar", "tar", "gz", "7z"].includes(ext)) return "archive";
+  if (["md", "log", "csv", "tsv"].includes(ext)) return "text";
+  return "other";
+}
+async function detectSignature(file) {
+  const head = file.slice(0, 16);
+  const ab = await readArrayBuffer(head);
+  const buf = new Uint8Array(ab);
+  const hex = Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (hex.startsWith("ffd8ff")) return "image/jpeg";
+  if (hex.startsWith("89504e470d0a1a0a")) return "image/png";
+  if (hex.startsWith("474946383761") || hex.startsWith("474946383961")) return "image/gif";
+  if (hex.startsWith("52494646") && hex.slice(16, 24) === "57454250") return "image/webp";
+  if (hex.startsWith("25504446")) return "application/pdf";
+  if (hex.startsWith("504b0304") || hex.startsWith("504b0506") || hex.startsWith("504b0708")) {
+    return "application/zip";
+  }
+  if (hex.slice(8, 16) === "66747970") return "video/mp4";
+  if (hex.startsWith("1f8b")) return "application/gzip";
+  return null;
+}
+async function collectFiles(items) {
+  if (!items) return [];
+  const collected = [];
+  const promises = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) continue;
+    if (item.kind !== "file") continue;
+    const entry = typeof item.webkitGetAsEntry === "function" ? item.webkitGetAsEntry() : null;
+    if (entry) {
+      promises.push(walkEntry(entry, "", collected));
+    } else {
+      const file = item.getAsFile();
+      if (file) collected.push(file);
+    }
+  }
+  await Promise.all(promises);
+  return collected;
+}
+async function walkEntry(entry, basePath, out) {
+  if (entry.isFile) {
+    const fileEntry = entry;
+    return new Promise((resolve) => {
+      fileEntry.file(
+        (f) => {
+          if (basePath) {
+            Object.defineProperty(f, "webkitRelativePath", {
+              value: `${basePath}/${f.name}`,
+              configurable: true
+            });
+          }
+          out.push(f);
+          resolve();
+        },
+        () => resolve()
+      );
+    });
+  }
+  if (entry.isDirectory) {
+    const dirEntry = entry;
+    const reader = dirEntry.createReader();
+    const children = [];
+    await new Promise((resolve) => {
+      const readAll = () => {
+        reader.readEntries((batch) => {
+          if (batch.length === 0) {
+            resolve();
+            return;
+          }
+          children.push(...batch);
+          readAll();
+        }, () => resolve());
+      };
+      readAll();
+    });
+    const nextPath = basePath ? `${basePath}/${entry.name}` : entry.name;
+    await Promise.all(children.map((c) => walkEntry(c, nextPath, out)));
+  }
+}
+function fileKey(file) {
+  return `${file.name}::${file.size}::${file.lastModified}`;
+}
+async function readArrayBuffer(blob) {
+  const maybe = blob.arrayBuffer;
+  if (typeof maybe === "function") {
+    return maybe.call(blob);
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error);
+    reader.readAsArrayBuffer(blob);
+  });
+}
+
+// src/utils/format.ts
+function formatBytes(bytes, decimals = 1) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const k = 1024;
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(k)));
+  return `${(bytes / Math.pow(k, i)).toFixed(decimals)} ${units[i]}`;
+}
+function formatSpeed(bps) {
+  if (!Number.isFinite(bps) || bps <= 0) return "\u2014";
+  return `${formatBytes(bps)}/s`;
+}
+function formatEta(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) return "\u2014";
+  if (seconds < 60) return `${Math.ceil(seconds)}s`;
+  if (seconds < 3600) {
+    const m2 = Math.floor(seconds / 60);
+    const s = Math.ceil(seconds % 60);
+    return `${m2}m ${s}s`;
+  }
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  return `${h}h ${m}m`;
+}
+function formatPercent(progress) {
+  return `${Math.round(Math.max(0, Math.min(1, progress)) * 100)}%`;
+}
+
+// src/core/validation.ts
+function normalizeAccept(accept) {
+  if (!accept) return [];
+  if (typeof accept === "string") {
+    return accept.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (Array.isArray(accept)) {
+    return accept.map((s) => s.trim()).filter(Boolean);
+  }
+  const out = [];
+  for (const [mime, exts] of Object.entries(accept)) {
+    out.push(mime);
+    if (Array.isArray(exts)) out.push(...exts);
+  }
+  return out;
+}
+function matchesAccept(file, acceptors) {
+  if (acceptors.length === 0) return true;
+  const fileMime = (file.type || "").toLowerCase();
+  const fileName = file.name.toLowerCase();
+  for (const raw of acceptors) {
+    const a = raw.toLowerCase();
+    if (a.startsWith(".")) {
+      if (fileName.endsWith(a)) return true;
+      continue;
+    }
+    if (a.endsWith("/*")) {
+      const prefix = a.slice(0, -1);
+      if (fileMime.startsWith(prefix)) return true;
+      continue;
+    }
+    if (fileMime === a) return true;
+  }
+  return false;
+}
+function validateBuiltin(file, config) {
+  if (typeof config.minSize === "number" && file.size < config.minSize) {
+    return {
+      code: "file-too-small",
+      message: `File is smaller than ${formatBytes(config.minSize)}.`,
+      file
+    };
+  }
+  if (typeof config.maxSize === "number" && file.size > config.maxSize) {
+    return {
+      code: "file-too-large",
+      message: `File is larger than ${formatBytes(config.maxSize)}.`,
+      file
+    };
+  }
+  const acceptors = normalizeAccept(config.accept);
+  if (!matchesAccept(file, acceptors)) {
+    return {
+      code: "file-invalid-type",
+      message: `File type "${file.type || "unknown"}" is not allowed.`,
+      file
+    };
+  }
+  return null;
+}
+async function validateFile(file, config) {
+  const built = validateBuiltin(file, config);
+  if (built) return built;
+  if (config.validators?.length) {
+    for (const validator of config.validators) {
+      const result = await validator(file);
+      if (result) return result;
+    }
+  }
+  return null;
+}
+async function validateBatch(files, config, existingCount = 0, existingKeys = /* @__PURE__ */ new Set()) {
+  const accepted = [];
+  const rejected = [];
+  const seenInBatch = /* @__PURE__ */ new Set();
+  let count = existingCount;
+  for (const file of files) {
+    if (typeof config.maxFiles === "number" && count >= config.maxFiles) {
+      rejected.push({
+        code: "too-many-files",
+        message: `Maximum of ${config.maxFiles} files allowed.`,
+        file
+      });
+      continue;
+    }
+    if (config.rejectDuplicates) {
+      const key = fileKey(file);
+      if (existingKeys.has(key) || seenInBatch.has(key)) {
+        rejected.push({
+          code: "duplicate-file",
+          message: `Duplicate file: ${file.name}.`,
+          file
+        });
+        continue;
+      }
+      seenInBatch.add(key);
+    }
+    const error = await validateFile(file, config);
+    if (error) {
+      rejected.push(error);
+    } else {
+      accepted.push(file);
+      count += 1;
+    }
+  }
+  return { accepted, rejected };
+}
+
+// src/core/chunkUpload.ts
+async function chunkUpload(params) {
+  const { file, config, signal, onProgress } = params;
+  const chunkSize = config.chunkSize ?? 5 * 1024 * 1024;
+  const uploadId = file.id;
+  if (!file.chunks || file.chunks.length === 0) {
+    file.chunks = buildChunks(file.size, chunkSize);
+  }
+  const total = file.size;
+  let loadedBaseline = file.chunks.filter((c) => c.status === "success").reduce((sum, c) => sum + (c.end - c.start), 0);
+  for (const chunk of file.chunks) {
+    if (signal.aborted) throw makeError("cancelled", "Upload cancelled", false);
+    if (chunk.status === "success") continue;
+    chunk.status = "uploading";
+    chunk.attempts += 1;
+    const blob = file.file.slice(chunk.start, chunk.end);
+    try {
+      await sendChunk({
+        blob,
+        chunk,
+        total,
+        uploadId,
+        config,
+        signal,
+        onProgress: (loadedInChunk) => {
+          onProgress(loadedBaseline + loadedInChunk, total);
+        }
+      });
+      chunk.status = "success";
+      loadedBaseline += chunk.end - chunk.start;
+      onProgress(loadedBaseline, total);
+    } catch (err) {
+      chunk.status = "error";
+      throw err;
+    }
+  }
+  return { uploadId, chunks: file.chunks.length };
+}
+function buildChunks(total, size) {
+  const chunks = [];
+  let start = 0;
+  let index = 0;
+  while (start < total) {
+    const end = Math.min(total, start + size);
+    chunks.push({ index, start, end, status: "pending", attempts: 0 });
+    start = end;
+    index += 1;
+  }
+  if (chunks.length === 0) {
+    chunks.push({ index: 0, start: 0, end: 0, status: "pending", attempts: 0 });
+  }
+  return chunks;
+}
+function sendChunk(params) {
+  const { blob, chunk, total, uploadId, config, signal, onProgress } = params;
+  return new Promise(async (resolve, reject) => {
+    if (!config.endpoint) {
+      reject(makeError("config-error", "No endpoint configured", false));
+      return;
+    }
+    let headers = {};
+    if (config.headers) {
+      try {
+        headers = typeof config.headers === "function" ? await config.headers() : { ...config.headers };
+      } catch (cause) {
+        reject(makeError("headers-failed", "Failed to compute headers", true, cause));
+        return;
+      }
+    }
+    headers["Content-Range"] = `bytes ${chunk.start}-${Math.max(0, chunk.end - 1)}/${total}`;
+    headers["X-Upload-Id"] = uploadId;
+    headers["X-Chunk-Index"] = String(chunk.index);
+    const xhr = new XMLHttpRequest();
+    xhr.open(config.method ?? "POST", config.endpoint, true);
+    xhr.withCredentials = !!config.withCredentials;
+    for (const [k, v] of Object.entries(headers)) {
+      try {
+        xhr.setRequestHeader(k, v);
+      } catch {
+      }
+    }
+    xhr.upload.addEventListener("progress", (ev) => {
+      if (ev.lengthComputable) onProgress(ev.loaded);
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) resolve();
+      else {
+        reject(
+          makeError(
+            `http-${xhr.status}`,
+            `Chunk ${chunk.index} failed: ${xhr.status}`,
+            xhr.status >= 500 || xhr.status === 408 || xhr.status === 429
+          )
+        );
+      }
+    });
+    xhr.addEventListener("error", () => reject(makeError("network", "Network error", true)));
+    xhr.addEventListener("abort", () => reject(makeError("cancelled", "Upload cancelled", false)));
+    signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    xhr.send(blob);
+  });
+}
+function makeError(code, message, retryable, cause) {
+  return { code, message, retryable, cause };
+}
+
+// src/core/speed.ts
+var SpeedMeter = class {
+  constructor(totalBytes, alpha = 0.3) {
+    this.bytes = 0;
+    this.lastTime = 0;
+    this.speed = 0;
+    this.totalBytes = totalBytes;
+    this.alpha = alpha;
+  }
+  update(currentBytes) {
+    const now = performance.now ? performance.now() : Date.now();
+    if (this.lastTime === 0) {
+      this.lastTime = now;
+      this.bytes = currentBytes;
+      return { speed: 0, eta: Infinity };
+    }
+    const dt = (now - this.lastTime) / 1e3;
+    if (dt <= 0) return { speed: this.speed, eta: this.eta() };
+    const db = currentBytes - this.bytes;
+    if (db < 0) {
+      this.bytes = currentBytes;
+      this.lastTime = now;
+      return { speed: this.speed, eta: this.eta() };
+    }
+    const sample = db / dt;
+    this.speed = this.speed === 0 ? sample : this.alpha * sample + (1 - this.alpha) * this.speed;
+    this.bytes = currentBytes;
+    this.lastTime = now;
+    return { speed: this.speed, eta: this.eta() };
+  }
+  eta() {
+    if (this.speed <= 0) return Infinity;
+    const remaining = this.totalBytes - this.bytes;
+    if (remaining <= 0) return 0;
+    return remaining / this.speed;
+  }
+};
+
+// src/core/xhrUpload.ts
+function xhrUpload(params) {
+  const { file, config, signal, onProgress } = params;
+  return new Promise(async (resolve, reject) => {
+    if (signal.aborted) {
+      reject(makeError2("cancelled", "Upload cancelled", false));
+      return;
+    }
+    let url = config.endpoint;
+    let method = config.method ?? "POST";
+    let extraFields = {};
+    let extraHeaders = {};
+    if (typeof config.getUploadToken === "function") {
+      try {
+        const token = await config.getUploadToken(file);
+        url = token.url;
+        method = token.method ?? method;
+        extraFields = token.fields ?? {};
+        extraHeaders = token.headers ?? {};
+      } catch (cause) {
+        reject(makeError2("token-failed", "Failed to obtain upload token", true, cause));
+        return;
+      }
+    }
+    if (!url) {
+      reject(makeError2("config-error", "No endpoint configured", false));
+      return;
+    }
+    let headers = { ...extraHeaders };
+    if (config.headers) {
+      try {
+        const dynamic = typeof config.headers === "function" ? await config.headers() : config.headers;
+        headers = { ...headers, ...dynamic };
+      } catch (cause) {
+        reject(makeError2("headers-failed", "Failed to compute headers", true, cause));
+        return;
+      }
+    }
+    const formExtra = typeof config.formData === "function" ? config.formData(file) : config.formData ?? {};
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    xhr.withCredentials = !!config.withCredentials;
+    for (const [k, v] of Object.entries(headers)) {
+      try {
+        xhr.setRequestHeader(k, v);
+      } catch {
+      }
+    }
+    xhr.upload.addEventListener("progress", (ev) => {
+      if (ev.lengthComputable) onProgress({ loaded: ev.loaded, total: ev.total });
+    });
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        const ct = xhr.getResponseHeader("content-type") ?? "";
+        let body = xhr.responseText;
+        if (ct.includes("application/json")) {
+          try {
+            body = JSON.parse(xhr.responseText);
+          } catch {
+          }
+        }
+        resolve(body);
+      } else {
+        reject(
+          makeError2(
+            `http-${xhr.status}`,
+            `Upload failed with status ${xhr.status}`,
+            xhr.status >= 500 || xhr.status === 408 || xhr.status === 429,
+            xhr.responseText
+          )
+        );
+      }
+    });
+    xhr.addEventListener("error", () => {
+      reject(makeError2("network", "Network error", true));
+    });
+    xhr.addEventListener("abort", () => {
+      reject(makeError2("cancelled", "Upload cancelled", false));
+    });
+    xhr.addEventListener("timeout", () => {
+      reject(makeError2("timeout", "Upload timed out", true));
+    });
+    const onAbort = () => xhr.abort();
+    signal.addEventListener("abort", onAbort, { once: true });
+    const fieldName = config.fieldName ?? "file";
+    if (method === "POST" && Object.keys(formExtra).length + Object.keys(extraFields).length > 0) {
+      const fd = new FormData();
+      for (const [k, v] of Object.entries({ ...extraFields, ...formExtra })) fd.append(k, v);
+      fd.append(fieldName, file.file, file.name);
+      xhr.send(fd);
+    } else if (method === "POST") {
+      const fd = new FormData();
+      fd.append(fieldName, file.file, file.name);
+      xhr.send(fd);
+    } else {
+      xhr.send(file.file);
+    }
+  });
+}
+function makeError2(code, message, retryable, cause) {
+  return { code, message, retryable, cause };
+}
+
+// src/core/queue.ts
+var UploadQueue = class {
+  constructor(config = {}, callbacks = {}) {
+    this.files = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    this.inFlight = /* @__PURE__ */ new Set();
+    this.completionFired = false;
+    this.config = { concurrency: 3, retries: 2, retryBackoffMs: 500, ...config };
+    this.callbacks = callbacks;
+  }
+  // ───────────── public state ─────────────
+  getFiles() {
+    return this.files;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.files);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  updateCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  // ───────────── mutations ─────────────
+  add(files) {
+    if (files.length === 0) return;
+    this.files = [...this.files, ...files];
+    this.completionFired = false;
+    this.emit();
+    const mode = this.config.mode ?? "manual";
+    if (mode === "instant" || mode === "auto") {
+      void this.start();
+    }
+  }
+  remove(id2) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    if (file.status === "uploading") {
+      file.controller?.abort();
+    }
+    revokePreview(file.previewUrl);
+    this.files = this.files.filter((f) => f.id !== id2);
+    this.inFlight.delete(id2);
+    this.callbacks.onRemove?.(file);
+    this.emit();
+  }
+  removeAll() {
+    for (const f of this.files) {
+      if (f.status === "uploading") f.controller?.abort();
+      revokePreview(f.previewUrl);
+    }
+    const removed = this.files;
+    this.files = [];
+    this.inFlight.clear();
+    for (const f of removed) this.callbacks.onRemove?.(f);
+    this.emit();
+  }
+  reorder(fromIndex, toIndex) {
+    if (fromIndex < 0 || toIndex < 0 || fromIndex >= this.files.length || toIndex >= this.files.length || fromIndex === toIndex) {
+      return;
+    }
+    const next = [...this.files];
+    const [moved] = next.splice(fromIndex, 1);
+    if (moved) next.splice(toIndex, 0, moved);
+    this.files = next;
+    this.emit();
+  }
+  rename(id2, newName) {
+    this.patch(id2, { name: newName });
+  }
+  setMetadata(id2, metadata) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    this.patch(id2, { metadata: { ...file.metadata, ...metadata } });
+  }
+  // ───────────── lifecycle ─────────────
+  async start() {
+    const strategy = this.config.strategy ?? "parallel";
+    const concurrency = strategy === "sequential" ? 1 : Math.max(1, this.config.concurrency ?? 3);
+    const pending = () => this.files.filter((f) => f.status === "idle" || f.status === "queued" || f.status === "paused");
+    for (const f of pending()) {
+      if (f.status === "idle") this.patch(f.id, { status: "queued" });
+    }
+    const next = () => pending().find((f) => f.status === "queued");
+    const runners = [];
+    const launch = async () => {
+      while (true) {
+        const file = next();
+        if (!file) return;
+        await this.runFile(file);
+      }
+    };
+    for (let i = 0; i < concurrency; i++) runners.push(launch());
+    await Promise.all(runners);
+    this.maybeFireCompletion();
+  }
+  pause(id2) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    if (file.status !== "uploading") return;
+    file.controller?.abort();
+    this.patch(id2, { status: "paused" });
+    this.callbacks.onPause?.(file);
+  }
+  resume(id2) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    if (file.status !== "paused") return;
+    this.patch(id2, { status: "queued" });
+    this.callbacks.onResume?.(file);
+    void this.start();
+  }
+  retry(id2) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    if (file.status !== "error" && file.status !== "cancelled") return;
+    this.patch(id2, {
+      status: "queued",
+      progress: 0,
+      bytesUploaded: 0,
+      speed: 0,
+      eta: Infinity,
+      error: void 0
+    });
+    this.callbacks.onRetry?.(file);
+    void this.start();
+  }
+  cancel(id2) {
+    const file = this.files.find((f) => f.id === id2);
+    if (!file) return;
+    if (file.status === "uploading") file.controller?.abort();
+    this.patch(id2, { status: "cancelled" });
+  }
+  // ───────────── internals ─────────────
+  async runFile(file) {
+    if (this.inFlight.has(file.id)) return;
+    this.inFlight.add(file.id);
+    const controller = new AbortController();
+    file.controller = controller;
+    const startedAt = Date.now();
+    this.patch(file.id, {
+      status: "uploading",
+      startedAt,
+      attempts: file.attempts + 1,
+      controller
+    });
+    this.callbacks.onUploadStart?.(this.lookup(file.id));
+    const meter = new SpeedMeter(file.size);
+    const updateProgress = (loaded, total) => {
+      const { speed, eta } = meter.update(loaded);
+      const progress = total > 0 ? loaded / total : 0;
+      this.patch(file.id, { progress, bytesUploaded: loaded, speed, eta });
+      this.callbacks.onUploadProgress?.(this.lookup(file.id));
+    };
+    try {
+      if (this.config.virusScan) {
+        const result = await this.config.virusScan(this.lookup(file.id));
+        if (!result.clean) {
+          throw {
+            code: "virus-detected",
+            message: result.reason ?? "File failed virus scan",
+            retryable: false
+          };
+        }
+      }
+      let response;
+      if (this.config.cloud) {
+        response = await this.config.cloud.upload(this.lookup(file.id), {
+          signal: controller.signal,
+          onProgress: updateProgress
+        });
+      } else if (this.config.chunkSize && this.config.chunkSize > 0) {
+        response = await chunkUpload({
+          file: this.lookup(file.id),
+          config: this.config,
+          signal: controller.signal,
+          onProgress: updateProgress
+        });
+      } else {
+        response = await xhrUpload({
+          file: this.lookup(file.id),
+          config: this.config,
+          signal: controller.signal,
+          onProgress: (ev) => updateProgress(ev.loaded, ev.total)
+        });
+      }
+      this.patch(file.id, {
+        status: "success",
+        progress: 1,
+        bytesUploaded: file.size,
+        finishedAt: Date.now(),
+        response,
+        controller: void 0,
+        eta: 0
+      });
+      this.callbacks.onUploadSuccess?.(this.lookup(file.id));
+    } catch (err) {
+      const error = normalizeError(err);
+      const current = this.lookup(file.id);
+      if (current.status === "paused") ; else if (error.code === "cancelled") {
+        this.patch(file.id, { status: "cancelled", error, controller: void 0 });
+      } else {
+        const maxRetries = this.config.retries ?? 0;
+        const canRetry = error.retryable && current.attempts <= maxRetries;
+        if (canRetry) {
+          const backoff = (this.config.retryBackoffMs ?? 500) * Math.pow(2, current.attempts - 1);
+          await new Promise((r) => setTimeout(r, backoff));
+          this.inFlight.delete(file.id);
+          this.callbacks.onRetry?.(current);
+          this.patch(file.id, { status: "queued", controller: void 0 });
+          return this.runFile(this.lookup(file.id));
+        }
+        this.patch(file.id, { status: "error", error, controller: void 0 });
+        this.callbacks.onUploadError?.(this.lookup(file.id), error);
+      }
+    } finally {
+      this.inFlight.delete(file.id);
+    }
+  }
+  lookup(id2) {
+    const f = this.files.find((x) => x.id === id2);
+    if (!f) throw new Error(`File ${id2} not found`);
+    return f;
+  }
+  patch(id2, patch) {
+    const idx = this.files.findIndex((f) => f.id === id2);
+    if (idx < 0) return;
+    const prev = this.files[idx];
+    if (!prev) return;
+    this.files = [
+      ...this.files.slice(0, idx),
+      { ...prev, ...patch },
+      ...this.files.slice(idx + 1)
+    ];
+    this.emit();
+  }
+  emit() {
+    for (const l of this.listeners) l(this.files);
+  }
+  maybeFireCompletion() {
+    if (this.completionFired) return;
+    if (this.files.length === 0) return;
+    const allDone = this.files.every(
+      (f) => f.status === "success" || f.status === "error" || f.status === "cancelled"
+    );
+    if (allDone) {
+      this.completionFired = true;
+      this.callbacks.onAllComplete?.(this.files);
+    }
+  }
+};
+function normalizeError(err) {
+  if (err && typeof err === "object" && "code" in err && "message" in err && "retryable" in err) {
+    return err;
+  }
+  if (err instanceof Error) {
+    return { code: "unknown", message: err.message, retryable: false, cause: err };
+  }
+  return { code: "unknown", message: "Upload failed", retryable: false, cause: err };
+}
+function useUploadQueue(options = {}) {
+  const queueRef = react.useRef(null);
+  if (queueRef.current === null) {
+    queueRef.current = new UploadQueue(options, options);
+  }
+  const queue = queueRef.current;
+  const [files, setFiles] = react.useState(() => queue.getFiles());
+  react.useEffect(() => {
+    queue.updateConfig(options);
+    queue.updateCallbacks(options);
+  }, [queue, options]);
+  react.useEffect(() => {
+    return queue.subscribe(setFiles);
+  }, [queue]);
+  return {
+    queue,
+    files,
+    add: (f) => queue.add(f),
+    remove: (id2) => queue.remove(id2),
+    removeAll: () => queue.removeAll(),
+    reorder: (from, to) => queue.reorder(from, to),
+    rename: (id2, name) => queue.rename(id2, name),
+    setMetadata: (id2, m) => queue.setMetadata(id2, m),
+    start: () => queue.start(),
+    pause: (id2) => queue.pause(id2),
+    resume: (id2) => queue.resume(id2),
+    retry: (id2) => queue.retry(id2),
+    cancel: (id2) => queue.cancel(id2)
+  };
+}
+function useDropzone(options = {}) {
+  const {
+    multiple = true,
+    directory = false,
+    disabled = false,
+    clipboard = true,
+    noBubble: _noBubble = true,
+    autoRevoke = true,
+    accept,
+    minSize,
+    maxSize,
+    maxFiles,
+    rejectDuplicates,
+    validators,
+    onDrop,
+    onDropAccepted,
+    onDropRejected,
+    ...uploaderConfig
+  } = options;
+  const inputRef = react.useRef(null);
+  const dragCounterRef = react.useRef(0);
+  const [dragState, setDragState] = react.useState("idle");
+  const [rejected, setRejected] = react.useState([]);
+  const queueApi = useUploadQueue({ ...uploaderConfig, ...options });
+  const existingKeys = react.useMemo(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const f of queueApi.files) set.add(fileKey(f.file));
+    return set;
+  }, [queueApi.files]);
+  const add = react.useCallback(
+    async (rawFiles) => {
+      let pool = rawFiles;
+      if (!multiple && pool.length > 1) pool = pool.slice(0, 1);
+      const isReplacement = !multiple && pool.length > 0 && queueApi.files.length > 0;
+      if (isReplacement) {
+        queueApi.removeAll();
+      }
+      const { accepted, rejected: rejectedFiles } = await validateBatch(
+        pool,
+        { accept, minSize, maxSize, maxFiles, rejectDuplicates, validators },
+        isReplacement ? 0 : queueApi.files.length,
+        isReplacement ? /* @__PURE__ */ new Set() : existingKeys
+      );
+      const wrapped = accepted.map((f) => {
+        const wf = wrapFile(f);
+        wf.previewUrl = generatePreview(f);
+        return wf;
+      });
+      queueApi.add(wrapped);
+      setRejected(rejectedFiles);
+      onDrop?.(wrapped, rejectedFiles);
+      if (wrapped.length) onDropAccepted?.(wrapped);
+      if (rejectedFiles.length) onDropRejected?.(rejectedFiles);
+      return { accepted: wrapped, rejected: rejectedFiles };
+    },
+    [
+      multiple,
+      accept,
+      minSize,
+      maxSize,
+      maxFiles,
+      rejectDuplicates,
+      validators,
+      queueApi,
+      existingKeys,
+      onDrop,
+      onDropAccepted,
+      onDropRejected
+    ]
+  );
+  const open = react.useCallback(() => {
+    if (disabled) return;
+    inputRef.current?.click();
+  }, [disabled]);
+  const handleInputChange = react.useCallback(
+    async (event) => {
+      const list = event.target.files;
+      if (!list) return;
+      await add(Array.from(list));
+      event.target.value = "";
+    },
+    [add]
+  );
+  const handleDragEnter = react.useCallback(
+    (event) => {
+      if (disabled) return;
+      event.preventDefault();
+      dragCounterRef.current += 1;
+      const hasFiles = Array.from(event.dataTransfer?.types ?? []).includes("Files");
+      setDragState(hasFiles ? "drag-accept" : "dragging");
+    },
+    [disabled]
+  );
+  const handleDragOver = react.useCallback(
+    (event) => {
+      if (disabled) return;
+      event.preventDefault();
+      if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+    },
+    [disabled]
+  );
+  const handleDragLeave = react.useCallback(
+    (event) => {
+      if (disabled) return;
+      event.preventDefault();
+      dragCounterRef.current = Math.max(0, dragCounterRef.current - 1);
+      if (dragCounterRef.current === 0) setDragState("idle");
+    },
+    [disabled]
+  );
+  const handleDrop = react.useCallback(
+    async (event) => {
+      if (disabled) return;
+      event.preventDefault();
+      dragCounterRef.current = 0;
+      setDragState("idle");
+      const dt = event.dataTransfer;
+      if (!dt) return;
+      let files = [];
+      if (dt.items && typeof dt.items[0]?.webkitGetAsEntry === "function") {
+        files = await collectFiles(dt.items);
+      } else if (dt.files) {
+        files = Array.from(dt.files);
+      }
+      await add(files);
+    },
+    [add, disabled]
+  );
+  const handleKeyDown = react.useCallback(
+    (event) => {
+      if (disabled) return;
+      if (event.key === "Enter" || event.key === " ") {
+        event.preventDefault();
+        open();
+      }
+    },
+    [disabled, open]
+  );
+  react.useEffect(() => {
+    if (!clipboard || disabled) return;
+    const onPaste = (event) => {
+      const ev = event;
+      const items = ev.clipboardData?.items;
+      if (!items) return;
+      const files = [];
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (!item) continue;
+        if (item.kind === "file") {
+          const f = item.getAsFile();
+          if (f) files.push(f);
+        }
+      }
+      if (files.length) void add(files);
+    };
+    document.addEventListener("paste", onPaste);
+    return () => document.removeEventListener("paste", onPaste);
+  }, [clipboard, disabled, add]);
+  react.useEffect(() => {
+    if (!autoRevoke) return;
+    return () => {
+      for (const f of queueApi.queue.getFiles()) {
+        if (f.previewUrl && typeof URL !== "undefined") {
+          try {
+            URL.revokeObjectURL(f.previewUrl);
+          } catch {
+          }
+        }
+      }
+    };
+  }, [autoRevoke, queueApi.queue]);
+  const state = dragState;
+  const isDragging = state !== "idle";
+  const getRootProps = react.useCallback(
+    (props = {}) => {
+      return {
+        ...props,
+        role: props.role ?? "button",
+        tabIndex: props.tabIndex ?? 0,
+        "aria-disabled": disabled || void 0,
+        "aria-label": props["aria-label"] ?? "File upload area",
+        "data-dropzone-state": state,
+        onClick: (e) => {
+          props.onClick?.(e);
+          if (!e.defaultPrevented) open();
+        },
+        onKeyDown: (e) => {
+          props.onKeyDown?.(e);
+          if (!e.defaultPrevented) handleKeyDown(e);
+        },
+        onDragEnter: (e) => {
+          props.onDragEnter?.(e);
+          handleDragEnter(e);
+        },
+        onDragOver: (e) => {
+          props.onDragOver?.(e);
+          handleDragOver(e);
+        },
+        onDragLeave: (e) => {
+          props.onDragLeave?.(e);
+          handleDragLeave(e);
+        },
+        onDrop: (e) => {
+          props.onDrop?.(e);
+          void handleDrop(e);
+        }
+      };
+    },
+    [
+      disabled,
+      state,
+      open,
+      handleKeyDown,
+      handleDragEnter,
+      handleDragOver,
+      handleDragLeave,
+      handleDrop
+    ]
+  );
+  const getInputProps = react.useCallback(
+    (props = {}) => {
+      const directoryProps = directory ? { webkitdirectory: "", directory: "", mozdirectory: "" } : {};
+      return {
+        ...directoryProps,
+        ...props,
+        ref: (node) => {
+          inputRef.current = node;
+        },
+        type: "file",
+        multiple,
+        disabled,
+        accept: typeof accept === "string" ? accept : Array.isArray(accept) ? accept.join(",") : void 0,
+        style: { display: "none", ...props.style },
+        onChange: (e) => {
+          props.onChange?.(e);
+          void handleInputChange(e);
+        },
+        tabIndex: -1,
+        "aria-hidden": true
+      };
+    },
+    [multiple, disabled, accept, directory, handleInputChange]
+  );
+  return {
+    getRootProps,
+    getInputProps,
+    open,
+    files: queueApi.files,
+    rejected,
+    isDragging,
+    isDragAccept: state === "drag-accept",
+    isDragReject: state === "drag-reject",
+    state,
+    add,
+    remove: queueApi.remove,
+    removeAll: queueApi.removeAll,
+    reorder: queueApi.reorder,
+    start: queueApi.start,
+    pause: queueApi.pause,
+    resume: queueApi.resume,
+    retry: queueApi.retry,
+    cancel: queueApi.cancel,
+    rename: queueApi.rename,
+    setMetadata: queueApi.setMetadata,
+    queue: queueApi.queue,
+    inputRef
+  };
+}
+function useUploadProgress(files) {
+  return react.useMemo(() => {
+    let total = 0;
+    let uploaded = 0;
+    let speed = 0;
+    let uploading = 0;
+    let completed = 0;
+    let errored = 0;
+    let pending = 0;
+    for (const f of files) {
+      total += f.size;
+      uploaded += f.bytesUploaded;
+      if (f.status === "uploading") {
+        uploading += 1;
+        speed += f.speed;
+      } else if (f.status === "success") {
+        completed += 1;
+      } else if (f.status === "error" || f.status === "cancelled") {
+        errored += 1;
+      } else {
+        pending += 1;
+      }
+    }
+    const progress = total > 0 ? uploaded / total : 0;
+    const remaining = total - uploaded;
+    const eta = speed > 0 ? remaining / speed : Infinity;
+    return { total, uploaded, progress, speed, eta, uploading, completed, errored, pending };
+  }, [files]);
+}
+var TEXT_PREVIEW_MAX_BYTES = 64 * 1024;
+function useFilePreview(file) {
+  const [state, setState] = react.useState({
+    kind: file ? getFileCategory(file) : "other",
+    loading: !!file
+  });
+  react.useEffect(() => {
+    if (!file) {
+      setState({ kind: "other", loading: false });
+      return;
+    }
+    const kind = getFileCategory(file);
+    if (kind === "text") {
+      let cancelled = false;
+      setState({ kind, loading: true });
+      const slice = file.file.slice(0, TEXT_PREVIEW_MAX_BYTES);
+      slice.text().then((text) => {
+        if (!cancelled) setState({ kind, text, loading: false });
+      }).catch((err) => {
+        if (!cancelled) {
+          setState({
+            kind,
+            loading: false,
+            error: err instanceof Error ? err.message : "Failed to read file"
+          });
+        }
+      });
+      return () => {
+        cancelled = true;
+      };
+    }
+    setState({ kind, url: file.previewUrl, loading: false });
+    return;
+  }, [file]);
+  return state;
+}
+
+// src/i18n/translations.ts
+var en = {
+  dropHere: "Drop files here",
+  dragOrClick: "Drag & drop files or click to browse",
+  browse: "Browse files",
+  uploading: "Uploading",
+  paused: "Paused",
+  success: "Uploaded",
+  error: "Failed",
+  retry: "Retry",
+  pause: "Pause",
+  resume: "Resume",
+  cancel: "Cancel",
+  remove: "Remove",
+  removeAll: "Remove all",
+  preview: "Preview",
+  download: "Download",
+  edit: "Edit",
+  save: "Save",
+  fullscreen: "Fullscreen",
+  rename: "Rename",
+  tags: "Tags",
+  description: "Description",
+  category: "Category",
+  addTag: "Add tag",
+  fileTooLarge: "File is too large",
+  fileTooSmall: "File is too small",
+  invalidType: "File type not allowed",
+  tooManyFiles: "Too many files",
+  duplicateFile: "Duplicate file",
+  speed: "Speed",
+  eta: "ETA",
+  ofText: "of",
+  filesText: "files",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var hi = {
+  dropHere: "\u092B\u093C\u093E\u0907\u0932\u0947\u0902 \u092F\u0939\u093E\u0901 \u091B\u094B\u0921\u093C\u0947\u0902",
+  dragOrClick: "\u092B\u093C\u093E\u0907\u0932\u0947\u0902 \u0916\u0940\u0902\u091A\u0947\u0902 \u0914\u0930 \u091B\u094B\u0921\u093C\u0947\u0902 \u092F\u093E \u092C\u094D\u0930\u093E\u0909\u091C\u093C \u0915\u0930\u0928\u0947 \u0915\u0947 \u0932\u093F\u090F \u0915\u094D\u0932\u093F\u0915 \u0915\u0930\u0947\u0902",
+  browse: "\u092B\u093C\u093E\u0907\u0932\u0947\u0902 \u092C\u094D\u0930\u093E\u0909\u091C\u093C \u0915\u0930\u0947\u0902",
+  uploading: "\u0905\u092A\u0932\u094B\u0921 \u0939\u094B \u0930\u0939\u093E \u0939\u0948",
+  paused: "\u0930\u0941\u0915\u093E \u0939\u0941\u0906",
+  success: "\u0905\u092A\u0932\u094B\u0921 \u0939\u094B \u0917\u092F\u093E",
+  error: "\u0935\u093F\u092B\u0932",
+  retry: "\u092A\u0941\u0928\u0903 \u092A\u094D\u0930\u092F\u093E\u0938",
+  pause: "\u0930\u094B\u0915\u0947\u0902",
+  resume: "\u091C\u093E\u0930\u0940 \u0930\u0916\u0947\u0902",
+  cancel: "\u0930\u0926\u094D\u0926 \u0915\u0930\u0947\u0902",
+  remove: "\u0939\u091F\u093E\u090F\u0901",
+  removeAll: "\u0938\u092D\u0940 \u0939\u091F\u093E\u090F\u0901",
+  preview: "\u092A\u0942\u0930\u094D\u0935\u093E\u0935\u0932\u094B\u0915\u0928",
+  download: "\u0921\u093E\u0909\u0928\u0932\u094B\u0921",
+  edit: "\u0938\u0902\u092A\u093E\u0926\u093F\u0924 \u0915\u0930\u0947\u0902",
+  save: "\u0938\u0939\u0947\u091C\u0947\u0902",
+  fullscreen: "\u092A\u0942\u0930\u094D\u0923 \u0938\u094D\u0915\u094D\u0930\u0940\u0928",
+  rename: "\u0928\u093E\u092E \u092C\u0926\u0932\u0947\u0902",
+  tags: "\u091F\u0948\u0917",
+  description: "\u0935\u093F\u0935\u0930\u0923",
+  category: "\u0936\u094D\u0930\u0947\u0923\u0940",
+  addTag: "\u091F\u0948\u0917 \u091C\u094B\u0921\u093C\u0947\u0902",
+  fileTooLarge: "\u092B\u093C\u093E\u0907\u0932 \u092C\u0939\u0941\u0924 \u092C\u0921\u093C\u0940 \u0939\u0948",
+  fileTooSmall: "\u092B\u093C\u093E\u0907\u0932 \u092C\u0939\u0941\u0924 \u091B\u094B\u091F\u0940 \u0939\u0948",
+  invalidType: "\u092B\u093C\u093E\u0907\u0932 \u092A\u094D\u0930\u0915\u093E\u0930 \u0905\u0928\u0941\u092E\u0924 \u0928\u0939\u0940\u0902 \u0939\u0948",
+  tooManyFiles: "\u092C\u0939\u0941\u0924 \u0938\u0940 \u092B\u093C\u093E\u0907\u0932\u0947\u0902",
+  duplicateFile: "\u0921\u0941\u092A\u094D\u0932\u093F\u0915\u0947\u091F \u092B\u093C\u093E\u0907\u0932",
+  speed: "\u0917\u0924\u093F",
+  eta: "\u0905\u0928\u0941\u092E\u093E\u0928\u093F\u0924 \u0938\u092E\u092F",
+  ofText: "\u092E\u0947\u0902 \u0938\u0947",
+  filesText: "\u092B\u093C\u093E\u0907\u0932\u0947\u0902",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var gu = {
+  dropHere: "\u0AAB\u0ABE\u0A87\u0AB2\u0ACB \u0A85\u0AB9\u0AC0\u0A82 \u0AAE\u0AC2\u0A95\u0ACB",
+  dragOrClick: "\u0AAB\u0ABE\u0A87\u0AB2\u0ACB \u0A96\u0AC7\u0A82\u0A9A\u0AC0\u0AA8\u0AC7 \u0AAE\u0AC2\u0A95\u0ACB \u0A85\u0AA5\u0AB5\u0ABE \u0AAC\u0ACD\u0AB0\u0ABE\u0A89\u0A9D \u0A95\u0AB0\u0AB5\u0ABE \u0AAE\u0ABE\u0A9F\u0AC7 \u0A95\u0ACD\u0AB2\u0ABF\u0A95 \u0A95\u0AB0\u0ACB",
+  browse: "\u0AAB\u0ABE\u0A87\u0AB2\u0ACB \u0AAC\u0ACD\u0AB0\u0ABE\u0A89\u0A9D \u0A95\u0AB0\u0ACB",
+  uploading: "\u0A85\u0AAA\u0AB2\u0ACB\u0AA1 \u0AA5\u0A88 \u0AB0\u0AB9\u0ACD\u0AAF\u0AC1\u0A82 \u0A9B\u0AC7",
+  paused: "\u0AA5\u0ACB\u0AAD\u0ABE\u0AB5\u0AC7\u0AB2\u0AC1\u0A82",
+  success: "\u0A85\u0AAA\u0AB2\u0ACB\u0AA1 \u0AA5\u0A88 \u0A97\u0AAF\u0AC1\u0A82",
+  error: "\u0AA8\u0ABF\u0AB7\u0ACD\u0AAB\u0AB3",
+  retry: "\u0AAB\u0AB0\u0AC0 \u0AAA\u0ACD\u0AB0\u0AAF\u0ABE\u0AB8 \u0A95\u0AB0\u0ACB",
+  pause: "\u0AA5\u0ACB\u0AAD\u0ACB",
+  resume: "\u0AAB\u0AB0\u0AC0 \u0AB6\u0AB0\u0AC2 \u0A95\u0AB0\u0ACB",
+  cancel: "\u0AB0\u0AA6 \u0A95\u0AB0\u0ACB",
+  remove: "\u0AA6\u0AC2\u0AB0 \u0A95\u0AB0\u0ACB",
+  removeAll: "\u0AAC\u0AA7\u0AC1\u0A82 \u0AA6\u0AC2\u0AB0 \u0A95\u0AB0\u0ACB",
+  preview: "\u0AAA\u0AC2\u0AB0\u0ACD\u0AB5\u0ABE\u0AB5\u0AB2\u0ACB\u0A95\u0AA8",
+  download: "\u0AA1\u0ABE\u0A89\u0AA8\u0AB2\u0ACB\u0AA1",
+  edit: "\u0AB8\u0A82\u0AAA\u0ABE\u0AA6\u0ABF\u0AA4 \u0A95\u0AB0\u0ACB",
+  save: "\u0AB8\u0ABE\u0A9A\u0AB5\u0ACB",
+  fullscreen: "\u0AB8\u0A82\u0AAA\u0AC2\u0AB0\u0ACD\u0AA3 \u0AB8\u0ACD\u0A95\u0ACD\u0AB0\u0AC0\u0AA8",
+  rename: "\u0AA8\u0ABE\u0AAE \u0AAC\u0AA6\u0AB2\u0ACB",
+  tags: "\u0A9F\u0AC5\u0A97\u0ACD\u0AB8",
+  description: "\u0AB5\u0AB0\u0ACD\u0AA3\u0AA8",
+  category: "\u0AB6\u0ACD\u0AB0\u0AC7\u0AA3\u0AC0",
+  addTag: "\u0A9F\u0AC5\u0A97 \u0A89\u0AAE\u0AC7\u0AB0\u0ACB",
+  fileTooLarge: "\u0AAB\u0ABE\u0A87\u0AB2 \u0AAC\u0AB9\u0AC1 \u0AAE\u0ACB\u0A9F\u0AC0 \u0A9B\u0AC7",
+  fileTooSmall: "\u0AAB\u0ABE\u0A87\u0AB2 \u0AAC\u0AB9\u0AC1 \u0AA8\u0ABE\u0AA8\u0AC0 \u0A9B\u0AC7",
+  invalidType: "\u0AAB\u0ABE\u0A87\u0AB2 \u0AAA\u0ACD\u0AB0\u0A95\u0ABE\u0AB0 \u0AAE\u0A82\u0A9C\u0AC2\u0AB0 \u0AA8\u0AA5\u0AC0",
+  tooManyFiles: "\u0A98\u0AA3\u0AC0 \u0AAC\u0AA7\u0AC0 \u0AAB\u0ABE\u0A87\u0AB2\u0ACB",
+  duplicateFile: "\u0AA1\u0AC1\u0AAA\u0ACD\u0AB2\u0ABF\u0A95\u0AC7\u0A9F \u0AAB\u0ABE\u0A87\u0AB2",
+  speed: "\u0A9D\u0AA1\u0AAA",
+  eta: "\u0A85\u0A82\u0AA6\u0ABE\u0A9C\u0ABF\u0AA4 \u0AB8\u0AAE\u0AAF",
+  ofText: "\u0AAE\u0ABE\u0A82\u0AA5\u0AC0",
+  filesText: "\u0AAB\u0ABE\u0A87\u0AB2\u0ACB",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var fr = {
+  dropHere: "D\xE9posez les fichiers ici",
+  dragOrClick: "Glissez-d\xE9posez ou cliquez pour parcourir",
+  browse: "Parcourir",
+  uploading: "Envoi en cours",
+  paused: "En pause",
+  success: "Envoy\xE9",
+  error: "\xC9chec",
+  retry: "R\xE9essayer",
+  pause: "Pause",
+  resume: "Reprendre",
+  cancel: "Annuler",
+  remove: "Supprimer",
+  removeAll: "Tout supprimer",
+  preview: "Aper\xE7u",
+  download: "T\xE9l\xE9charger",
+  edit: "Modifier",
+  save: "Enregistrer",
+  fullscreen: "Plein \xE9cran",
+  rename: "Renommer",
+  tags: "\xC9tiquettes",
+  description: "Description",
+  category: "Cat\xE9gorie",
+  addTag: "Ajouter une \xE9tiquette",
+  fileTooLarge: "Fichier trop volumineux",
+  fileTooSmall: "Fichier trop petit",
+  invalidType: "Type de fichier non autoris\xE9",
+  tooManyFiles: "Trop de fichiers",
+  duplicateFile: "Fichier en double",
+  speed: "Vitesse",
+  eta: "Restant",
+  ofText: "sur",
+  filesText: "fichiers",
+  bytes: "o",
+  kb: "Ko",
+  mb: "Mo",
+  gb: "Go"
+};
+var de = {
+  dropHere: "Dateien hier ablegen",
+  dragOrClick: "Dateien ablegen oder klicken zum Ausw\xE4hlen",
+  browse: "Dateien ausw\xE4hlen",
+  uploading: "Wird hochgeladen",
+  paused: "Angehalten",
+  success: "Hochgeladen",
+  error: "Fehler",
+  retry: "Erneut versuchen",
+  pause: "Pause",
+  resume: "Fortsetzen",
+  cancel: "Abbrechen",
+  remove: "Entfernen",
+  removeAll: "Alle entfernen",
+  preview: "Vorschau",
+  download: "Herunterladen",
+  edit: "Bearbeiten",
+  save: "Speichern",
+  fullscreen: "Vollbild",
+  rename: "Umbenennen",
+  tags: "Tags",
+  description: "Beschreibung",
+  category: "Kategorie",
+  addTag: "Tag hinzuf\xFCgen",
+  fileTooLarge: "Datei ist zu gro\xDF",
+  fileTooSmall: "Datei ist zu klein",
+  invalidType: "Dateityp nicht zul\xE4ssig",
+  tooManyFiles: "Zu viele Dateien",
+  duplicateFile: "Doppelte Datei",
+  speed: "Geschwindigkeit",
+  eta: "Verbleibend",
+  ofText: "von",
+  filesText: "Dateien",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var ar = {
+  dropHere: "\u0623\u0641\u0644\u062A \u0627\u0644\u0645\u0644\u0641\u0627\u062A \u0647\u0646\u0627",
+  dragOrClick: "\u0627\u0633\u062D\u0628 \u0648\u0623\u0641\u0644\u062A \u0627\u0644\u0645\u0644\u0641\u0627\u062A \u0623\u0648 \u0627\u0646\u0642\u0631 \u0644\u0644\u062A\u0635\u0641\u062D",
+  browse: "\u062A\u0635\u0641\u062D \u0627\u0644\u0645\u0644\u0641\u0627\u062A",
+  uploading: "\u062C\u0627\u0631\u064A \u0627\u0644\u0631\u0641\u0639",
+  paused: "\u0645\u062A\u0648\u0642\u0641",
+  success: "\u062A\u0645 \u0627\u0644\u0631\u0641\u0639",
+  error: "\u0641\u0634\u0644",
+  retry: "\u0625\u0639\u0627\u062F\u0629",
+  pause: "\u0625\u064A\u0642\u0627\u0641",
+  resume: "\u0627\u0633\u062A\u0626\u0646\u0627\u0641",
+  cancel: "\u0625\u0644\u063A\u0627\u0621",
+  remove: "\u0625\u0632\u0627\u0644\u0629",
+  removeAll: "\u0625\u0632\u0627\u0644\u0629 \u0627\u0644\u0643\u0644",
+  preview: "\u0645\u0639\u0627\u064A\u0646\u0629",
+  download: "\u062A\u0646\u0632\u064A\u0644",
+  edit: "\u062A\u062D\u0631\u064A\u0631",
+  save: "\u062D\u0641\u0638",
+  fullscreen: "\u0645\u0644\u0621 \u0627\u0644\u0634\u0627\u0634\u0629",
+  rename: "\u0625\u0639\u0627\u062F\u0629 \u062A\u0633\u0645\u064A\u0629",
+  tags: "\u0639\u0644\u0627\u0645\u0627\u062A",
+  description: "\u0627\u0644\u0648\u0635\u0641",
+  category: "\u0627\u0644\u0641\u0626\u0629",
+  addTag: "\u0625\u0636\u0627\u0641\u0629 \u0639\u0644\u0627\u0645\u0629",
+  fileTooLarge: "\u0627\u0644\u0645\u0644\u0641 \u0643\u0628\u064A\u0631 \u062C\u062F\u064B\u0627",
+  fileTooSmall: "\u0627\u0644\u0645\u0644\u0641 \u0635\u063A\u064A\u0631 \u062C\u062F\u064B\u0627",
+  invalidType: "\u0646\u0648\u0639 \u0627\u0644\u0645\u0644\u0641 \u063A\u064A\u0631 \u0645\u0633\u0645\u0648\u062D",
+  tooManyFiles: "\u0627\u0644\u0643\u062B\u064A\u0631 \u0645\u0646 \u0627\u0644\u0645\u0644\u0641\u0627\u062A",
+  duplicateFile: "\u0645\u0644\u0641 \u0645\u0643\u0631\u0631",
+  speed: "\u0627\u0644\u0633\u0631\u0639\u0629",
+  eta: "\u0627\u0644\u0648\u0642\u062A \u0627\u0644\u0645\u062A\u0628\u0642\u064A",
+  ofText: "\u0645\u0646",
+  filesText: "\u0645\u0644\u0641\u0627\u062A",
+  bytes: "\u0628\u0627\u064A\u062A",
+  kb: "\u0643.\u0628",
+  mb: "\u0645.\u0628",
+  gb: "\u062C.\u0628"
+};
+var zh = {
+  dropHere: "\u5C06\u6587\u4EF6\u62D6\u653E\u5230\u6B64\u5904",
+  dragOrClick: "\u62D6\u653E\u6587\u4EF6\u6216\u70B9\u51FB\u6D4F\u89C8",
+  browse: "\u6D4F\u89C8\u6587\u4EF6",
+  uploading: "\u4E0A\u4F20\u4E2D",
+  paused: "\u5DF2\u6682\u505C",
+  success: "\u5DF2\u4E0A\u4F20",
+  error: "\u5931\u8D25",
+  retry: "\u91CD\u8BD5",
+  pause: "\u6682\u505C",
+  resume: "\u7EE7\u7EED",
+  cancel: "\u53D6\u6D88",
+  remove: "\u79FB\u9664",
+  removeAll: "\u5168\u90E8\u79FB\u9664",
+  preview: "\u9884\u89C8",
+  download: "\u4E0B\u8F7D",
+  edit: "\u7F16\u8F91",
+  save: "\u4FDD\u5B58",
+  fullscreen: "\u5168\u5C4F",
+  rename: "\u91CD\u547D\u540D",
+  tags: "\u6807\u7B7E",
+  description: "\u63CF\u8FF0",
+  category: "\u7C7B\u522B",
+  addTag: "\u6DFB\u52A0\u6807\u7B7E",
+  fileTooLarge: "\u6587\u4EF6\u8FC7\u5927",
+  fileTooSmall: "\u6587\u4EF6\u8FC7\u5C0F",
+  invalidType: "\u4E0D\u5141\u8BB8\u7684\u6587\u4EF6\u7C7B\u578B",
+  tooManyFiles: "\u6587\u4EF6\u8FC7\u591A",
+  duplicateFile: "\u91CD\u590D\u6587\u4EF6",
+  speed: "\u901F\u5EA6",
+  eta: "\u5269\u4F59\u65F6\u95F4",
+  ofText: "/",
+  filesText: "\u4E2A\u6587\u4EF6",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var es = {
+  dropHere: "Suelta los archivos aqu\xED",
+  dragOrClick: "Arrastra y suelta archivos o haz clic para explorar",
+  browse: "Explorar archivos",
+  uploading: "Subiendo",
+  paused: "Pausado",
+  success: "Subido",
+  error: "Error",
+  retry: "Reintentar",
+  pause: "Pausar",
+  resume: "Reanudar",
+  cancel: "Cancelar",
+  remove: "Eliminar",
+  removeAll: "Eliminar todo",
+  preview: "Vista previa",
+  download: "Descargar",
+  edit: "Editar",
+  save: "Guardar",
+  fullscreen: "Pantalla completa",
+  rename: "Renombrar",
+  tags: "Etiquetas",
+  description: "Descripci\xF3n",
+  category: "Categor\xEDa",
+  addTag: "A\xF1adir etiqueta",
+  fileTooLarge: "El archivo es demasiado grande",
+  fileTooSmall: "El archivo es demasiado peque\xF1o",
+  invalidType: "Tipo de archivo no permitido",
+  tooManyFiles: "Demasiados archivos",
+  duplicateFile: "Archivo duplicado",
+  speed: "Velocidad",
+  eta: "Restante",
+  ofText: "de",
+  filesText: "archivos",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var pt = {
+  dropHere: "Solte os arquivos aqui",
+  dragOrClick: "Arraste e solte arquivos ou clique para procurar",
+  browse: "Procurar arquivos",
+  uploading: "Enviando",
+  paused: "Pausado",
+  success: "Enviado",
+  error: "Falhou",
+  retry: "Tentar novamente",
+  pause: "Pausar",
+  resume: "Retomar",
+  cancel: "Cancelar",
+  remove: "Remover",
+  removeAll: "Remover todos",
+  preview: "Pr\xE9-visualizar",
+  download: "Baixar",
+  edit: "Editar",
+  save: "Salvar",
+  fullscreen: "Tela cheia",
+  rename: "Renomear",
+  tags: "Etiquetas",
+  description: "Descri\xE7\xE3o",
+  category: "Categoria",
+  addTag: "Adicionar etiqueta",
+  fileTooLarge: "Arquivo muito grande",
+  fileTooSmall: "Arquivo muito pequeno",
+  invalidType: "Tipo de arquivo n\xE3o permitido",
+  tooManyFiles: "Muitos arquivos",
+  duplicateFile: "Arquivo duplicado",
+  speed: "Velocidade",
+  eta: "Restante",
+  ofText: "de",
+  filesText: "arquivos",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var ru = {
+  dropHere: "\u041F\u0435\u0440\u0435\u0442\u0430\u0449\u0438\u0442\u0435 \u0444\u0430\u0439\u043B\u044B \u0441\u044E\u0434\u0430",
+  dragOrClick: "\u041F\u0435\u0440\u0435\u0442\u0430\u0449\u0438\u0442\u0435 \u0444\u0430\u0439\u043B\u044B \u0438\u043B\u0438 \u043D\u0430\u0436\u043C\u0438\u0442\u0435 \u0434\u043B\u044F \u0432\u044B\u0431\u043E\u0440\u0430",
+  browse: "\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u0444\u0430\u0439\u043B\u044B",
+  uploading: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430",
+  paused: "\u041F\u0440\u0438\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043E",
+  success: "\u0417\u0430\u0433\u0440\u0443\u0436\u0435\u043D\u043E",
+  error: "\u041E\u0448\u0438\u0431\u043A\u0430",
+  retry: "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u044C",
+  pause: "\u041F\u0430\u0443\u0437\u0430",
+  resume: "\u041F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C",
+  cancel: "\u041E\u0442\u043C\u0435\u043D\u0430",
+  remove: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C",
+  removeAll: "\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u0432\u0441\u0435",
+  preview: "\u041F\u0440\u0435\u0434\u043F\u0440\u043E\u0441\u043C\u043E\u0442\u0440",
+  download: "\u0421\u043A\u0430\u0447\u0430\u0442\u044C",
+  edit: "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C",
+  save: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C",
+  fullscreen: "\u041F\u043E\u043B\u043D\u044B\u0439 \u044D\u043A\u0440\u0430\u043D",
+  rename: "\u041F\u0435\u0440\u0435\u0438\u043C\u0435\u043D\u043E\u0432\u0430\u0442\u044C",
+  tags: "\u0422\u0435\u0433\u0438",
+  description: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435",
+  category: "\u041A\u0430\u0442\u0435\u0433\u043E\u0440\u0438\u044F",
+  addTag: "\u0414\u043E\u0431\u0430\u0432\u0438\u0442\u044C \u0442\u0435\u0433",
+  fileTooLarge: "\u0424\u0430\u0439\u043B \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0439",
+  fileTooSmall: "\u0424\u0430\u0439\u043B \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u0438\u0439",
+  invalidType: "\u0422\u0438\u043F \u0444\u0430\u0439\u043B\u0430 \u043D\u0435 \u0440\u0430\u0437\u0440\u0435\u0448\u0451\u043D",
+  tooManyFiles: "\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u043D\u043E\u0433\u043E \u0444\u0430\u0439\u043B\u043E\u0432",
+  duplicateFile: "\u0414\u0443\u0431\u043B\u0438\u0440\u0443\u044E\u0449\u0438\u0439 \u0444\u0430\u0439\u043B",
+  speed: "\u0421\u043A\u043E\u0440\u043E\u0441\u0442\u044C",
+  eta: "\u041E\u0441\u0442\u0430\u043B\u043E\u0441\u044C",
+  ofText: "\u0438\u0437",
+  filesText: "\u0444\u0430\u0439\u043B\u043E\u0432",
+  bytes: "\u0411",
+  kb: "\u041A\u0411",
+  mb: "\u041C\u0411",
+  gb: "\u0413\u0411"
+};
+var ja = {
+  dropHere: "\u3053\u3053\u306B\u30D5\u30A1\u30A4\u30EB\u3092\u30C9\u30ED\u30C3\u30D7",
+  dragOrClick: "\u30D5\u30A1\u30A4\u30EB\u3092\u30C9\u30E9\u30C3\u30B0\uFF06\u30C9\u30ED\u30C3\u30D7\u307E\u305F\u306F\u30AF\u30EA\u30C3\u30AF\u3057\u3066\u9078\u629E",
+  browse: "\u30D5\u30A1\u30A4\u30EB\u3092\u9078\u629E",
+  uploading: "\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u4E2D",
+  paused: "\u4E00\u6642\u505C\u6B62",
+  success: "\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u5B8C\u4E86",
+  error: "\u5931\u6557",
+  retry: "\u518D\u8A66\u884C",
+  pause: "\u4E00\u6642\u505C\u6B62",
+  resume: "\u518D\u958B",
+  cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB",
+  remove: "\u524A\u9664",
+  removeAll: "\u3059\u3079\u3066\u524A\u9664",
+  preview: "\u30D7\u30EC\u30D3\u30E5\u30FC",
+  download: "\u30C0\u30A6\u30F3\u30ED\u30FC\u30C9",
+  edit: "\u7DE8\u96C6",
+  save: "\u4FDD\u5B58",
+  fullscreen: "\u5168\u753B\u9762",
+  rename: "\u540D\u524D\u3092\u5909\u66F4",
+  tags: "\u30BF\u30B0",
+  description: "\u8AAC\u660E",
+  category: "\u30AB\u30C6\u30B4\u30EA\u30FC",
+  addTag: "\u30BF\u30B0\u3092\u8FFD\u52A0",
+  fileTooLarge: "\u30D5\u30A1\u30A4\u30EB\u304C\u5927\u304D\u3059\u304E\u307E\u3059",
+  fileTooSmall: "\u30D5\u30A1\u30A4\u30EB\u304C\u5C0F\u3055\u3059\u304E\u307E\u3059",
+  invalidType: "\u8A31\u53EF\u3055\u308C\u3066\u3044\u306A\u3044\u30D5\u30A1\u30A4\u30EB\u5F62\u5F0F",
+  tooManyFiles: "\u30D5\u30A1\u30A4\u30EB\u6570\u304C\u591A\u3059\u304E\u307E\u3059",
+  duplicateFile: "\u91CD\u8907\u30D5\u30A1\u30A4\u30EB",
+  speed: "\u901F\u5EA6",
+  eta: "\u6B8B\u308A\u6642\u9593",
+  ofText: "/",
+  filesText: "\u30D5\u30A1\u30A4\u30EB",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var ko = {
+  dropHere: "\uC5EC\uAE30\uC5D0 \uD30C\uC77C\uC744 \uB193\uC73C\uC138\uC694",
+  dragOrClick: "\uD30C\uC77C\uC744 \uB04C\uC5B4\uB2E4 \uB193\uAC70\uB098 \uD074\uB9AD\uD558\uC5EC \uC120\uD0DD",
+  browse: "\uD30C\uC77C \uCC3E\uC544\uBCF4\uAE30",
+  uploading: "\uC5C5\uB85C\uB4DC \uC911",
+  paused: "\uC77C\uC2DC \uC911\uC9C0\uB428",
+  success: "\uC5C5\uB85C\uB4DC\uB428",
+  error: "\uC2E4\uD328",
+  retry: "\uB2E4\uC2DC \uC2DC\uB3C4",
+  pause: "\uC77C\uC2DC \uC911\uC9C0",
+  resume: "\uC7AC\uAC1C",
+  cancel: "\uCDE8\uC18C",
+  remove: "\uC81C\uAC70",
+  removeAll: "\uBAA8\uB450 \uC81C\uAC70",
+  preview: "\uBBF8\uB9AC\uBCF4\uAE30",
+  download: "\uB2E4\uC6B4\uB85C\uB4DC",
+  edit: "\uD3B8\uC9D1",
+  save: "\uC800\uC7A5",
+  fullscreen: "\uC804\uCCB4 \uD654\uBA74",
+  rename: "\uC774\uB984 \uBCC0\uACBD",
+  tags: "\uD0DC\uADF8",
+  description: "\uC124\uBA85",
+  category: "\uCE74\uD14C\uACE0\uB9AC",
+  addTag: "\uD0DC\uADF8 \uCD94\uAC00",
+  fileTooLarge: "\uD30C\uC77C\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4",
+  fileTooSmall: "\uD30C\uC77C\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4",
+  invalidType: "\uD5C8\uC6A9\uB418\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD",
+  tooManyFiles: "\uD30C\uC77C\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4",
+  duplicateFile: "\uC911\uBCF5 \uD30C\uC77C",
+  speed: "\uC18D\uB3C4",
+  eta: "\uB0A8\uC740 \uC2DC\uAC04",
+  ofText: "/",
+  filesText: "\uAC1C \uD30C\uC77C",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var it = {
+  dropHere: "Trascina i file qui",
+  dragOrClick: "Trascina i file o clicca per sfogliare",
+  browse: "Sfoglia file",
+  uploading: "Caricamento in corso",
+  paused: "In pausa",
+  success: "Caricato",
+  error: "Errore",
+  retry: "Riprova",
+  pause: "Pausa",
+  resume: "Riprendi",
+  cancel: "Annulla",
+  remove: "Rimuovi",
+  removeAll: "Rimuovi tutto",
+  preview: "Anteprima",
+  download: "Scarica",
+  edit: "Modifica",
+  save: "Salva",
+  fullscreen: "Schermo intero",
+  rename: "Rinomina",
+  tags: "Etichette",
+  description: "Descrizione",
+  category: "Categoria",
+  addTag: "Aggiungi etichetta",
+  fileTooLarge: "File troppo grande",
+  fileTooSmall: "File troppo piccolo",
+  invalidType: "Tipo di file non consentito",
+  tooManyFiles: "Troppi file",
+  duplicateFile: "File duplicato",
+  speed: "Velocit\xE0",
+  eta: "Rimanente",
+  ofText: "di",
+  filesText: "file",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var tr = {
+  dropHere: "Dosyalar\u0131 buraya b\u0131rak\u0131n",
+  dragOrClick: "Dosyalar\u0131 s\xFCr\xFCkleyip b\u0131rak\u0131n veya g\xF6zatmak i\xE7in t\u0131klay\u0131n",
+  browse: "Dosyalara g\xF6zat",
+  uploading: "Y\xFCkleniyor",
+  paused: "Duraklat\u0131ld\u0131",
+  success: "Y\xFCklendi",
+  error: "Ba\u015Far\u0131s\u0131z",
+  retry: "Tekrar dene",
+  pause: "Duraklat",
+  resume: "Devam et",
+  cancel: "\u0130ptal",
+  remove: "Kald\u0131r",
+  removeAll: "T\xFCm\xFCn\xFC kald\u0131r",
+  preview: "\xD6nizleme",
+  download: "\u0130ndir",
+  edit: "D\xFCzenle",
+  save: "Kaydet",
+  fullscreen: "Tam ekran",
+  rename: "Yeniden adland\u0131r",
+  tags: "Etiketler",
+  description: "A\xE7\u0131klama",
+  category: "Kategori",
+  addTag: "Etiket ekle",
+  fileTooLarge: "Dosya \xE7ok b\xFCy\xFCk",
+  fileTooSmall: "Dosya \xE7ok k\xFC\xE7\xFCk",
+  invalidType: "Dosya t\xFCr\xFCne izin verilmiyor",
+  tooManyFiles: "\xC7ok fazla dosya",
+  duplicateFile: "Yinelenen dosya",
+  speed: "H\u0131z",
+  eta: "Kalan s\xFCre",
+  ofText: "/",
+  filesText: "dosya",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var id = {
+  dropHere: "Letakkan file di sini",
+  dragOrClick: "Seret & lepas file atau klik untuk menjelajah",
+  browse: "Jelajahi file",
+  uploading: "Mengunggah",
+  paused: "Dijeda",
+  success: "Diunggah",
+  error: "Gagal",
+  retry: "Coba lagi",
+  pause: "Jeda",
+  resume: "Lanjutkan",
+  cancel: "Batal",
+  remove: "Hapus",
+  removeAll: "Hapus semua",
+  preview: "Pratinjau",
+  download: "Unduh",
+  edit: "Ubah",
+  save: "Simpan",
+  fullscreen: "Layar penuh",
+  rename: "Ganti nama",
+  tags: "Tag",
+  description: "Deskripsi",
+  category: "Kategori",
+  addTag: "Tambah tag",
+  fileTooLarge: "File terlalu besar",
+  fileTooSmall: "File terlalu kecil",
+  invalidType: "Tipe file tidak diizinkan",
+  tooManyFiles: "Terlalu banyak file",
+  duplicateFile: "File duplikat",
+  speed: "Kecepatan",
+  eta: "Sisa waktu",
+  ofText: "dari",
+  filesText: "file",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var bn = {
+  dropHere: "\u098F\u0996\u09BE\u09A8\u09C7 \u09AB\u09BE\u0987\u09B2 \u099B\u09BE\u09A1\u09BC\u09C1\u09A8",
+  dragOrClick: "\u09AB\u09BE\u0987\u09B2 \u099F\u09C7\u09A8\u09C7 \u0986\u09A8\u09C1\u09A8 \u09AC\u09BE \u09AC\u09CD\u09B0\u09BE\u0989\u099C \u0995\u09B0\u09A4\u09C7 \u0995\u09CD\u09B2\u09BF\u0995 \u0995\u09B0\u09C1\u09A8",
+  browse: "\u09AB\u09BE\u0987\u09B2 \u09AC\u09CD\u09B0\u09BE\u0989\u099C \u0995\u09B0\u09C1\u09A8",
+  uploading: "\u0986\u09AA\u09B2\u09CB\u09A1 \u09B9\u099A\u09CD\u099B\u09C7",
+  paused: "\u09AC\u09BF\u09B0\u09A4\u09BF",
+  success: "\u0986\u09AA\u09B2\u09CB\u09A1 \u09B9\u09AF\u09BC\u09C7\u099B\u09C7",
+  error: "\u09AC\u09CD\u09AF\u09B0\u09CD\u09A5",
+  retry: "\u09AA\u09C1\u09A8\u09B0\u09BE\u09AF\u09BC \u099A\u09C7\u09B7\u09CD\u099F\u09BE",
+  pause: "\u09AC\u09BF\u09B0\u09A4\u09BF",
+  resume: "\u09AA\u09C1\u09A8\u09B0\u09BE\u09AF\u09BC \u09B6\u09C1\u09B0\u09C1",
+  cancel: "\u09AC\u09BE\u09A4\u09BF\u09B2",
+  remove: "\u09B8\u09B0\u09BE\u09A8",
+  removeAll: "\u09B8\u09AC \u09B8\u09B0\u09BE\u09A8",
+  preview: "\u09AA\u09C2\u09B0\u09CD\u09AC\u09B0\u09C2\u09AA",
+  download: "\u09A1\u09BE\u0989\u09A8\u09B2\u09CB\u09A1",
+  edit: "\u09B8\u09AE\u09CD\u09AA\u09BE\u09A6\u09A8\u09BE",
+  save: "\u09B8\u0982\u09B0\u0995\u09CD\u09B7\u09A3",
+  fullscreen: "\u09AA\u09C2\u09B0\u09CD\u09A3 \u09B8\u09CD\u0995\u09CD\u09B0\u09BF\u09A8",
+  rename: "\u09A8\u09BE\u09AE \u09AA\u09B0\u09BF\u09AC\u09B0\u09CD\u09A4\u09A8",
+  tags: "\u099F\u09CD\u09AF\u09BE\u0997",
+  description: "\u09AC\u09BF\u09AC\u09B0\u09A3",
+  category: "\u09AC\u09BF\u09AD\u09BE\u0997",
+  addTag: "\u099F\u09CD\u09AF\u09BE\u0997 \u09AF\u09CB\u0997 \u0995\u09B0\u09C1\u09A8",
+  fileTooLarge: "\u09AB\u09BE\u0987\u09B2\u099F\u09BF \u0996\u09C1\u09AC \u09AC\u09A1\u09BC",
+  fileTooSmall: "\u09AB\u09BE\u0987\u09B2\u099F\u09BF \u0996\u09C1\u09AC \u099B\u09CB\u099F",
+  invalidType: "\u09AB\u09BE\u0987\u09B2\u09C7\u09B0 \u09AA\u09CD\u09B0\u0995\u09BE\u09B0 \u0985\u09A8\u09C1\u09AE\u09CB\u09A6\u09BF\u09A4 \u09A8\u09AF\u09BC",
+  tooManyFiles: "\u0985\u09A8\u09C7\u0995 \u09AC\u09C7\u09B6\u09BF \u09AB\u09BE\u0987\u09B2",
+  duplicateFile: "\u09A8\u0995\u09B2 \u09AB\u09BE\u0987\u09B2",
+  speed: "\u0997\u09A4\u09BF",
+  eta: "\u09AC\u09BE\u0995\u09BF \u09B8\u09AE\u09AF\u09BC",
+  ofText: "\u098F\u09B0",
+  filesText: "\u09AB\u09BE\u0987\u09B2",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var ur = {
+  dropHere: "\u0641\u0627\u0626\u0644\u06CC\u06BA \u06CC\u06C1\u0627\u06BA \u0686\u06BE\u0648\u0691\u06CC\u06BA",
+  dragOrClick: "\u0641\u0627\u0626\u0644\u06CC\u06BA \u06AF\u06BE\u0633\u06CC\u0679\u06CC\u06BA \u0627\u0648\u0631 \u0686\u06BE\u0648\u0691\u06CC\u06BA \u06CC\u0627 \u0628\u0631\u0627\u0624\u0632 \u06A9\u0631\u0646\u06D2 \u06A9\u06D2 \u0644\u06CC\u06D2 \u06A9\u0644\u06A9 \u06A9\u0631\u06CC\u06BA",
+  browse: "\u0641\u0627\u0626\u0644\u06CC\u06BA \u0628\u0631\u0627\u0624\u0632 \u06A9\u0631\u06CC\u06BA",
+  uploading: "\u0627\u067E \u0644\u0648\u0688 \u06C1\u0648 \u0631\u06C1\u0627 \u06C1\u06D2",
+  paused: "\u0631\u0648\u06A9 \u062F\u06CC\u0627 \u06AF\u06CC\u0627",
+  success: "\u0627\u067E \u0644\u0648\u0688 \u06C1\u0648 \u06AF\u06CC\u0627",
+  error: "\u0646\u0627\u06A9\u0627\u0645",
+  retry: "\u062F\u0648\u0628\u0627\u0631\u06C1 \u06A9\u0648\u0634\u0634",
+  pause: "\u0631\u0648\u06A9\u06CC\u06BA",
+  resume: "\u062C\u0627\u0631\u06CC \u0631\u06A9\u06BE\u06CC\u06BA",
+  cancel: "\u0645\u0646\u0633\u0648\u062E",
+  remove: "\u06C1\u0679\u0627\u0626\u06CC\u06BA",
+  removeAll: "\u0633\u0628 \u06C1\u0679\u0627\u0626\u06CC\u06BA",
+  preview: "\u067E\u06CC\u0634 \u0646\u0638\u0627\u0631\u06C1",
+  download: "\u0688\u0627\u0624\u0646 \u0644\u0648\u0688",
+  edit: "\u062A\u0631\u0645\u06CC\u0645",
+  save: "\u0645\u062D\u0641\u0648\u0638 \u06A9\u0631\u06CC\u06BA",
+  fullscreen: "\u067E\u0648\u0631\u06CC \u0627\u0633\u06A9\u0631\u06CC\u0646",
+  rename: "\u0646\u0627\u0645 \u062A\u0628\u062F\u06CC\u0644 \u06A9\u0631\u06CC\u06BA",
+  tags: "\u0679\u06CC\u06AF\u0632",
+  description: "\u062A\u0641\u0635\u06CC\u0644",
+  category: "\u0632\u0645\u0631\u06C1",
+  addTag: "\u0679\u06CC\u06AF \u0634\u0627\u0645\u0644 \u06A9\u0631\u06CC\u06BA",
+  fileTooLarge: "\u0641\u0627\u0626\u0644 \u0628\u06C1\u062A \u0628\u0691\u06CC \u06C1\u06D2",
+  fileTooSmall: "\u0641\u0627\u0626\u0644 \u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u06CC \u06C1\u06D2",
+  invalidType: "\u0641\u0627\u0626\u0644 \u06A9\u06CC \u0642\u0633\u0645 \u06A9\u06CC \u0627\u062C\u0627\u0632\u062A \u0646\u06C1\u06CC\u06BA",
+  tooManyFiles: "\u0628\u06C1\u062A \u0632\u06CC\u0627\u062F\u06C1 \u0641\u0627\u0626\u0644\u06CC\u06BA",
+  duplicateFile: "\u0688\u067E\u0644\u06CC\u06A9\u06CC\u0679 \u0641\u0627\u0626\u0644",
+  speed: "\u0631\u0641\u062A\u0627\u0631",
+  eta: "\u0628\u0627\u0642\u06CC \u0648\u0642\u062A",
+  ofText: "\u0645\u06CC\u06BA \u0633\u06D2",
+  filesText: "\u0641\u0627\u0626\u0644\u06CC\u06BA",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var nl = {
+  dropHere: "Zet bestanden hier neer",
+  dragOrClick: "Sleep bestanden of klik om te bladeren",
+  browse: "Bladeren",
+  uploading: "Uploaden",
+  paused: "Gepauzeerd",
+  success: "Ge\xFCpload",
+  error: "Mislukt",
+  retry: "Opnieuw proberen",
+  pause: "Pauze",
+  resume: "Hervatten",
+  cancel: "Annuleren",
+  remove: "Verwijderen",
+  removeAll: "Alles verwijderen",
+  preview: "Voorbeeld",
+  download: "Downloaden",
+  edit: "Bewerken",
+  save: "Opslaan",
+  fullscreen: "Volledig scherm",
+  rename: "Hernoemen",
+  tags: "Tags",
+  description: "Beschrijving",
+  category: "Categorie",
+  addTag: "Tag toevoegen",
+  fileTooLarge: "Bestand is te groot",
+  fileTooSmall: "Bestand is te klein",
+  invalidType: "Bestandstype niet toegestaan",
+  tooManyFiles: "Te veel bestanden",
+  duplicateFile: "Dubbel bestand",
+  speed: "Snelheid",
+  eta: "Resterend",
+  ofText: "van",
+  filesText: "bestanden",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var pl = {
+  dropHere: "Upu\u015B\u0107 pliki tutaj",
+  dragOrClick: "Przeci\u0105gnij i upu\u015B\u0107 pliki lub kliknij, aby przegl\u0105da\u0107",
+  browse: "Przegl\u0105daj pliki",
+  uploading: "Przesy\u0142anie",
+  paused: "Wstrzymane",
+  success: "Przes\u0142ano",
+  error: "B\u0142\u0105d",
+  retry: "Pon\xF3w",
+  pause: "Wstrzymaj",
+  resume: "Wzn\xF3w",
+  cancel: "Anuluj",
+  remove: "Usu\u0144",
+  removeAll: "Usu\u0144 wszystko",
+  preview: "Podgl\u0105d",
+  download: "Pobierz",
+  edit: "Edytuj",
+  save: "Zapisz",
+  fullscreen: "Pe\u0142ny ekran",
+  rename: "Zmie\u0144 nazw\u0119",
+  tags: "Tagi",
+  description: "Opis",
+  category: "Kategoria",
+  addTag: "Dodaj tag",
+  fileTooLarge: "Plik jest za du\u017Cy",
+  fileTooSmall: "Plik jest za ma\u0142y",
+  invalidType: "Typ pliku niedozwolony",
+  tooManyFiles: "Za du\u017Co plik\xF3w",
+  duplicateFile: "Duplikat pliku",
+  speed: "Pr\u0119dko\u015B\u0107",
+  eta: "Pozosta\u0142o",
+  ofText: "z",
+  filesText: "plik\xF3w",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var vi = {
+  dropHere: "Th\u1EA3 t\u1EC7p v\xE0o \u0111\xE2y",
+  dragOrClick: "K\xE9o & th\u1EA3 t\u1EC7p ho\u1EB7c nh\u1EA5p \u0111\u1EC3 duy\u1EC7t",
+  browse: "Duy\u1EC7t t\u1EC7p",
+  uploading: "\u0110ang t\u1EA3i l\xEAn",
+  paused: "\u0110\xE3 t\u1EA1m d\u1EEBng",
+  success: "\u0110\xE3 t\u1EA3i l\xEAn",
+  error: "Th\u1EA5t b\u1EA1i",
+  retry: "Th\u1EED l\u1EA1i",
+  pause: "T\u1EA1m d\u1EEBng",
+  resume: "Ti\u1EBFp t\u1EE5c",
+  cancel: "H\u1EE7y",
+  remove: "X\xF3a",
+  removeAll: "X\xF3a t\u1EA5t c\u1EA3",
+  preview: "Xem tr\u01B0\u1EDBc",
+  download: "T\u1EA3i xu\u1ED1ng",
+  edit: "S\u1EEDa",
+  save: "L\u01B0u",
+  fullscreen: "To\xE0n m\xE0n h\xECnh",
+  rename: "\u0110\u1ED5i t\xEAn",
+  tags: "Th\u1EBB",
+  description: "M\xF4 t\u1EA3",
+  category: "Danh m\u1EE5c",
+  addTag: "Th\xEAm th\u1EBB",
+  fileTooLarge: "T\u1EC7p qu\xE1 l\u1EDBn",
+  fileTooSmall: "T\u1EC7p qu\xE1 nh\u1ECF",
+  invalidType: "Lo\u1EA1i t\u1EC7p kh\xF4ng \u0111\u01B0\u1EE3c ph\xE9p",
+  tooManyFiles: "Qu\xE1 nhi\u1EC1u t\u1EC7p",
+  duplicateFile: "T\u1EC7p tr\xF9ng l\u1EB7p",
+  speed: "T\u1ED1c \u0111\u1ED9",
+  eta: "C\xF2n l\u1EA1i",
+  ofText: "c\u1EE7a",
+  filesText: "t\u1EC7p",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var th = {
+  dropHere: "\u0E27\u0E32\u0E07\u0E44\u0E1F\u0E25\u0E4C\u0E17\u0E35\u0E48\u0E19\u0E35\u0E48",
+  dragOrClick: "\u0E25\u0E32\u0E01\u0E41\u0E25\u0E30\u0E27\u0E32\u0E07\u0E44\u0E1F\u0E25\u0E4C\u0E2B\u0E23\u0E37\u0E2D\u0E04\u0E25\u0E34\u0E01\u0E40\u0E1E\u0E37\u0E48\u0E2D\u0E40\u0E23\u0E35\u0E22\u0E01\u0E14\u0E39",
+  browse: "\u0E40\u0E23\u0E35\u0E22\u0E01\u0E14\u0E39\u0E44\u0E1F\u0E25\u0E4C",
+  uploading: "\u0E01\u0E33\u0E25\u0E31\u0E07\u0E2D\u0E31\u0E1B\u0E42\u0E2B\u0E25\u0E14",
+  paused: "\u0E2B\u0E22\u0E38\u0E14\u0E0A\u0E31\u0E48\u0E27\u0E04\u0E23\u0E32\u0E27",
+  success: "\u0E2D\u0E31\u0E1B\u0E42\u0E2B\u0E25\u0E14\u0E41\u0E25\u0E49\u0E27",
+  error: "\u0E25\u0E49\u0E21\u0E40\u0E2B\u0E25\u0E27",
+  retry: "\u0E25\u0E2D\u0E07\u0E2D\u0E35\u0E01\u0E04\u0E23\u0E31\u0E49\u0E07",
+  pause: "\u0E2B\u0E22\u0E38\u0E14\u0E0A\u0E31\u0E48\u0E27\u0E04\u0E23\u0E32\u0E27",
+  resume: "\u0E14\u0E33\u0E40\u0E19\u0E34\u0E19\u0E01\u0E32\u0E23\u0E15\u0E48\u0E2D",
+  cancel: "\u0E22\u0E01\u0E40\u0E25\u0E34\u0E01",
+  remove: "\u0E25\u0E1A",
+  removeAll: "\u0E25\u0E1A\u0E17\u0E31\u0E49\u0E07\u0E2B\u0E21\u0E14",
+  preview: "\u0E14\u0E39\u0E15\u0E31\u0E27\u0E2D\u0E22\u0E48\u0E32\u0E07",
+  download: "\u0E14\u0E32\u0E27\u0E19\u0E4C\u0E42\u0E2B\u0E25\u0E14",
+  edit: "\u0E41\u0E01\u0E49\u0E44\u0E02",
+  save: "\u0E1A\u0E31\u0E19\u0E17\u0E36\u0E01",
+  fullscreen: "\u0E40\u0E15\u0E47\u0E21\u0E08\u0E2D",
+  rename: "\u0E40\u0E1B\u0E25\u0E35\u0E48\u0E22\u0E19\u0E0A\u0E37\u0E48\u0E2D",
+  tags: "\u0E41\u0E17\u0E47\u0E01",
+  description: "\u0E04\u0E33\u0E2D\u0E18\u0E34\u0E1A\u0E32\u0E22",
+  category: "\u0E2B\u0E21\u0E27\u0E14\u0E2B\u0E21\u0E39\u0E48",
+  addTag: "\u0E40\u0E1E\u0E34\u0E48\u0E21\u0E41\u0E17\u0E47\u0E01",
+  fileTooLarge: "\u0E44\u0E1F\u0E25\u0E4C\u0E21\u0E35\u0E02\u0E19\u0E32\u0E14\u0E43\u0E2B\u0E0D\u0E48\u0E40\u0E01\u0E34\u0E19\u0E44\u0E1B",
+  fileTooSmall: "\u0E44\u0E1F\u0E25\u0E4C\u0E21\u0E35\u0E02\u0E19\u0E32\u0E14\u0E40\u0E25\u0E47\u0E01\u0E40\u0E01\u0E34\u0E19\u0E44\u0E1B",
+  invalidType: "\u0E44\u0E21\u0E48\u0E2D\u0E19\u0E38\u0E0D\u0E32\u0E15\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E44\u0E1F\u0E25\u0E4C\u0E19\u0E35\u0E49",
+  tooManyFiles: "\u0E44\u0E1F\u0E25\u0E4C\u0E21\u0E32\u0E01\u0E40\u0E01\u0E34\u0E19\u0E44\u0E1B",
+  duplicateFile: "\u0E44\u0E1F\u0E25\u0E4C\u0E0B\u0E49\u0E33",
+  speed: "\u0E04\u0E27\u0E32\u0E21\u0E40\u0E23\u0E47\u0E27",
+  eta: "\u0E40\u0E27\u0E25\u0E32\u0E17\u0E35\u0E48\u0E40\u0E2B\u0E25\u0E37\u0E2D",
+  ofText: "\u0E08\u0E32\u0E01",
+  filesText: "\u0E44\u0E1F\u0E25\u0E4C",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var he = {
+  dropHere: "\u05D2\u05E8\u05D5\u05E8 \u05E7\u05D1\u05E6\u05D9\u05DD \u05DC\u05DB\u05D0\u05DF",
+  dragOrClick: "\u05D2\u05E8\u05D5\u05E8 \u05D5\u05E9\u05D7\u05E8\u05E8 \u05E7\u05D1\u05E6\u05D9\u05DD \u05D0\u05D5 \u05DC\u05D7\u05E5 \u05DC\u05E2\u05D9\u05D5\u05DF",
+  browse: "\u05E2\u05D9\u05D5\u05DF \u05D1\u05E7\u05D1\u05E6\u05D9\u05DD",
+  uploading: "\u05DE\u05E2\u05DC\u05D4",
+  paused: "\u05DE\u05D5\u05E9\u05D4\u05D4",
+  success: "\u05D4\u05D5\u05E2\u05DC\u05D4",
+  error: "\u05E0\u05DB\u05E9\u05DC",
+  retry: "\u05E0\u05E1\u05D4 \u05E9\u05D5\u05D1",
+  pause: "\u05D4\u05E9\u05D4\u05D4",
+  resume: "\u05D4\u05DE\u05E9\u05DA",
+  cancel: "\u05D1\u05D8\u05DC",
+  remove: "\u05D4\u05E1\u05E8",
+  removeAll: "\u05D4\u05E1\u05E8 \u05D4\u05DB\u05DC",
+  preview: "\u05EA\u05E6\u05D5\u05D2\u05D4 \u05DE\u05E7\u05D3\u05D9\u05DE\u05D4",
+  download: "\u05D4\u05D5\u05E8\u05D3",
+  edit: "\u05E2\u05E8\u05D5\u05DA",
+  save: "\u05E9\u05DE\u05D5\u05E8",
+  fullscreen: "\u05DE\u05E1\u05DA \u05DE\u05DC\u05D0",
+  rename: "\u05E9\u05E0\u05D4 \u05E9\u05DD",
+  tags: "\u05EA\u05D2\u05D9\u05D5\u05EA",
+  description: "\u05EA\u05D9\u05D0\u05D5\u05E8",
+  category: "\u05E7\u05D8\u05D2\u05D5\u05E8\u05D9\u05D4",
+  addTag: "\u05D4\u05D5\u05E1\u05E3 \u05EA\u05D2\u05D9\u05EA",
+  fileTooLarge: "\u05D4\u05E7\u05D5\u05D1\u05E5 \u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9",
+  fileTooSmall: "\u05D4\u05E7\u05D5\u05D1\u05E5 \u05E7\u05D8\u05DF \u05DE\u05D3\u05D9",
+  invalidType: "\u05E1\u05D5\u05D2 \u05D4\u05E7\u05D5\u05D1\u05E5 \u05D0\u05D9\u05E0\u05D5 \u05DE\u05D5\u05EA\u05E8",
+  tooManyFiles: "\u05D9\u05D5\u05EA\u05E8 \u05DE\u05D3\u05D9 \u05E7\u05D1\u05E6\u05D9\u05DD",
+  duplicateFile: "\u05E7\u05D5\u05D1\u05E5 \u05DB\u05E4\u05D5\u05DC",
+  speed: "\u05DE\u05D4\u05D9\u05E8\u05D5\u05EA",
+  eta: "\u05D6\u05DE\u05DF \u05E0\u05D5\u05EA\u05E8",
+  ofText: "\u05DE\u05EA\u05D5\u05DA",
+  filesText: "\u05E7\u05D1\u05E6\u05D9\u05DD",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var fa = {
+  dropHere: "\u0641\u0627\u06CC\u0644\u200C\u0647\u0627 \u0631\u0627 \u0627\u06CC\u0646\u062C\u0627 \u0631\u0647\u0627 \u06A9\u0646\u06CC\u062F",
+  dragOrClick: "\u0641\u0627\u06CC\u0644\u200C\u0647\u0627 \u0631\u0627 \u0628\u06A9\u0634\u06CC\u062F \u0648 \u0631\u0647\u0627 \u06A9\u0646\u06CC\u062F \u06CC\u0627 \u0628\u0631\u0627\u06CC \u0645\u0631\u0648\u0631 \u06A9\u0644\u06CC\u06A9 \u06A9\u0646\u06CC\u062F",
+  browse: "\u0645\u0631\u0648\u0631 \u0641\u0627\u06CC\u0644\u200C\u0647\u0627",
+  uploading: "\u062F\u0631 \u062D\u0627\u0644 \u0628\u0627\u0631\u06AF\u0630\u0627\u0631\u06CC",
+  paused: "\u0645\u062A\u0648\u0642\u0641 \u0634\u062F",
+  success: "\u0628\u0627\u0631\u06AF\u0630\u0627\u0631\u06CC \u0634\u062F",
+  error: "\u0646\u0627\u0645\u0648\u0641\u0642",
+  retry: "\u062A\u0644\u0627\u0634 \u062F\u0648\u0628\u0627\u0631\u0647",
+  pause: "\u062A\u0648\u0642\u0641",
+  resume: "\u0627\u062F\u0627\u0645\u0647",
+  cancel: "\u0644\u063A\u0648",
+  remove: "\u062D\u0630\u0641",
+  removeAll: "\u062D\u0630\u0641 \u0647\u0645\u0647",
+  preview: "\u067E\u06CC\u0634\u200C\u0646\u0645\u0627\u06CC\u0634",
+  download: "\u062F\u0627\u0646\u0644\u0648\u062F",
+  edit: "\u0648\u06CC\u0631\u0627\u06CC\u0634",
+  save: "\u0630\u062E\u06CC\u0631\u0647",
+  fullscreen: "\u062A\u0645\u0627\u0645 \u0635\u0641\u062D\u0647",
+  rename: "\u062A\u063A\u06CC\u06CC\u0631 \u0646\u0627\u0645",
+  tags: "\u0628\u0631\u0686\u0633\u0628\u200C\u0647\u0627",
+  description: "\u062A\u0648\u0636\u06CC\u062D\u0627\u062A",
+  category: "\u062F\u0633\u062A\u0647\u200C\u0628\u0646\u062F\u06CC",
+  addTag: "\u0627\u0641\u0632\u0648\u062F\u0646 \u0628\u0631\u0686\u0633\u0628",
+  fileTooLarge: "\u0641\u0627\u06CC\u0644 \u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF \u0627\u0633\u062A",
+  fileTooSmall: "\u0641\u0627\u06CC\u0644 \u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9 \u0627\u0633\u062A",
+  invalidType: "\u0646\u0648\u0639 \u0641\u0627\u06CC\u0644 \u0645\u062C\u0627\u0632 \u0646\u06CC\u0633\u062A",
+  tooManyFiles: "\u0641\u0627\u06CC\u0644\u200C\u0647\u0627\u06CC \u0632\u06CC\u0627\u062F",
+  duplicateFile: "\u0641\u0627\u06CC\u0644 \u062A\u06A9\u0631\u0627\u0631\u06CC",
+  speed: "\u0633\u0631\u0639\u062A",
+  eta: "\u0632\u0645\u0627\u0646 \u0628\u0627\u0642\u06CC\u200C\u0645\u0627\u0646\u062F\u0647",
+  ofText: "\u0627\u0632",
+  filesText: "\u0641\u0627\u06CC\u0644",
+  bytes: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB"
+};
+var translations = {
+  en,
+  hi,
+  gu,
+  fr,
+  de,
+  ar,
+  zh,
+  es,
+  pt,
+  ru,
+  ja,
+  ko,
+  it,
+  tr,
+  id,
+  bn,
+  ur,
+  nl,
+  pl,
+  vi,
+  th,
+  he,
+  fa
+};
+var rtlLocales = /* @__PURE__ */ new Set(["ar", "ur", "he", "fa"]);
+var I18nContext = react.createContext(null);
+function I18nProvider({ locale = "en", messages, children }) {
+  const value = react.useMemo(() => {
+    const base2 = translations[locale] ?? translations.en;
+    return {
+      locale,
+      t: { ...base2, ...messages },
+      isRtl: rtlLocales.has(locale)
+    };
+  }, [locale, messages]);
+  return /* @__PURE__ */ jsxRuntime.jsx(I18nContext.Provider, { value, children });
+}
+function useI18n() {
+  const ctx = react.useContext(I18nContext);
+  if (ctx) return ctx;
+  return { locale: "en", t: translations.en, isRtl: false };
+}
+var base = {
+  width: 16,
+  height: 16,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+var UploadIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
+  /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "17 8 12 3 7 8" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "3", x2: "12", y2: "15" })
+] });
+var FileIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "14 2 14 8 20 8" })
+] });
+var ImageIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2" }),
+  /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "9", cy: "9", r: "2" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" })
+] });
+var TrashIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "3 6 5 6 21 6" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" })
+] });
+var PauseIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "6", y: "4", width: "4", height: "16" }),
+  /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "14", y: "4", width: "4", height: "16" })
+] });
+var PlayIcon = (p) => /* @__PURE__ */ jsxRuntime.jsx("svg", { ...base, ...p, children: /* @__PURE__ */ jsxRuntime.jsx("polygon", { points: "5 3 19 12 5 21 5 3" }) });
+var RetryIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "23 4 23 10 17 10" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M20.49 15a9 9 0 1 1-2.12-9.36L23 10" })
+] });
+var CheckIcon = (p) => /* @__PURE__ */ jsxRuntime.jsx("svg", { ...base, ...p, children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "20 6 9 17 4 12" }) });
+var AlertIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
+] });
+var CloseIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+] });
+var DownloadIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
+  /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "7 10 12 15 17 10" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "15", x2: "12", y2: "3" })
+] });
+var EyeIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "3" })
+] });
+var FolderIcon = (p) => /* @__PURE__ */ jsxRuntime.jsx("svg", { ...base, ...p, children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z" }) });
+var EditIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 20h9" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16.5 3.5a2.121 2.121 0 1 1 3 3L7 19l-4 1 1-4z" })
+] });
+var MaximizeIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M8 3H5a2 2 0 0 0-2 2v3" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 8V5a2 2 0 0 0-2-2h-3" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 16v3a2 2 0 0 0 2 2h3" }),
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16 21h3a2 2 0 0 0 2-2v-3" })
+] });
+var TagIcon = (p) => /* @__PURE__ */ jsxRuntime.jsxs("svg", { ...base, ...p, children: [
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" }),
+  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "7", y1: "7", x2: "7.01", y2: "7" })
+] });
+var sizeClasses = {
+  sm: "max-w-sm",
+  md: "max-w-md",
+  lg: "max-w-2xl",
+  xl: "max-w-4xl",
+  full: "max-w-[95vw]"
+};
+function UploadModal({
+  open,
+  onClose,
+  title,
+  description,
+  children,
+  size = "lg",
+  hideClose,
+  className
+}) {
+  const { t } = useI18n();
+  react.useEffect(() => {
+    if (!open) return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    const handler = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("keydown", handler);
+    return () => {
+      document.body.style.overflow = prev;
+      document.removeEventListener("keydown", handler);
+    };
+  }, [open, onClose]);
+  if (!open || typeof document === "undefined") return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": typeof title === "string" ? title : "Upload",
+      className: "fixed inset-0 z-[1000] flex items-center justify-center p-4",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "absolute inset-0 bg-black/50 backdrop-blur-sm",
+            onClick: onClose,
+            "aria-hidden": true
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: cn(
+              "relative w-full overflow-hidden rounded-rup border border-rup-border bg-rup-bg text-rup-fg shadow-rup",
+              sizeClasses[size],
+              className
+            ),
+            children: [
+              (title || !hideClose) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between border-b border-rup-border px-5 py-3", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                  title && /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "text-base font-semibold", children: title }),
+                  description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "mt-0.5 text-xs text-rup-muted", children: description })
+                ] }),
+                !hideClose && /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: onClose,
+                    "aria-label": t.cancel,
+                    className: "inline-flex h-8 w-8 items-center justify-center rounded-md text-rup-muted hover:bg-rup-border/40 hover:text-rup-fg",
+                    children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { width: 16, height: 16 })
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "max-h-[80vh] overflow-y-auto p-5", children })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function FileEditModal({ file, onClose, onRename, onSave }) {
+  const { t } = useI18n();
+  const [name, setName] = react.useState("");
+  const [category, setCategory] = react.useState("");
+  const [description, setDescription] = react.useState("");
+  const [tags, setTags] = react.useState([]);
+  const [tagDraft, setTagDraft] = react.useState("");
+  react.useEffect(() => {
+    if (!file) return;
+    setName(file.name);
+    setCategory(typeof file.metadata.category === "string" ? file.metadata.category : "");
+    setDescription(
+      typeof file.metadata.description === "string" ? file.metadata.description : ""
+    );
+    setTags(Array.isArray(file.metadata.tags) ? [...file.metadata.tags] : []);
+    setTagDraft("");
+  }, [file]);
+  const commitTagDraft = () => {
+    const next = tagDraft.trim();
+    if (!next) return;
+    if (tags.includes(next)) {
+      setTagDraft("");
+      return;
+    }
+    setTags((prev) => [...prev, next]);
+    setTagDraft("");
+  };
+  const onTagKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === ",") {
+      e.preventDefault();
+      commitTagDraft();
+    } else if (e.key === "Backspace" && tagDraft === "" && tags.length > 0) {
+      setTags((prev) => prev.slice(0, -1));
+    }
+  };
+  const handleSave = () => {
+    if (!file) return;
+    if (name && name !== file.name) onRename?.(file, name);
+    onSave?.(file, { category: category || void 0, description: description || void 0, tags });
+    onClose();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(UploadModal, { open: !!file, onClose, title: t.edit, size: "md", hideClose: true, children: file && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-xs text-rup-muted", children: [
+        file.size > 0 ? new Intl.NumberFormat().format(file.size) + " bytes" : "",
+        " ",
+        "\xB7 ",
+        file.type || "unknown"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onClose,
+          "aria-label": t.cancel,
+          className: "inline-flex h-7 w-7 items-center justify-center rounded-md text-rup-muted hover:bg-rup-border/40 hover:text-rup-fg",
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { width: 14, height: 14 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(Field, { label: t.rename, children: /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        value: name,
+        onChange: (e) => setName(e.target.value),
+        className: inputCls,
+        autoFocus: true
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Field, { label: t.category, children: /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        value: category,
+        onChange: (e) => setCategory(e.target.value),
+        placeholder: "e.g. invoices",
+        className: inputCls
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Field, { label: t.tags, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-wrap items-center gap-1.5 rounded-rup border border-rup-border bg-rup-bg p-2", children: [
+      tags.map((tag) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "span",
+        {
+          className: "inline-flex items-center gap-1 rounded-full bg-rup-accent/15 px-2 py-0.5 text-xs text-rup-accent",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(TagIcon, { width: 10, height: 10 }),
+            tag,
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => setTags((prev) => prev.filter((x) => x !== tag)),
+                className: "ml-0.5 text-rup-accent hover:opacity-70",
+                "aria-label": `${t.remove} ${tag}`,
+                children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { width: 10, height: 10 })
+              }
+            )
+          ]
+        },
+        tag
+      )),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          value: tagDraft,
+          onChange: (e) => setTagDraft(e.target.value),
+          onKeyDown: onTagKeyDown,
+          onBlur: commitTagDraft,
+          placeholder: t.addTag,
+          className: "min-w-[80px] flex-1 bg-transparent text-sm text-rup-fg outline-none placeholder:text-rup-muted"
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Field, { label: t.description, children: /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        value: description,
+        onChange: (e) => setDescription(e.target.value),
+        rows: 3,
+        className: cn(inputCls, "resize-none")
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-2 flex items-center justify-end gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onClose,
+          className: "rounded-md border border-rup-border bg-rup-bg px-4 py-2 text-sm text-rup-fg hover:bg-rup-border/30",
+          children: t.cancel
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: handleSave,
+          className: "rounded-md bg-rup-accent px-4 py-2 text-sm font-medium text-rup-accent-fg hover:opacity-90",
+          children: t.save
+        }
+      )
+    ] })
+  ] }) });
+}
+var inputCls = "w-full rounded-rup border border-rup-border bg-rup-bg px-3 py-2 text-sm text-rup-fg placeholder:text-rup-muted focus:outline-none focus:ring-2 focus:ring-rup-accent";
+function Field({ label, children }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: "flex flex-col gap-1", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium text-rup-muted", children: label }),
+    children
+  ] });
+}
+function FilePreviewModal({ file, onClose, onDownload }) {
+  const { t } = useI18n();
+  const preview = useFilePreview(file);
+  const [zoom, setZoom] = react.useState(1);
+  const [rotate, setRotate] = react.useState(0);
+  react.useEffect(() => {
+    setZoom(1);
+    setRotate(0);
+  }, [file?.id]);
+  const handleDownload = () => {
+    if (!file) return;
+    if (onDownload) {
+      onDownload(file);
+      return;
+    }
+    const url = URL.createObjectURL(file.file);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = file.name;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(UploadModal, { open: !!file, onClose, title: file?.name, size: "xl", hideClose: true, children: file && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-3", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-end gap-2", children: [
+      preview.kind === "image" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ZoomButton, { onClick: () => setZoom((z) => Math.max(0.2, z - 0.2)), children: "\u2212" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-rup-muted", children: [
+          Math.round(zoom * 100),
+          "%"
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(ZoomButton, { onClick: () => setZoom((z) => Math.min(5, z + 0.2)), children: "+" }),
+        /* @__PURE__ */ jsxRuntime.jsx(ZoomButton, { onClick: () => setRotate((r) => (r + 90) % 360), children: "\u21BB" })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: handleDownload,
+          className: "inline-flex items-center gap-1 rounded-md border border-rup-border px-3 py-1.5 text-xs hover:bg-rup-border/30",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(DownloadIcon, { width: 14, height: 14 }),
+            t.download
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onClose,
+          "aria-label": t.cancel,
+          className: "inline-flex h-8 w-8 items-center justify-center rounded-md text-rup-muted hover:bg-rup-border/40 hover:text-rup-fg",
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { width: 16, height: 16 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex min-h-[40vh] items-center justify-center overflow-auto rounded-rup bg-rup-border/20 p-4", children: renderPreview({ preview, file, zoom, rotate }) })
+  ] }) });
+}
+function renderPreview({
+  preview,
+  file,
+  zoom,
+  rotate
+}) {
+  if (preview.loading) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-rup-muted", children: "Loading\u2026" });
+  }
+  if (preview.error) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-rup-error", children: preview.error });
+  }
+  if (preview.kind === "image" && preview.url) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "img",
+      {
+        src: preview.url,
+        alt: file.name,
+        style: { transform: `scale(${zoom}) rotate(${rotate}deg)` },
+        className: "max-h-[70vh] origin-center select-none transition-transform"
+      }
+    );
+  }
+  if (preview.kind === "video" && preview.url) {
+    return /* @__PURE__ */ jsxRuntime.jsx("video", { src: preview.url, controls: true, className: "max-h-[70vh]" });
+  }
+  if (preview.kind === "audio" && preview.url) {
+    return /* @__PURE__ */ jsxRuntime.jsx("audio", { src: preview.url, controls: true, className: "w-full" });
+  }
+  if (preview.kind === "pdf" && preview.url) {
+    return /* @__PURE__ */ jsxRuntime.jsx("iframe", { src: preview.url, title: file.name, className: "h-[70vh] w-full rounded border-0" });
+  }
+  if (preview.kind === "text" && typeof preview.text === "string") {
+    return /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "max-h-[70vh] w-full overflow-auto whitespace-pre-wrap break-words rounded bg-rup-bg p-4 text-xs", children: preview.text });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center gap-2 text-sm text-rup-muted", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("span", { children: "No inline preview available for this file type." }),
+    preview.url && /* @__PURE__ */ jsxRuntime.jsx(
+      "a",
+      {
+        href: preview.url,
+        target: "_blank",
+        rel: "noreferrer",
+        className: "text-rup-accent underline",
+        children: "Open in new tab"
+      }
+    )
+  ] });
+}
+function ZoomButton({ children, onClick }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: cn(
+        "h-8 w-8 rounded-md border border-rup-border bg-rup-bg text-sm text-rup-fg hover:bg-rup-border/30"
+      ),
+      children
+    }
+  );
+}
+var SEGMENT_COUNT = 10;
+function UploadProgress({
+  value,
+  variant = "bar",
+  showLabel = false,
+  size,
+  fillClassName,
+  trackClassName,
+  indeterminate = false,
+  segments = SEGMENT_COUNT,
+  className,
+  ...rest
+}) {
+  const pct = Math.max(0, Math.min(1, value));
+  const roundedPct = Math.round(pct * 100);
+  if (variant === "circle") {
+    const dim = size ?? 48;
+    const stroke = Math.max(3, Math.floor(dim / 12));
+    const radius = (dim - stroke) / 2;
+    const circumference = 2 * Math.PI * radius;
+    const offset = indeterminate ? circumference * 0.75 : circumference * (1 - pct);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: cn("relative inline-flex items-center justify-center", className),
+        style: { width: dim, height: dim },
+        role: "progressbar",
+        "aria-valuenow": indeterminate ? void 0 : roundedPct,
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: dim, height: dim, className: indeterminate ? "animate-spin" : "", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "circle",
+              {
+                cx: dim / 2,
+                cy: dim / 2,
+                r: radius,
+                stroke: "currentColor",
+                strokeWidth: stroke,
+                fill: "none",
+                className: cn("text-rup-border", trackClassName)
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "circle",
+              {
+                cx: dim / 2,
+                cy: dim / 2,
+                r: radius,
+                stroke: "currentColor",
+                strokeWidth: stroke,
+                strokeLinecap: "round",
+                fill: "none",
+                strokeDasharray: circumference,
+                strokeDashoffset: offset,
+                transform: `rotate(-90 ${dim / 2} ${dim / 2})`,
+                className: cn("text-rup-accent transition-[stroke-dashoffset] duration-300", fillClassName)
+              }
+            )
+          ] }),
+          showLabel && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "absolute text-xs font-medium text-rup-fg", children: formatPercent(pct) })
+        ]
+      }
+    );
+  }
+  if (variant === "segmented") {
+    const filled = Math.round(pct * segments);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: cn("flex items-center gap-2", className),
+        role: "progressbar",
+        "aria-valuenow": roundedPct,
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-1 items-center gap-[3px]", children: Array.from({ length: segments }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: cn(
+                "h-2 flex-1 rounded-sm transition-colors duration-200",
+                i < filled ? "bg-rup-accent" : "bg-rup-border/60",
+                fillClassName && i < filled && fillClassName
+              )
+            },
+            i
+          )) }),
+          showLabel && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-[3ch] text-right text-xs tabular-nums text-rup-muted", children: formatPercent(pct) })
+        ]
+      }
+    );
+  }
+  if (variant === "dots") {
+    const filled = Math.round(pct * segments);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: cn("flex items-center gap-2", className),
+        role: "progressbar",
+        "aria-valuenow": roundedPct,
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-1 items-center justify-between gap-1", children: Array.from({ length: segments }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: cn(
+                "h-2 w-2 rounded-full transition-all duration-200",
+                i < filled ? "bg-rup-accent scale-110" : "bg-rup-border/60",
+                fillClassName && i < filled && fillClassName
+              )
+            },
+            i
+          )) }),
+          showLabel && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-[3ch] text-right text-xs tabular-nums text-rup-muted", children: formatPercent(pct) })
+        ]
+      }
+    );
+  }
+  const isMinimal = variant === "minimal";
+  const isGradient = variant === "gradient";
+  const isStriped = variant === "striped";
+  const height = size ?? (isMinimal ? 2 : isStriped ? 10 : 6);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cn("flex items-center gap-2", className),
+      role: "progressbar",
+      "aria-valuenow": indeterminate ? void 0 : roundedPct,
+      "aria-valuemin": 0,
+      "aria-valuemax": 100,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(
+              "relative w-full overflow-hidden bg-rup-border/60",
+              isMinimal ? "rounded-none" : "rounded-full",
+              trackClassName
+            ),
+            style: { height },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: cn(
+                  "absolute inset-y-0 left-0 transition-[width] duration-300",
+                  isMinimal ? "rounded-none" : "rounded-full",
+                  isGradient ? "bg-gradient-to-r from-indigo-500 via-purple-500 to-pink-500" : "bg-rup-accent",
+                  isStriped && "bg-[linear-gradient(45deg,rgba(255,255,255,0.18)_25%,transparent_25%,transparent_50%,rgba(255,255,255,0.18)_50%,rgba(255,255,255,0.18)_75%,transparent_75%,transparent)] bg-[length:1rem_1rem] animate-[rup-shimmer_1s_linear_infinite]",
+                  indeterminate && "w-1/3 animate-[rup-shimmer_1.4s_linear_infinite]",
+                  fillClassName
+                ),
+                style: { width: indeterminate ? void 0 : `${pct * 100}%` }
+              }
+            )
+          }
+        ),
+        showLabel && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-[3ch] text-right text-xs tabular-nums text-rup-muted", children: formatPercent(pct) })
+      ]
+    }
+  );
+}
+function UploadPreview({
+  file,
+  density = "comfortable",
+  showStats = true,
+  showThumb = true,
+  progressVariant,
+  progressSize,
+  className,
+  onRetry,
+  onPause,
+  onResume,
+  onCancel,
+  onRemove,
+  onPreview,
+  onDownload,
+  onEdit,
+  ...rest
+}) {
+  const { t } = useI18n();
+  const category = react.useMemo(() => getFileCategory(file), [file]);
+  const [thumbError, setThumbError] = react.useState(false);
+  const isImage = category === "image" && file.previewUrl && showThumb && !thumbError;
+  const isVideo = category === "video" && file.previewUrl && showThumb && !thumbError;
+  const isUploading = file.status === "uploading";
+  const isPaused = file.status === "paused";
+  const isErr = file.status === "error";
+  const isOk = file.status === "success";
+  const showProgress = isUploading || isPaused || file.progress > 0;
+  const resolvedProgressVariant = progressVariant ?? (isPaused ? "bar" : isUploading ? "striped" : "bar");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cn(
+        "group relative flex items-center gap-3 rounded-rup border border-rup-border bg-rup-bg p-3 text-rup-fg",
+        density === "compact" && "p-2 gap-2",
+        density === "card" && "flex-col items-stretch p-4",
+        isErr && "border-rup-error/50",
+        isOk && "border-rup-success/50",
+        className
+      ),
+      "data-rup-file-id": file.id,
+      "data-status": file.status,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(
+              "flex h-12 w-12 shrink-0 items-center justify-center overflow-hidden rounded-md bg-rup-border/30 text-rup-muted",
+              density === "compact" && "h-9 w-9",
+              density === "card" && "h-32 w-full"
+            ),
+            children: isImage ? /* @__PURE__ */ jsxRuntime.jsx(
+              "img",
+              {
+                src: file.previewUrl,
+                alt: file.name,
+                className: "h-full w-full object-cover",
+                onError: () => setThumbError(true)
+              }
+            ) : isVideo ? /* @__PURE__ */ jsxRuntime.jsx(
+              "video",
+              {
+                src: file.previewUrl,
+                className: "h-full w-full object-cover",
+                muted: true,
+                onError: () => setThumbError(true)
+              }
+            ) : category === "image" ? /* @__PURE__ */ jsxRuntime.jsx(ImageIcon, { width: 20, height: 20 }) : /* @__PURE__ */ jsxRuntime.jsx(FileIcon, { width: 20, height: 20 })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate text-sm font-medium", title: file.name, children: file.name }),
+            isOk && /* @__PURE__ */ jsxRuntime.jsx(CheckIcon, { width: 14, height: 14, className: "text-rup-success" }),
+            isErr && /* @__PURE__ */ jsxRuntime.jsx(AlertIcon, { width: 14, height: 14, className: "text-rup-error" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mt-0.5 flex items-center gap-2 text-xs text-rup-muted", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatBytes(file.size) }),
+            isUploading && showStats && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { children: "\xB7" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+                t.speed,
+                ": ",
+                formatSpeed(file.speed)
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { children: "\xB7" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+                t.eta,
+                ": ",
+                formatEta(file.eta)
+              ] })
+            ] }),
+            isErr && file.error && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate text-rup-error", title: file.error.message, children: file.error.message }),
+            isPaused && /* @__PURE__ */ jsxRuntime.jsx("span", { children: t.paused })
+          ] }),
+          showProgress && /* @__PURE__ */ jsxRuntime.jsx(
+            UploadProgress,
+            {
+              value: file.progress,
+              variant: resolvedProgressVariant,
+              size: progressSize,
+              className: "mt-2",
+              fillClassName: isErr ? "bg-rup-error" : isOk ? "bg-rup-success" : void 0
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex items-center gap-1", density === "card" && "justify-end"), children: [
+          onPreview && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onPreview(file), label: t.preview, children: /* @__PURE__ */ jsxRuntime.jsx(EyeIcon, { width: 14, height: 14 }) }),
+          onEdit && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onEdit(file), label: t.edit ?? "Edit", children: /* @__PURE__ */ jsxRuntime.jsx(EditIcon, { width: 14, height: 14 }) }),
+          onDownload && isOk && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onDownload(file), label: t.download, children: /* @__PURE__ */ jsxRuntime.jsx(DownloadIcon, { width: 14, height: 14 }) }),
+          onRetry && (isErr || file.status === "cancelled") && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onRetry(file), label: t.retry, children: /* @__PURE__ */ jsxRuntime.jsx(RetryIcon, { width: 14, height: 14 }) }),
+          onPause && isUploading && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onPause(file), label: t.pause, children: /* @__PURE__ */ jsxRuntime.jsx(PauseIcon, { width: 14, height: 14 }) }),
+          onResume && isPaused && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onResume(file), label: t.resume, children: /* @__PURE__ */ jsxRuntime.jsx(PlayIcon, { width: 14, height: 14 }) }),
+          onCancel && isUploading && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onCancel(file), label: t.cancel, children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { width: 14, height: 14 }) }),
+          onRemove && /* @__PURE__ */ jsxRuntime.jsx(IconButton, { onClick: () => onRemove(file), label: t.remove, danger: true, children: /* @__PURE__ */ jsxRuntime.jsx(TrashIcon, { width: 14, height: 14 }) })
+        ] })
+      ]
+    }
+  );
+}
+function IconButton({
+  children,
+  onClick,
+  label,
+  danger
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      onClick,
+      "aria-label": label,
+      title: label,
+      className: cn(
+        "inline-flex h-7 w-7 items-center justify-center rounded-md text-rup-muted transition hover:bg-rup-border/40 hover:text-rup-fg focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-rup-accent",
+        danger && "hover:bg-rup-error/10 hover:text-rup-error"
+      ),
+      children
+    }
+  );
+}
+function UploadGallery({
+  files,
+  layout = "list",
+  reorderable = false,
+  onReorder,
+  searchable = false,
+  filterable = false,
+  previewable = false,
+  editable = false,
+  onRename,
+  onMetadataChange,
+  scrollAfter,
+  maxHeight = "280px",
+  emptyState,
+  className,
+  density,
+  showStats,
+  showThumb,
+  progressVariant,
+  progressSize,
+  onRetry,
+  onPause,
+  onResume,
+  onCancel,
+  onRemove,
+  onPreview,
+  onDownload,
+  onEdit,
+  ...rest
+}) {
+  const { t } = useI18n();
+  const [query, setQuery] = react.useState("");
+  const [filter, setFilter] = react.useState("all");
+  const [dragIndex, setDragIndex] = react.useState(null);
+  const [previewFile, setPreviewFile] = react.useState(null);
+  const [editFile, setEditFile] = react.useState(null);
+  const resolvedOnPreview = onPreview ?? (previewable ? (f) => setPreviewFile(f) : void 0);
+  const resolvedOnEdit = onEdit ?? (editable ? (f) => setEditFile(f) : void 0);
+  const visible = files.filter((f) => {
+    if (query && !f.name.toLowerCase().includes(query.toLowerCase())) return false;
+    if (filter === "uploading" && f.status !== "uploading" && f.status !== "queued") return false;
+    if (filter === "success" && f.status !== "success") return false;
+    if (filter === "error" && f.status !== "error" && f.status !== "cancelled") return false;
+    return true;
+  });
+  const shouldScroll = typeof scrollAfter === "number" && scrollAfter > 0 && visible.length > scrollAfter;
+  const wrapDrag = (index) => reorderable && onReorder ? {
+    draggable: true,
+    onDragStart: (e) => {
+      e.dataTransfer.effectAllowed = "move";
+      setDragIndex(index);
+    },
+    onDragOver: (e) => {
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "move";
+    },
+    onDrop: (e) => {
+      e.preventDefault();
+      if (dragIndex === null || dragIndex === index) return;
+      onReorder(dragIndex, index);
+      setDragIndex(null);
+    },
+    onDragEnd: () => setDragIndex(null)
+  } : {};
+  if (files.length === 0 && emptyState) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("text-sm text-rup-muted", className), children: emptyState });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex flex-col gap-3", className), ...rest, children: [
+    (searchable || filterable) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+      searchable && /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "search",
+          value: query,
+          onChange: (e) => setQuery(e.target.value),
+          placeholder: "Search\u2026",
+          className: "h-9 flex-1 min-w-[180px] rounded-rup border border-rup-border bg-rup-bg px-3 text-sm text-rup-fg placeholder:text-rup-muted focus:outline-none focus:ring-2 focus:ring-rup-accent"
+        }
+      ),
+      filterable && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-1", children: ["all", "uploading", "success", "error"].map((key) => /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => setFilter(key),
+          className: cn(
+            "rounded-full px-3 py-1 text-xs font-medium capitalize transition",
+            filter === key ? "bg-rup-accent text-rup-accent-fg" : "bg-rup-border/30 text-rup-muted hover:bg-rup-border/60"
+          ),
+          children: key === "all" ? "All" : key === "uploading" ? t.uploading : key === "success" ? t.success : t.error
+        },
+        key
+      )) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(ScrollWrapper, { active: shouldScroll, maxHeight, children: /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: cn(
+          layout === "list" && "flex flex-col gap-2",
+          layout === "compact" && "flex flex-col gap-1",
+          layout === "grid" && "grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-4",
+          layout === "table" && "overflow-hidden rounded-rup border border-rup-border"
+        ),
+        children: visible.map((f, i) => /* @__PURE__ */ jsxRuntime.jsx("div", { ...wrapDrag(i), children: /* @__PURE__ */ jsxRuntime.jsx(
+          UploadPreview,
+          {
+            file: f,
+            density: density ?? (layout === "grid" ? "card" : layout === "compact" ? "compact" : "comfortable"),
+            showStats,
+            showThumb,
+            progressVariant,
+            progressSize,
+            onRetry,
+            onPause,
+            onResume,
+            onCancel,
+            onRemove,
+            onPreview: resolvedOnPreview,
+            onDownload,
+            onEdit: resolvedOnEdit,
+            className: cn(layout === "table" && "rounded-none border-x-0 border-t-0 last:border-b-0")
+          }
+        ) }, f.id))
+      }
+    ) }),
+    previewable && !onPreview && /* @__PURE__ */ jsxRuntime.jsx(FilePreviewModal, { file: previewFile, onClose: () => setPreviewFile(null) }),
+    editable && !onEdit && /* @__PURE__ */ jsxRuntime.jsx(
+      FileEditModal,
+      {
+        file: editFile,
+        onClose: () => setEditFile(null),
+        onRename,
+        onSave: onMetadataChange
+      }
+    )
+  ] });
+}
+function ScrollWrapper({
+  active,
+  maxHeight,
+  children
+}) {
+  if (!active) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: "rup-scrollbar overflow-y-auto pr-1",
+      style: { maxHeight, scrollbarGutter: "stable" },
+      children
+    }
+  );
+}
+
+exports.AlertIcon = AlertIcon;
+exports.CheckIcon = CheckIcon;
+exports.CloseIcon = CloseIcon;
+exports.DownloadIcon = DownloadIcon;
+exports.EditIcon = EditIcon;
+exports.EyeIcon = EyeIcon;
+exports.FileEditModal = FileEditModal;
+exports.FileIcon = FileIcon;
+exports.FilePreviewModal = FilePreviewModal;
+exports.FolderIcon = FolderIcon;
+exports.I18nProvider = I18nProvider;
+exports.ImageIcon = ImageIcon;
+exports.MaximizeIcon = MaximizeIcon;
+exports.PauseIcon = PauseIcon;
+exports.PlayIcon = PlayIcon;
+exports.RetryIcon = RetryIcon;
+exports.TagIcon = TagIcon;
+exports.TrashIcon = TrashIcon;
+exports.UploadGallery = UploadGallery;
+exports.UploadIcon = UploadIcon;
+exports.UploadModal = UploadModal;
+exports.UploadPreview = UploadPreview;
+exports.UploadProgress = UploadProgress;
+exports.UploadQueue = UploadQueue;
+exports.cn = cn;
+exports.detectSignature = detectSignature;
+exports.formatBytes = formatBytes;
+exports.formatEta = formatEta;
+exports.formatPercent = formatPercent;
+exports.formatSpeed = formatSpeed;
+exports.generatePreview = generatePreview;
+exports.getFileCategory = getFileCategory;
+exports.matchesAccept = matchesAccept;
+exports.revokePreview = revokePreview;
+exports.rtlLocales = rtlLocales;
+exports.translations = translations;
+exports.useDropzone = useDropzone;
+exports.useFilePreview = useFilePreview;
+exports.useI18n = useI18n;
+exports.useUploadProgress = useUploadProgress;
+exports.useUploadQueue = useUploadQueue;
+exports.validateBatch = validateBatch;
+exports.validateFile = validateFile;
+exports.wrapFile = wrapFile;
+//# sourceMappingURL=chunk-VVMPVTIX.cjs.map
+//# sourceMappingURL=chunk-VVMPVTIX.cjs.map