@useupup/core 3.3.0

package/dist/internal.js

@@ -0,0 +1,2275 @@
+export { BrowserRuntime } from './chunk-HFR5HZJZ.js';
+import { resolveAccept, isUploadActive, GoogleDrivePlugin, DropboxPlugin, BoxPlugin, OneDrivePlugin } from './chunk-PMBR3OUW.js';
+export { CrashRecoveryManager, EventEmitter, FileManager, IndexedDBStorage, PluginManager, UploadManager, isFileRemovalLocked, isUploadActive, isUploadIdle } from './chunk-PMBR3OUW.js';
+export { PipelineEngine } from './chunk-FYQQRULL.js';
+export { DirectUpload, TokenEndpointCredentials, clearAllSessions, fileFingerprint, loadSession, removeSession, saveSession, updateSessionProgress } from './chunk-OOPDEOTM.js';
+import { FileSource } from './chunk-ZMS2HXLB.js';
+import { UpupError, UpupNetworkError } from './chunk-GE4LIVXP.js';
+import { LOCALE_META, resolveLocaleBundle, createTranslator, enUS, flattenTranslatorToUiTranslations } from './chunk-UXNPM54W.js';
+export { buildFallbackChain, resolveMessage } from './chunk-UXNPM54W.js';
+import { ThemeStore } from './chunk-VV6QCQLL.js';
+export { ThemeStore, tokensToVarRefs } from './chunk-VV6QCQLL.js';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+// src/sse-processor.ts
+function withProcessingKey(endpoint, key) {
+  const hashIndex = endpoint.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? endpoint.slice(0, hashIndex) : endpoint;
+  const hash = hashIndex >= 0 ? endpoint.slice(hashIndex) : "";
+  const queryIndex = beforeHash.indexOf("?");
+  const path = queryIndex >= 0 ? beforeHash.slice(0, queryIndex) : beforeHash;
+  const query = queryIndex >= 0 ? beforeHash.slice(queryIndex + 1) : "";
+  const params = new URLSearchParams(query);
+  params.set("key", key);
+  return `${path}?${params.toString()}${hash}`;
+}
+var SSEProcessor = class {
+  constructor() {
+    this.sources = /* @__PURE__ */ new Map();
+    this.timers = /* @__PURE__ */ new Map();
+  }
+  subscribe(key, endpoint, onMessage, onError, timeout = 6e4) {
+    if (this.sources.has(key)) return;
+    const url = withProcessingKey(endpoint, key);
+    const source = new EventSource(url);
+    this.sources.set(key, source);
+    const cleanup = () => {
+      this.unsubscribe(key);
+    };
+    const timer = setTimeout(() => {
+      onError(new Error(`Processing timed out for ${key}`));
+      cleanup();
+    }, timeout);
+    this.timers.set(key, timer);
+    source.onmessage = (event) => {
+      clearTimeout(timer);
+      this.timers.delete(key);
+      const raw = event.data;
+      let data;
+      try {
+        data = typeof raw === "string" ? JSON.parse(raw) : { raw };
+      } catch {
+        data = { raw };
+      }
+      onMessage(data);
+      cleanup();
+    };
+    source.onerror = () => {
+      clearTimeout(timer);
+      this.timers.delete(key);
+      onError(new Error(`Processing stream failed for ${key}`));
+      cleanup();
+    };
+  }
+  unsubscribe(key) {
+    const source = this.sources.get(key);
+    if (source) {
+      source.close();
+      this.sources.delete(key);
+    }
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+  }
+  destroy() {
+    this.sources.forEach((s) => {
+      s.close();
+    });
+    this.sources.clear();
+    this.timers.forEach((t) => {
+      clearTimeout(t);
+    });
+    this.timers.clear();
+  }
+};
+
+// src/utils/encoder.ts
+function b64EncodeUnicode(str) {
+  return btoa(
+    encodeURIComponent(str).replace(
+      /%([0-9A-F]{2})/g,
+      (_, p1) => String.fromCharCode(parseInt(p1, 16))
+    )
+  );
+}
+
+// src/utils/file-helpers.ts
+var fileAppendParams = (file) => {
+  const partial = file;
+  const rel = partial.relativePath || file.webkitRelativePath || file.name;
+  Object.assign(file, {
+    id: partial.id || b64EncodeUnicode(rel),
+    url: partial.url || URL.createObjectURL(file),
+    source: partial.source || "local" /* LOCAL */,
+    status: partial.status || "READY" /* READY */,
+    metadata: partial.metadata || {}
+  });
+  return file;
+};
+var revokeFileUrl = (file) => {
+  if (file.url?.startsWith("blob:")) {
+    URL.revokeObjectURL(file.url);
+  }
+};
+
+// src/utils/image-helpers.ts
+function dataURLtoBlob(dataURL) {
+  const [header = "", base64Data = ""] = dataURL.split(",");
+  const colon = header.indexOf(":");
+  const semi = colon === -1 ? -1 : header.indexOf(";", colon + 1);
+  const mime = semi === -1 ? "application/octet-stream" : header.slice(colon + 1, semi);
+  const binary = atob(base64Data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new Blob([bytes], { type: mime });
+}
+function blobToUploadFile(blob, original, output) {
+  const fileName = output?.fileName ? output.fileName(original) : original.name;
+  const file = new File([blob], fileName, {
+    type: blob.type || original.type,
+    lastModified: Date.now()
+  });
+  const fileWithParams = file;
+  fileWithParams.id = original.id;
+  fileWithParams.url = URL.createObjectURL(file);
+  fileWithParams.source = original.source;
+  fileWithParams.status = original.status;
+  fileWithParams.metadata = original.metadata;
+  if (original.key !== void 0) fileWithParams.key = original.key;
+  const originalLegacy = original;
+  const targetLegacy = fileWithParams;
+  if (originalLegacy.fileHash !== void 0)
+    targetLegacy.fileHash = originalLegacy.fileHash;
+  if (originalLegacy.thumbnail !== void 0)
+    targetLegacy.thumbnail = originalLegacy.thumbnail;
+  return fileWithParams;
+}
+function revokeAndReplace(map, fileId, newFile) {
+  const oldFile = map.get(fileId);
+  if (oldFile) {
+    revokeFileUrl(oldFile);
+  }
+  const next = new Map(map);
+  next.set(fileId, newFile);
+  return next;
+}
+
+// src/orchestrator/upload-speed.ts
+var SPEED_SAMPLE_WINDOW_MS = 3e3;
+function computeSpeedEta(args) {
+  const { now, uploadedBytes, totalBytes, previousSpeed, previousEta } = args;
+  const samples = [
+    ...args.samples,
+    { time: now, bytes: uploadedBytes }
+  ].filter((s) => s.time >= now - SPEED_SAMPLE_WINDOW_MS);
+  let speed = previousSpeed;
+  let eta = previousEta;
+  if (samples.length >= 2) {
+    const oldest = samples[0];
+    const newest = samples[samples.length - 1];
+    if (oldest && newest) {
+      const elapsed = (newest.time - oldest.time) / 1e3;
+      if (elapsed > 0) {
+        speed = Math.max(0, (newest.bytes - oldest.bytes) / elapsed);
+        const remaining = totalBytes - uploadedBytes;
+        eta = speed > 0 ? Math.ceil(remaining / speed) : 0;
+      }
+    }
+  }
+  return { samples, speed, eta };
+}
+
+// src/orchestrator/uploader-orchestrator.ts
+var UploaderOrchestrator = class {
+  constructor(core, callbacks) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.unsubs = [];
+    this.disposed = false;
+    /** useSyncExternalStore-compatible subscribe (bound). */
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    /** useSyncExternalStore-compatible getSnapshot (bound). */
+    this.getSnapshot = () => {
+      return this.state;
+    };
+    // ── Lifecycle ────────────────────────────────────────────────────
+    this.speedSamples = [];
+    this.core = core;
+    this.callbacks = callbacks;
+    this.state = {
+      files: /* @__PURE__ */ new Map(),
+      uploadStatus: "IDLE" /* IDLE */,
+      uploadError: "",
+      uploadErrorCode: void 0,
+      totalProgress: 0,
+      filesProgressMap: {},
+      uploadSpeed: 0,
+      uploadEta: 0,
+      uploadedBytes: 0,
+      totalBytes: 0,
+      activeSource: void 0,
+      editingFile: null,
+      editorQueue: [],
+      isAddingMore: false,
+      viewMode: "grid",
+      isOnline: true
+    };
+  }
+  setState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.notify();
+  }
+  notify() {
+    this.listeners.forEach((fn) => {
+      fn();
+    });
+  }
+  // ── File management methods ──────────────────────────────────────
+  /** Remove a file by id: revoke its blob URL, then delegate to core. */
+  removeFile(fileId) {
+    const file = this.state.files.get(fileId);
+    if (file) revokeFileUrl(file);
+    this.core.removeFile(fileId);
+  }
+  /** Set the active upload source. */
+  setActiveSource(source) {
+    this.setState({ activeSource: source });
+  }
+  /** Toggle between grid and list view. */
+  setViewMode(mode) {
+    this.setState({ viewMode: mode });
+  }
+  /** Toggle the "adding more files" state. */
+  setIsAddingMore(value) {
+    this.setState({ isAddingMore: value });
+  }
+  // ── Upload control methods ──────────────────────────────────────
+  /** Trigger upload for all current files. Calls onPrepareFiles if provided. */
+  async startUpload() {
+    const currentFiles = [...this.state.files.values()];
+    if (currentFiles.length === 0) return void 0;
+    this.setState({ uploadError: "", uploadErrorCode: void 0 });
+    const prepared = this.callbacks.onPrepareFiles ? await this.callbacks.onPrepareFiles(currentFiles) : currentFiles;
+    if (prepared !== currentFiles) {
+      this.core.removeAll();
+      await this.core.addFiles(prepared);
+    }
+    return await this.core.upload();
+  }
+  /** Retry upload for a specific file or all failed files. */
+  async retryUpload(fileId) {
+    if (this.state.files.size === 0) return void 0;
+    this.setState({ uploadError: "", uploadErrorCode: void 0 });
+    return await this.core.retry(fileId);
+  }
+  /** Cancel in-progress upload, revoke blob URLs, clear all files and progress. */
+  handleCancel() {
+    this.core.cancel();
+    this.state.files.forEach((file) => {
+      revokeFileUrl(file);
+    });
+    this.core.removeAll();
+    this.setState({
+      filesProgressMap: {},
+      uploadSpeed: 0,
+      uploadEta: 0,
+      uploadedBytes: 0,
+      totalBytes: 0
+    });
+  }
+  /** Pause in-progress upload. */
+  handlePause() {
+    this.core.pause();
+  }
+  /** Resume paused upload. */
+  handleResume() {
+    this.core.resume();
+  }
+  /** Mark upload as done: invoke callback, emit event, then cancel/clear. */
+  handleDone() {
+    this.callbacks.onDoneClicked?.();
+    this.core.emit("done", {});
+    this.handleCancel();
+  }
+  /** Full state reset: clear isAddingMore, emit state-reset, then handleDone. */
+  resetState() {
+    this.setState({ isAddingMore: false });
+    this.core.emit("state-reset", {});
+    this.handleDone();
+  }
+  // ── Image editor methods ────────────────────────────────────────
+  /** Open the image editor for a given file. Invokes onOpen callback and emits event. */
+  openImageEditor(file) {
+    this.setState({ editingFile: file });
+    this.callbacks.imageEditorOptions?.onOpen?.(file);
+    this.core.emit("image-editor-open", { file });
+  }
+  /**
+   * Close the image editor without saving. Invokes onCancel callback.
+   * If the editor queue is non-empty, the next file is automatically opened.
+   */
+  closeImageEditor() {
+    const current = this.state.editingFile;
+    this.setState({ editingFile: null });
+    if (current) {
+      this.callbacks.imageEditorOptions?.onCancel?.(current);
+      this.core.emit("image-editor-cancel", { file: current });
+    }
+    this.processEditorQueue();
+  }
+  /**
+   * Save an edited image. Converts the data URL to a blob, creates a new
+   * UploadFile preserving the original's identity, replaces it in state
+   * and core, then invokes the onSave callback.
+   */
+  saveImageEdit(editedImageData, mimeType) {
+    const editing = this.state.editingFile;
+    if (!editing) return;
+    const opts = this.callbacks.imageEditorOptions;
+    const outputMime = mimeType || opts?.output?.mimeType || editing.type;
+    const blob = new Blob([dataURLtoBlob(editedImageData)], {
+      type: outputMime
+    });
+    const newFile = blobToUploadFile(blob, editing, opts?.output);
+    const nextFiles = revokeAndReplace(
+      this.state.files,
+      editing.id,
+      newFile
+    );
+    this.setState({ files: nextFiles, editingFile: null });
+    this.core.replaceFile(editing.id, newFile);
+    opts?.onSave?.(newFile, editing);
+    this.core.emit("image-editor-save", {
+      file: newFile,
+      original: editing
+    });
+    this.processEditorQueue();
+  }
+  /** Replace a single file in state by id (revokes old blob URL). Also replaces in core. */
+  replaceFile(fileId, newFile) {
+    const nextFiles = revokeAndReplace(this.state.files, fileId, newFile);
+    this.setState({ files: nextFiles });
+    this.core.replaceFile(fileId, newFile);
+  }
+  /** Enqueue files for auto-opening in the image editor. */
+  enqueueForEditor(files) {
+    if (files.length === 0) return;
+    this.setState({ editorQueue: [...this.state.editorQueue, ...files] });
+    if (!this.state.editingFile) {
+      this.processEditorQueue();
+    }
+  }
+  /** Pop the next file from the editor queue and open it. */
+  processEditorQueue() {
+    if (this.state.editingFile || this.state.editorQueue.length === 0)
+      return;
+    const [next, ...rest] = this.state.editorQueue;
+    if (!next) return;
+    this.setState({ editorQueue: rest });
+    this.openImageEditor(next);
+  }
+  /**
+   * Project orchestrator state from core — the single source of truth (F-145).
+   * `uploadStatus` is derived from the `status` each status-carrying `state-change`
+   * event supplies (core sets `_status` before every such emit); the discrete
+   * upload-start/upload-all-complete/upload-error listeners no longer write it. `files`
+   * is rebuilt from `core.files`, and is a no-op when the file set is unchanged (same
+   * size + ordered ids + same UploadFile refs) so the `files` reference stays stable
+   * across the many status-only `state-change` events core emits during upload —
+   * preserving referential stability for useSyncExternalStore / computed consumers.
+   */
+  projectFromCore(payload) {
+    const partial = {};
+    if (payload?.status !== void 0) partial.uploadStatus = payload.status;
+    const coreFiles = this.core.files;
+    if (this.filesProjectionChanged(coreFiles)) {
+      partial.files = new Map(coreFiles);
+      partial.totalBytes = [...coreFiles.values()].reduce(
+        (sum, f) => sum + f.size,
+        0
+      );
+    }
+    if (Object.keys(partial).length > 0) this.setState(partial);
+  }
+  filesProjectionChanged(coreFiles) {
+    const current = this.state.files;
+    if (current.size !== coreFiles.size) return true;
+    const a = current.entries();
+    const b = coreFiles.entries();
+    for (let x = a.next(), y = b.next(); !x.done && !y.done; x = a.next(), y = b.next()) {
+      if (x.value[0] !== y.value[0] || x.value[1] !== y.value[1])
+        return true;
+    }
+    return false;
+  }
+  init() {
+    this.projectFromCore();
+    this.unsubs.push(
+      this.core.on("upload-start", () => {
+        this.callbacks.onUploadStart?.();
+      })
+    );
+    this.unsubs.push(
+      this.core.on(
+        "file-upload-start",
+        (payload) => {
+          this.callbacks.onFileUploadStart?.(payload.file);
+        }
+      )
+    );
+    this.unsubs.push(
+      this.core.on(
+        "state-change",
+        (payload) => {
+          this.projectFromCore(payload);
+        }
+      )
+    );
+    this.unsubs.push(
+      this.core.on("files-added", (added) => {
+        if (!Array.isArray(added) || added.length === 0) return;
+        this.callbacks.onFilesSelected?.(added);
+        const editorOpts = this.callbacks.imageEditorOptions;
+        if (editorOpts?.enabled) {
+          const images = added.filter(
+            (file) => file.type.startsWith("image/")
+          );
+          if (editorOpts.autoOpen === "single" && images.length === 1) {
+            const [firstImage] = images;
+            if (firstImage) this.enqueueForEditor([firstImage]);
+          }
+          if (editorOpts.autoOpen === "always" && images.length > 0) {
+            this.enqueueForEditor(images);
+          }
+        }
+        if (this.callbacks.autoUpload) {
+          this.core.emit("auto-upload", { count: added.length });
+          setTimeout(() => {
+            if (this.disposed) return;
+            void this.core.upload().catch(() => {
+            });
+          }, 0);
+        }
+      })
+    );
+    this.unsubs.push(
+      this.core.on("file-removed", (file) => {
+        this.callbacks.onFileRemoved?.(file);
+      })
+    );
+    this.unsubs.push(
+      this.core.on(
+        "upload-progress",
+        (progress) => {
+          const nextProgressMap = {
+            ...this.state.filesProgressMap,
+            [progress.fileId]: {
+              id: progress.fileId,
+              loaded: progress.loaded,
+              total: progress.total
+            }
+          };
+          const nextUploaded = Object.values(nextProgressMap).reduce(
+            (sum, item) => sum + item.loaded,
+            0
+          );
+          const { samples, speed, eta } = computeSpeedEta({
+            samples: this.speedSamples,
+            now: Date.now(),
+            uploadedBytes: nextUploaded,
+            totalBytes: this.state.totalBytes,
+            previousSpeed: this.state.uploadSpeed,
+            previousEta: this.state.uploadEta
+          });
+          this.speedSamples = samples;
+          this.setState({
+            filesProgressMap: nextProgressMap,
+            uploadedBytes: nextUploaded,
+            uploadSpeed: speed,
+            uploadEta: eta
+          });
+          const file = this.state.files.get(progress.fileId);
+          if (file) {
+            this.callbacks.onFileUploadProgress?.(file, {
+              loaded: progress.loaded,
+              total: progress.total,
+              percentage: progress.total > 0 ? Math.round(
+                progress.loaded / progress.total * 100
+              ) : 0
+            });
+          }
+          this.callbacks.onFilesUploadProgress?.(
+            this.core.progress.completedFiles,
+            this.core.progress.totalFiles
+          );
+        }
+      )
+    );
+    this.unsubs.push(
+      this.core.on(
+        "upload-success",
+        (payload) => {
+          const resultKey = payload.result.key;
+          this.callbacks.onFileUploadComplete?.(
+            payload.file,
+            resultKey ?? payload.file.key ?? ""
+          );
+        }
+      )
+    );
+    this.unsubs.push(
+      this.core.on("upload-all-complete", (completed) => {
+        this.callbacks.onFilesUploadComplete?.(completed);
+        this.callbacks.onUploadComplete?.(completed);
+      })
+    );
+    this.unsubs.push(
+      this.core.on(
+        "upload-error",
+        (payload) => {
+          const message = payload.error.message;
+          const code = payload.error instanceof UpupError ? payload.error.code : void 0;
+          this.setState({
+            uploadError: message,
+            uploadErrorCode: code
+          });
+          this.callbacks.onError?.(message);
+        }
+      )
+    );
+    if (typeof globalThis.window !== "undefined" && typeof globalThis.window.addEventListener === "function") {
+      const handleOnline = () => {
+        this.setState({ isOnline: true });
+        this.core.emit("connection-online", {});
+      };
+      const handleOffline = () => {
+        this.setState({ isOnline: false });
+        this.core.emit("connection-offline", {});
+      };
+      globalThis.window.addEventListener("online", handleOnline);
+      globalThis.window.addEventListener("offline", handleOffline);
+      this.unsubs.push(() => {
+        globalThis.window.removeEventListener("online", handleOnline);
+        globalThis.window.removeEventListener("offline", handleOffline);
+      });
+      if (typeof navigator !== "undefined" && typeof navigator.onLine === "boolean") {
+        this.setState({ isOnline: navigator.onLine });
+      }
+    }
+  }
+  destroy() {
+    this.disposed = true;
+    this.state.files.forEach((file) => {
+      revokeFileUrl(file);
+    });
+    this.unsubs.forEach((u) => {
+      u();
+    });
+    this.unsubs = [];
+    this.speedSamples = [];
+    this.listeners.clear();
+  }
+};
+
+// src/orchestrator/helpers.ts
+function getDir(locale) {
+  if (locale && typeof locale === "object" && "dir" in locale)
+    return locale.dir;
+  const code = typeof locale === "string" ? locale : "en-US";
+  const base = code.split("-")[0] ?? "";
+  const meta = LOCALE_META[code] ?? Object.values(LOCALE_META).find((m) => m.code.startsWith(base + "-"));
+  return meta?.dir ?? "ltr";
+}
+function normalizeSource(source) {
+  return Object.values(FileSource).includes(source) ? source : void 0;
+}
+var DEFAULT_SOURCES = [
+  "local" /* LOCAL */,
+  "url" /* URL */,
+  "camera" /* CAMERA */,
+  "microphone" /* MICROPHONE */,
+  "screen" /* SCREEN */
+];
+var DEFAULT_MAX_FILE_SIZE = { size: 1, unit: "GB" };
+
+// src/uploader/normalize-options.ts
+function normalizeUploaderOptions(options) {
+  const acceptProp = options.allowedFileTypes ?? "*";
+  const mini = options.mini ?? false;
+  const animations = options.animations ?? true;
+  const resolvedSources = options.sources ? options.sources.map((s) => normalizeSource(s)).filter(Boolean) : DEFAULT_SOURCES;
+  const resolvedLimit = options.maxFiles ?? 10;
+  const resolvedMode = options.mode ?? (options.serverUrl && !options.uploadEndpoint ? "server" : "client");
+  const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+  const accept = resolveAccept(
+    typeof acceptProp === "string" ? acceptProp : acceptProp.join(",")
+  );
+  const limit = mini ? 1 : Math.max(resolvedLimit, 1);
+  const multiple = mini ? false : limit > 1;
+  const folderUploadAllowDrop = options.folderUpload?.allowDrop ?? false;
+  const folderPickerButtonVisible = options.folderUpload?.showSelectFolderButton ?? false;
+  const imageEditor = (() => {
+    const ie = options.imageEditor;
+    if (ie === void 0 || ie === true)
+      return { enabled: true, autoOpen: "never", display: "inline" };
+    if (typeof ie === "object" && ie !== null) {
+      const o = ie;
+      return {
+        ...o,
+        enabled: o.enabled ?? true,
+        autoOpen: o.autoOpen ?? "never",
+        display: o.display ?? "inline"
+      };
+    }
+    return { enabled: false, autoOpen: "never", display: "inline" };
+  })();
+  const i18n = options.i18n;
+  const bundle = i18n?.bundle ?? resolveLocaleBundle(i18n?.locale);
+  const fallbackBundle = resolveLocaleBundle(i18n?.fallbackLocale);
+  const translator = createTranslator({
+    bundle: bundle ?? enUS,
+    fallback: fallbackBundle ?? enUS,
+    overrides: i18n?.overrides
+  });
+  const translations = flattenTranslatorToUiTranslations(translator);
+  const lang = bundle?.code ?? (typeof i18n?.locale === "string" ? i18n.locale : "en-US");
+  const dir = bundle?.dir ?? getDir(i18n?.locale);
+  const resolved = {
+    mini,
+    animations,
+    sources: resolvedSources,
+    allowedFileTypes: accept,
+    limit,
+    maxFileSize,
+    multiple,
+    mode: resolvedMode,
+    serverUrl: options.serverUrl,
+    folderUploadAllowDrop,
+    folderPickerButtonVisible,
+    imageEditor,
+    resumable: options.resumable,
+    translator,
+    translations,
+    lang,
+    dir,
+    cloudDrives: options.cloudDrives
+  };
+  const coreOptions = {
+    uploadEndpoint: options.uploadEndpoint || void 0,
+    serverUrl: options.serverUrl,
+    provider: options.provider,
+    mode: resolvedMode,
+    allowedFileTypes: accept,
+    limit,
+    maxFileSize,
+    minFileSize: options.minFileSize,
+    maxTotalFileSize: options.maxTotalFileSize,
+    maxRetries: options.maxRetries,
+    onBeforeFileAdded: options.onBeforeFileAdded,
+    imageCompression: options.imageCompression,
+    thumbnailGenerator: options.thumbnailGenerator,
+    checksumVerification: options.checksumVerification,
+    webWorker: options.webWorker,
+    heicConversion: options.heicConversion,
+    stripExifData: options.stripExifData,
+    contentDeduplication: options.contentDeduplication,
+    crashRecovery: options.crashRecovery,
+    // Forwarded verbatim: `undefined` must survive so core's default-on
+    // network awareness applies; only an explicit `false` opts out.
+    networkAware: options.networkAware,
+    maxConcurrentUploads: options.maxConcurrentUploads,
+    metadata: options.metadata,
+    cors: options.cors,
+    resumable: options.resumable,
+    cloudDrives: options.cloudDrives,
+    locale: bundle
+  };
+  return { coreOptions, resolved };
+}
+
+// src/uploader/motion-gate.ts
+var REDUCE_QUERY = "(prefers-reduced-motion: reduce)";
+function createMotionGate({
+  animations,
+  matchMedia = typeof window !== "undefined" && typeof window.matchMedia === "function" ? window.matchMedia.bind(window) : void 0
+}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let reduced = false;
+  let mql = null;
+  const onChange = (e) => {
+    reduced = e.matches;
+    listeners.forEach((l) => {
+      l();
+    });
+  };
+  if (matchMedia) {
+    mql = matchMedia(REDUCE_QUERY);
+    reduced = mql.matches;
+    mql.addEventListener("change", onChange);
+  }
+  return {
+    getSnapshot: () => animations === false || reduced ? "off" : "on",
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    destroy() {
+      mql?.removeEventListener("change", onChange);
+      listeners.clear();
+    }
+  };
+}
+
+// src/uploader/transient-ui-state.ts
+function createTransientUiState({
+  motion,
+  reallyRemove,
+  exitMs = 200,
+  overlayMs = 350,
+  toastMs = 3e3
+}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const leaving = /* @__PURE__ */ new Set();
+  const timers = /* @__PURE__ */ new Set();
+  let overlayOpen = false;
+  let overlayClosing = false;
+  let overlayGen = 0;
+  let rejected = null;
+  let toastGen = 0;
+  let destroyed = false;
+  function compute() {
+    return {
+      leavingFileIds: new Set(leaving),
+      sourceOverlayOpen: overlayOpen,
+      sourceOverlayClosing: overlayClosing,
+      dropRejected: rejected
+    };
+  }
+  let snapshot = compute();
+  function notify() {
+    snapshot = compute();
+    listeners.forEach((l) => {
+      l();
+    });
+  }
+  function later(ms, fn) {
+    const t = setTimeout(() => {
+      timers.delete(t);
+      if (!destroyed) fn();
+    }, ms);
+    timers.add(t);
+  }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    removeFileAnimated(fileId) {
+      if (leaving.has(fileId)) return;
+      if (motion() === "off") {
+        reallyRemove(fileId);
+        return;
+      }
+      leaving.add(fileId);
+      notify();
+      later(exitMs, () => {
+        leaving.delete(fileId);
+        reallyRemove(fileId);
+        notify();
+      });
+    },
+    openSourceOverlay() {
+      if (overlayOpen) return;
+      overlayOpen = true;
+      overlayClosing = false;
+      overlayGen++;
+      notify();
+    },
+    closeSourceOverlay() {
+      if (!overlayOpen) return;
+      overlayOpen = false;
+      if (motion() === "off") {
+        overlayClosing = false;
+        notify();
+        return;
+      }
+      overlayClosing = true;
+      const g = ++overlayGen;
+      notify();
+      later(overlayMs, () => {
+        if (g === overlayGen) {
+          overlayClosing = false;
+          notify();
+        }
+      });
+    },
+    flagDropRejected(provider) {
+      rejected = provider;
+      const g = ++toastGen;
+      notify();
+      later(toastMs, () => {
+        if (g === toastGen) {
+          rejected = null;
+          notify();
+        }
+      });
+    },
+    destroy() {
+      destroyed = true;
+      timers.forEach((t) => {
+        clearTimeout(t);
+      });
+      timers.clear();
+      listeners.clear();
+    }
+  };
+}
+
+// src/uploader/create-uploader-controller.ts
+function createUploaderController({ core, options, normalized }, hostHooks = {}) {
+  const { resolved } = normalized;
+  const { connectSSE } = hostHooks;
+  const onError = (message) => options.onError?.(message);
+  let callbackRefs = { ...options };
+  const proxiedCallbacks = {
+    get onError() {
+      return callbackRefs.onError;
+    },
+    get onWarn() {
+      return callbackRefs.onWarn;
+    },
+    get onUploadStart() {
+      return callbackRefs.onUploadStart;
+    },
+    get onFileUploadStart() {
+      return callbackRefs.onFileUploadStart;
+    },
+    get onFileUploadProgress() {
+      return callbackRefs.onFileUploadProgress;
+    },
+    get onFilesUploadProgress() {
+      return callbackRefs.onFilesUploadProgress;
+    },
+    get onFileUploadComplete() {
+      return callbackRefs.onFileUploadComplete;
+    },
+    get onFilesUploadComplete() {
+      return (files) => {
+        callbackRefs.onFilesUploadComplete?.(files);
+        if (connectSSE && Array.isArray(files))
+          files.forEach((f) => {
+            connectSSE(f);
+          });
+      };
+    },
+    get onUploadComplete() {
+      return callbackRefs.onUploadComplete;
+    },
+    get onFilesSelected() {
+      return callbackRefs.onFilesSelected;
+    },
+    get onDoneClicked() {
+      return callbackRefs.onDoneClicked;
+    },
+    get onPrepareFiles() {
+      return callbackRefs.onPrepareFiles;
+    },
+    get onFileRemoved() {
+      return callbackRefs.onFileRemoved;
+    },
+    get imageEditorOptions() {
+      return resolved.imageEditor;
+    },
+    get autoUpload() {
+      return callbackRefs.autoUpload ?? false;
+    }
+  };
+  const orchestrator = new UploaderOrchestrator(core, proxiedCallbacks);
+  const themeConfig = options.theme ?? (options.dark !== void 0 ? { mode: options.dark ? "dark" : "light" } : void 0);
+  const theme = new ThemeStore(themeConfig);
+  const motionGate = createMotionGate({ animations: resolved.animations });
+  const transientUi = createTransientUiState({
+    motion: () => motionGate.getSnapshot(),
+    reallyRemove: (fileId) => {
+      orchestrator.removeFile(fileId);
+    }
+  });
+  const drivePlugins = [];
+  function registerPlugins() {
+    const cd = resolved.cloudDrives;
+    if (cd?.googleDrive) {
+      const p = new GoogleDrivePlugin();
+      p.configure(cd.googleDrive);
+      try {
+        core.use(p);
+      } catch {
+      }
+      drivePlugins.push(p);
+    }
+    if (cd?.dropbox) {
+      const p = new DropboxPlugin();
+      p.configure(cd.dropbox);
+      try {
+        core.use(p);
+      } catch {
+      }
+      drivePlugins.push(p);
+    }
+    if (cd?.box) {
+      const p = new BoxPlugin();
+      p.configure(cd.box);
+      try {
+        core.use(p);
+      } catch {
+      }
+      drivePlugins.push(p);
+    }
+    if (cd?.oneDrive) {
+      const p = new OneDrivePlugin();
+      p.configure(cd.oneDrive);
+      try {
+        core.use(p);
+      } catch {
+      }
+      drivePlugins.push(p);
+    }
+  }
+  let inputEl = null;
+  const registerFileInput = (el) => {
+    inputEl = el;
+  };
+  const getFileInput = () => inputEl;
+  const openFilePicker = () => inputEl?.click();
+  const filesArray = () => [...core.files.values()];
+  const commands = {
+    async handleSetSelectedFiles(newFiles) {
+      const before = core.files.size;
+      try {
+        await core.addFiles(newFiles);
+        if (core.files.size > before && !orchestrator.getSnapshot().activeSource) {
+          transientUi.closeSourceOverlay();
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError(message);
+        const first = newFiles[0];
+        if (first) {
+          const m = message.toLowerCase();
+          if (m.includes("type")) {
+            callbackRefs.onFileTypeMismatch?.(
+              first,
+              resolved.allowedFileTypes
+            );
+            callbackRefs.onRestrictionFailed?.(
+              first,
+              "TYPE_MISMATCH"
+            );
+          } else if (m.includes("limit")) {
+            callbackRefs.onRestrictionFailed?.(
+              first,
+              "LIMIT_EXCEEDED"
+            );
+          } else if (m.includes("below")) {
+            callbackRefs.onRestrictionFailed?.(
+              first,
+              "FILE_TOO_SMALL"
+            );
+          } else if (m.includes("size")) {
+            callbackRefs.onRestrictionFailed?.(
+              first,
+              "FILE_TOO_LARGE"
+            );
+          }
+        }
+      }
+    },
+    // Upload-control commands are pure delegation: UploaderOrchestrator is
+    // the single owner of the upload-control flow (F-722) — it holds the
+    // projected state, clears uploadError/uploadErrorCode before a new
+    // run, and owns the done/state-reset emissions. Re-implementing any of
+    // these here re-creates the drifting second copy pass 2 removed.
+    handleFileRemove(fileId) {
+      transientUi.removeFileAnimated(fileId);
+    },
+    handleRemoveAll() {
+      core.removeAll();
+    },
+    async uploadFiles(newFiles) {
+      await core.setFiles(newFiles);
+      return core.upload();
+    },
+    replaceFiles(newFiles) {
+      filesArray().forEach((f) => {
+        revokeFileUrl(f);
+      });
+      void core.setFiles(newFiles);
+    },
+    startUpload() {
+      return orchestrator.startUpload();
+    },
+    retryUpload(fileId) {
+      return orchestrator.retryUpload(fileId);
+    },
+    handleCancel() {
+      orchestrator.handleCancel();
+    },
+    handlePause() {
+      orchestrator.handlePause();
+    },
+    handleResume() {
+      orchestrator.handleResume();
+    },
+    handleDone() {
+      orchestrator.handleDone();
+    },
+    resetState() {
+      orchestrator.resetState();
+    },
+    openImageEditor(file) {
+      orchestrator.openImageEditor(file);
+    },
+    closeImageEditor() {
+      orchestrator.closeImageEditor();
+    },
+    saveImageEdit(editedImageData, mimeType) {
+      orchestrator.saveImageEdit(editedImageData, mimeType);
+    },
+    replaceFile(fileId, newFile) {
+      orchestrator.replaceFile(fileId, newFile);
+    },
+    setActiveSource(a) {
+      orchestrator.setActiveSource(a);
+    },
+    setIsAddingMore(v) {
+      orchestrator.setIsAddingMore(v);
+    },
+    setViewMode(m) {
+      orchestrator.setViewMode(m);
+    }
+  };
+  let lastStatus;
+  let statusUnsub = null;
+  const subscribers = /* @__PURE__ */ new Set();
+  let fanInUnsubs = [];
+  function ensureFanIn() {
+    if (fanInUnsubs.length > 0) return;
+    const notifyAll = () => {
+      subscribers.forEach((l) => {
+        l();
+      });
+    };
+    fanInUnsubs = [
+      core.on("state-change", notifyAll),
+      orchestrator.subscribe(notifyAll),
+      theme.subscribe(notifyAll),
+      motionGate.subscribe(notifyAll),
+      transientUi.subscribe(notifyAll)
+    ];
+  }
+  function tearDownFanIn() {
+    fanInUnsubs.forEach((u) => {
+      u();
+    });
+    fanInUnsubs = [];
+  }
+  let initialized = false;
+  let destroyed = false;
+  function init() {
+    if (initialized) return;
+    initialized = true;
+    destroyed = false;
+    orchestrator.init();
+    theme.init();
+    registerPlugins();
+    statusUnsub = orchestrator.subscribe(() => {
+      const s = orchestrator.getSnapshot().uploadStatus;
+      const str = s.toLowerCase();
+      if (str !== lastStatus) {
+        lastStatus = str;
+        callbackRefs.onStatusChange?.(str);
+      }
+    });
+    if (options.crashRecovery)
+      void core.restoreFromCrashRecovery().catch((err) => {
+        if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+          console.warn("[upup] crash-recovery restore failed", err);
+        }
+      });
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    initialized = false;
+    statusUnsub?.();
+    statusUnsub = null;
+    lastStatus = void 0;
+    drivePlugins.splice(0).forEach((p) => {
+      p.destroy();
+    });
+    tearDownFanIn();
+    orchestrator.destroy();
+    transientUi.destroy();
+    motionGate.destroy();
+    theme.destroy();
+  }
+  function subscribe(listener) {
+    subscribers.add(listener);
+    ensureFanIn();
+    return () => {
+      subscribers.delete(listener);
+      if (subscribers.size === 0) {
+        tearDownFanIn();
+      }
+    };
+  }
+  function updateCallbacks(next) {
+    callbackRefs = { ...callbackRefs, ...next };
+  }
+  return {
+    core,
+    orchestrator,
+    theme,
+    motionGate,
+    transientUi,
+    resolved,
+    commands,
+    registerFileInput,
+    getFileInput,
+    openFilePicker,
+    updateCallbacks,
+    subscribe,
+    init,
+    destroy
+  };
+}
+
+// src/uploader/create-child-controller.ts
+function createChildController(factory, options = {}) {
+  const controller = factory();
+  let started = false;
+  let stopped = false;
+  let unsub = null;
+  return {
+    controller,
+    init() {
+      if (started) return;
+      started = true;
+      controller.init?.();
+      if (options.onChange && controller.subscribe)
+        unsub = controller.subscribe(options.onChange);
+    },
+    destroy() {
+      if (stopped) return;
+      stopped = true;
+      unsub?.();
+      unsub = null;
+      controller.destroy?.();
+    }
+  };
+}
+
+// src/drives/bind-drive-events.ts
+function bindDriveEvents(core, provider, callbacks) {
+  const unsubs = [
+    core.on(`${provider}:authenticated`, callbacks.onAuthenticated),
+    core.on(`${provider}:signed-out`, callbacks.onSignedOut),
+    core.on(`${provider}:session-expired`, callbacks.onSessionExpired),
+    core.on(`${provider}:files-loaded`, callbacks.onFilesLoaded),
+    core.on(`${provider}:state-change`, callbacks.onStateChange),
+    core.on(`${provider}:error`, callbacks.onError)
+  ];
+  return () => {
+    unsubs.forEach((u) => {
+      u();
+    });
+  };
+}
+
+// src/utils/load-gapi.ts
+var GIS_SCRIPT_SRC = "https://accounts.google.com/gsi/client";
+var gisPromise = null;
+function loadGoogleIdentityServices() {
+  if (gisPromise) return gisPromise;
+  gisPromise = new Promise((resolve, reject) => {
+    const existing = document.querySelector(
+      `script[src="${GIS_SCRIPT_SRC}"]`
+    );
+    if (existing) {
+      existing.addEventListener("load", () => {
+        resolve();
+      });
+      existing.addEventListener("error", () => {
+        reject(new Error(`Failed to load script: ${GIS_SCRIPT_SRC}`));
+      });
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = GIS_SCRIPT_SRC;
+    script.async = true;
+    script.onload = () => {
+      resolve();
+    };
+    script.onerror = () => {
+      reject(new Error(`Failed to load script: ${GIS_SCRIPT_SRC}`));
+    };
+    document.head.appendChild(script);
+  });
+  return gisPromise;
+}
+
+// src/drives/drive-browser-controller.ts
+var GIS_SCOPE = "https://www.googleapis.com/auth/drive.readonly https://www.googleapis.com/auth/userinfo.profile";
+var DriveBrowserController = class {
+  constructor(core, descriptor, callbacks) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.plugin = null;
+    this.tokenClient = null;
+    this.unsubs = [];
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    this.getSnapshot = () => this.state;
+    this.core = core;
+    this.descriptor = descriptor;
+    this.callbacks = callbacks;
+    this.state = {
+      user: void 0,
+      folder: void 0,
+      path: [],
+      selectedFiles: [],
+      isClickLoading: false,
+      showLoader: false,
+      isAuthReady: false,
+      isAuthenticated: false,
+      isLoading: true,
+      authCancelled: false,
+      token: void 0,
+      error: void 0,
+      hasMore: false,
+      isLoadingMore: false
+    };
+  }
+  setState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.notify();
+  }
+  notify() {
+    this.listeners.forEach((fn) => {
+      fn();
+    });
+  }
+  // ── Lifecycle ────────────────────────────────────────────────
+  init() {
+    const plugin = this.core.getPlugin(this.descriptor.pluginId);
+    if (!plugin) return;
+    this.plugin = plugin;
+    this.restore(plugin);
+    this.unsubs.push(this.bindEvents());
+    if (this.descriptor.auth === "gis") {
+      void this.initGis(plugin);
+    }
+  }
+  destroy() {
+    this.unsubs.forEach((u) => {
+      u();
+    });
+    this.unsubs = [];
+    this.listeners.clear();
+    this.plugin = null;
+    this.tokenClient = null;
+  }
+  // ── Restore session on mount ─────────────────────────────────
+  restore(plugin) {
+    const restored = plugin.restoreSession();
+    if (this.descriptor.auth === "gis") {
+      if (!restored) return;
+      this.setState({
+        token: {
+          access_token: plugin.getAccessToken() || "",
+          expires_in: 3600
+        }
+      });
+      void (async () => {
+        try {
+          const userInfo = await plugin.getUserInfo();
+          if (userInfo) this.setState({ user: userInfo });
+        } catch {
+        }
+        await plugin.loadFiles(this.descriptor.loadFilesRootArg);
+      })();
+    } else {
+      this.setState({ isAuthenticated: restored, isLoading: false });
+      if (!restored) return;
+      void (async () => {
+        try {
+          const userInfo = await plugin.getUserInfo();
+          if (userInfo) this.setState({ user: userInfo });
+        } catch {
+        }
+        try {
+          await plugin.loadFiles(this.descriptor.loadFilesRootArg);
+        } catch {
+        }
+      })();
+    }
+  }
+  // ── Event subscriptions (the 6 canonical drive events) ─────
+  bindEvents() {
+    const isGis = this.descriptor.auth === "gis";
+    return bindDriveEvents(this.core, this.descriptor.eventPrefix, {
+      onAuthenticated: (payload) => {
+        const data = payload;
+        if (isGis) {
+          if (data.user) this.setState({ user: data.user });
+          this.setState({ isAuthReady: true });
+        } else {
+          this.setState({
+            user: data.user ?? this.state.user,
+            isAuthenticated: true,
+            isLoading: false
+          });
+        }
+      },
+      onSignedOut: () => {
+        this.resetSession();
+      },
+      onSessionExpired: () => {
+        this.resetSession();
+      },
+      onFilesLoaded: (payload) => {
+        const p = payload;
+        const folder = this.buildRootFolder(p);
+        this.cursor = p.cursor;
+        this.setState({
+          folder,
+          path: this.nextPath(folder),
+          isClickLoading: false,
+          error: void 0,
+          hasMore: !!p.hasMore
+        });
+      },
+      onStateChange: (payload) => {
+        const data = payload;
+        if (isGis) {
+          if (data.state === "browsing")
+            this.setState({ isClickLoading: true });
+        } else {
+          this.setState({
+            isLoading: data.state === "authenticating" || data.state === "browsing"
+          });
+        }
+      },
+      onError: (payload) => {
+        const p = payload;
+        this.setState({
+          isClickLoading: false,
+          showLoader: false,
+          isLoadingMore: false,
+          error: {
+            message: p?.error?.message || "Unknown error",
+            action: p?.action
+          }
+        });
+      }
+    });
+  }
+  /**
+   * The single session-teardown home (F-127). onSignedOut and onSessionExpired
+   * previously drifted independently — onSessionExpired forgot to clear
+   * selectedFiles/pendingFolder, leaking a stale selection into the next
+   * sign-in. Both now delegate here.
+   */
+  resetSession() {
+    this.pendingFolder = void 0;
+    this.cursor = void 0;
+    this.setState({
+      user: void 0,
+      folder: void 0,
+      token: void 0,
+      path: [],
+      selectedFiles: [],
+      isAuthenticated: false,
+      hasMore: false,
+      error: void 0
+    });
+  }
+  buildRootFolder(payload) {
+    const d = this.descriptor;
+    const rawId = d.folderIdField === "path" ? payload.path : payload.folderId;
+    const id = rawId || d.rootFolderId;
+    const isRoot = !rawId || id === d.rootFolderId;
+    let name;
+    if (isRoot) name = d.rootFolderName;
+    else if (this.pendingFolder?.id === id) name = this.pendingFolder.name;
+    else if (d.folderKey === "path")
+      name = id.split("/").pop() || d.rootFolderName;
+    else name = id;
+    return {
+      id,
+      name,
+      path: d.folderKey === "path" ? payload.path || "" : "",
+      size: 0,
+      mimeType: "",
+      isFolder: true,
+      children: payload.files
+    };
+  }
+  // ── Auth ─────────────────────────────────────────────────────
+  async initGis(plugin) {
+    const cfg = plugin.getConfig?.() ?? {};
+    if (!cfg.clientId || !cfg.apiKey) {
+      this.setState({
+        isAuthReady: true,
+        error: {
+          message: "Google Drive is not configured (missing clientId/apiKey)",
+          action: "init"
+        }
+      });
+      return;
+    }
+    if (plugin.isAuthenticated()) {
+      this.setState({ isAuthReady: true });
+      return;
+    }
+    await loadGoogleIdentityServices();
+    const google = window.google;
+    if (!google) {
+      this.setState({
+        isAuthReady: true,
+        error: {
+          message: "Google Identity Services failed to load",
+          action: "init"
+        }
+      });
+      return;
+    }
+    this.tokenClient = google.accounts.oauth2.initTokenClient({
+      client_id: cfg.clientId,
+      scope: GIS_SCOPE,
+      ux_mode: "popup",
+      callback: (tokenResponse) => {
+        if (tokenResponse.error) return;
+        this.setState({
+          authCancelled: false,
+          token: {
+            access_token: tokenResponse.access_token,
+            expires_in: Date.now() + (tokenResponse.expires_in - 20) * 1e3
+          }
+        });
+        void plugin.authenticate?.(
+          tokenResponse.access_token,
+          tokenResponse.expires_in
+        ).then(
+          () => plugin.loadFiles(this.descriptor.loadFilesRootArg)
+        );
+      },
+      error_callback: () => {
+        this.setState({ authCancelled: true });
+      }
+    });
+    this.setState({ isAuthReady: true });
+  }
+  signIn() {
+    if (this.descriptor.auth === "gis") {
+      this.tokenClient?.requestAccessToken({});
+    } else {
+      void this.runPopupAuth();
+    }
+  }
+  retryAuth() {
+    if (this.descriptor.auth === "gis") {
+      this.setState({ authCancelled: false });
+      this.tokenClient?.requestAccessToken({});
+    } else {
+      void this.runPopupAuth();
+    }
+  }
+  async runPopupAuth() {
+    const plugin = this.plugin;
+    if (!plugin?.authenticateViaPopup) return;
+    this.setState({ isLoading: true });
+    await plugin.authenticateViaPopup();
+    if (plugin.isAuthenticated()) {
+      await plugin.loadFiles(this.descriptor.loadFilesRootArg);
+    }
+  }
+  signOut() {
+    this.plugin?.signOut();
+    this.setState({ token: void 0 });
+  }
+  // ── Browse / select actions ──────────────────────────────────
+  /**
+   * Folder trail for the breadcrumb, owned here so every framework stays consistent
+   * (react/vue/svelte previously seeded it in a component effect that collapsed the
+   * trail; vanilla/angular had no seed at all). Root load resets to [root]; descending
+   * appends; re-loading a folder already in the trail truncates to it. Ids must stay
+   * unique — the breadcrumb is keyed by folder id.
+   */
+  nextPath(folder) {
+    if (folder.id === this.descriptor.rootFolderId) return [folder];
+    const cur = this.state.path;
+    const idx = cur.findIndex((p) => p.id === folder.id);
+    if (idx >= 0) return [...cur.slice(0, idx), folder];
+    return [...cur, folder];
+  }
+  setPath(path) {
+    this.cursor = void 0;
+    this.setState({ path, hasMore: false });
+  }
+  handleClick(file) {
+    const plugin = this.plugin;
+    if (!plugin) return;
+    if (file.isFolder) {
+      this.setState({ isClickLoading: true });
+      const arg = this.descriptor.folderKey === "path" ? file.path : file.id;
+      this.pendingFolder = { id: arg, name: file.name };
+      void plugin.loadFiles(arg);
+    } else {
+      const prev = this.state.selectedFiles;
+      const next = prev.some((f) => f.id === file.id) ? prev.filter((f) => f.id !== file.id) : [...prev, file];
+      this.setState({ selectedFiles: next });
+    }
+  }
+  async handleSubmit() {
+    const plugin = this.plugin;
+    if (!plugin || this.state.selectedFiles.length === 0) return;
+    this.setState({ showLoader: true });
+    try {
+      await this.downloadAndClose(this.state.selectedFiles);
+    } catch {
+    } finally {
+      this.setState({ showLoader: false });
+    }
+  }
+  handleCancelDownload() {
+    this.setState({ selectedFiles: [] });
+  }
+  async onSelectCurrentFolder() {
+    const plugin = this.plugin;
+    if (!plugin) return;
+    if (this.descriptor.selectFolder === "cached-children") {
+      const current = this.state.path[this.state.path.length - 1];
+      if (!current) return;
+      this.setState({ showLoader: true });
+      try {
+        await this.downloadAndClose(current.children);
+      } catch {
+      } finally {
+        this.setState({ showLoader: false });
+      }
+      return;
+    }
+    if (!plugin.loadAllFilesInFolder || !this.state.folder) return;
+    this.setState({ showLoader: true });
+    try {
+      const folderArg = this.state.folder[this.descriptor.folderKey] || this.descriptor.loadAllRootArg || "";
+      const all = await plugin.loadAllFilesInFolder(folderArg);
+      await this.downloadAndClose(all);
+    } catch {
+    } finally {
+      this.setState({ showLoader: false });
+    }
+  }
+  /**
+   * Append-driven pagination (F-125), mirroring onSelectCurrentFolder's
+   * await-then-use-the-return-value style rather than reacting to another
+   * files-loaded event — the same convention, not a second one. A no-op
+   * unless the plugin supports it, the current view has more to fetch, and
+   * a continuation token exists.
+   */
+  async loadMore() {
+    const plugin = this.plugin;
+    if (!plugin?.loadMoreFiles || !this.state.hasMore || !this.cursor || this.state.isLoadingMore) {
+      return;
+    }
+    this.setState({ isLoadingMore: true, error: void 0 });
+    try {
+      const page = await plugin.loadMoreFiles(this.cursor);
+      const folder = this.state.folder;
+      if (!folder) {
+        this.setState({ isLoadingMore: false });
+        return;
+      }
+      const merged = {
+        ...folder,
+        children: [...folder.children, ...page.files]
+      };
+      const path = this.state.path.slice();
+      const tail = path[path.length - 1];
+      if (tail && tail.id === folder.id) {
+        path[path.length - 1] = merged;
+      }
+      this.cursor = page.cursor;
+      this.setState({
+        folder: merged,
+        path,
+        hasMore: page.hasMore,
+        isLoadingMore: false
+      });
+    } catch {
+      this.setState({ isLoadingMore: false });
+    }
+  }
+  async downloadAndClose(files) {
+    const plugin = this.plugin;
+    if (!plugin) return;
+    const fileOnly = files.filter((f) => !f.isFolder);
+    if (fileOnly.length > 0) {
+      const downloaded = await plugin.downloadFiles(fileOnly);
+      if (downloaded.length > 0)
+        this.callbacks.onFilesSelected(downloaded);
+    }
+    this.setState({ selectedFiles: [] });
+    this.callbacks.onClose();
+  }
+};
+
+// src/folder-drop.ts
+function setRelativePath(file, path) {
+  try {
+    Object.defineProperty(file, "relativePath", {
+      value: path.replace(/^\//, ""),
+      configurable: true,
+      enumerable: false,
+      writable: true
+    });
+  } catch {
+  }
+}
+function fileFromWebkitEntry(entry) {
+  return new Promise((resolve, reject) => {
+    entry.file?.((file) => {
+      setRelativePath(file, entry.fullPath || `/${file.name}`);
+      resolve([file]);
+    }, reject);
+  });
+}
+async function traverseWebkitEntry(entry, allowFolderDrop, state) {
+  if (entry.isFile) return fileFromWebkitEntry(entry);
+  if (!entry.isDirectory) return [];
+  if (!allowFolderDrop) {
+    state.skippedDirectory = true;
+    return [];
+  }
+  const reader = entry.createReader?.();
+  if (!reader) return [];
+  const entries = await new Promise((resolve, reject) => {
+    reader.readEntries(resolve, reject);
+  });
+  const nested = await Promise.all(
+    entries.map(
+      (child) => traverseWebkitEntry(child, allowFolderDrop, state)
+    )
+  );
+  return nested.flat();
+}
+async function traverseHandle(handle, allowFolderDrop, state, path = "") {
+  if (handle.kind === "file" && handle.getFile) {
+    const file = await handle.getFile();
+    setRelativePath(file, path + file.name);
+    return [file];
+  }
+  if (handle.kind !== "directory") return [];
+  if (!allowFolderDrop) {
+    state.skippedDirectory = true;
+    return [];
+  }
+  if (!handle.entries) return [];
+  const out = [];
+  for await (const [name, child] of handle.entries()) {
+    out.push(
+      ...await traverseHandle(
+        child,
+        allowFolderDrop,
+        state,
+        path + name + "/"
+      )
+    );
+  }
+  return out;
+}
+async function collectDroppedFiles(dataTransfer, allowFolderDrop) {
+  const items = Array.from(dataTransfer.items);
+  const state = { skippedDirectory: false };
+  const firstItem = items[0];
+  const supportsWebkitEntries = typeof firstItem?.webkitGetAsEntry === "function";
+  if (supportsWebkitEntries) {
+    const entries = items.map((item) => item.webkitGetAsEntry()).filter(Boolean);
+    const nested = await Promise.all(
+      entries.map(
+        (entry) => traverseWebkitEntry(entry, allowFolderDrop, state)
+      )
+    );
+    const files = nested.flat();
+    if (files.length > 0 || state.skippedDirectory) {
+      return { files, skippedDirectory: state.skippedDirectory };
+    }
+  }
+  const supportsHandles = "getAsFileSystemHandle" in (firstItem || {});
+  if (supportsHandles) {
+    const handles = await Promise.all(
+      items.map(
+        async (item) => await item.getAsFileSystemHandle?.()
+      )
+    );
+    const nested = await Promise.all(
+      handles.filter(
+        (handle) => Boolean(handle)
+      ).map((handle) => traverseHandle(handle, allowFolderDrop, state))
+    );
+    const files = nested.flat();
+    if (files.length > 0 || state.skippedDirectory) {
+      return { files, skippedDirectory: state.skippedDirectory };
+    }
+  }
+  return {
+    files: Array.from(dataTransfer.files),
+    skippedDirectory: false
+  };
+}
+
+// src/controllers/drag-drop-controller.ts
+var READONLY_DRIVE_SOURCE_MAP = {
+  googleDrive: true,
+  oneDrive: true,
+  dropbox: true,
+  box: true
+};
+var READONLY_DRIVE_SOURCES = new Set(
+  Object.keys(READONLY_DRIVE_SOURCE_MAP)
+);
+var DragDropController = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.isDragging = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.unsubOrchestrator = null;
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    this.getSnapshot = () => this.snapshot;
+    this.handleDragOver = this.handleDragOver.bind(this);
+    this.handleDragLeave = this.handleDragLeave.bind(this);
+    this.handleDrop = this.handleDrop.bind(this);
+    this.handlePaste = this.handlePaste.bind(this);
+    this.snapshot = this.compute();
+  }
+  /** Subscribe to the orchestrator so border/dragging derive on change. Call on mount. Idempotent. */
+  init() {
+    if (this.unsubOrchestrator) return;
+    this.unsubOrchestrator = this.deps.orchestrator.subscribe(() => {
+      this.recompute();
+    });
+    this.recompute();
+  }
+  get disabled() {
+    const p = this.deps.props();
+    const o = this.deps.orchestrator.getSnapshot();
+    return p.disableDragDrop || !!o.activeSource || isUploadActive(o.uploadStatus);
+  }
+  compute() {
+    const o = this.deps.orchestrator.getSnapshot();
+    const filesSize = this.deps.filesSize();
+    const active = o.activeSource;
+    const isAddingMore = o.isAddingMore;
+    return {
+      isDragging: this.isDragging,
+      absoluteIsDragging: this.isDragging && !active,
+      absoluteHasBorder: (!filesSize || isAddingMore || this.isDragging) && !active
+    };
+  }
+  /**
+   * Recompute the cached snapshot from current inputs and notify if it changed.
+   * Runs automatically on drag events and orchestrator changes. Hosts may also call
+   * it to refresh after external state the controller cannot observe via the
+   * orchestrator — e.g. a framework that removes files through `core.removeFile`
+   * directly (which emits no orchestrator notify), leaving the file-count-derived
+   * `absoluteHasBorder` stale.
+   */
+  recompute() {
+    const next = this.compute();
+    const prev = this.snapshot;
+    if (next.isDragging === prev.isDragging && next.absoluteIsDragging === prev.absoluteIsDragging && next.absoluteHasBorder === prev.absoluteHasBorder)
+      return;
+    this.snapshot = next;
+    this.notify();
+  }
+  notify() {
+    this.listeners.forEach((fn) => {
+      fn();
+    });
+  }
+  handleDragOver(e) {
+    if (this.disabled || this.deps.props().isProcessing) return;
+    e.preventDefault();
+    this.isDragging = true;
+    if (e.dataTransfer) e.dataTransfer.dropEffect = "copy";
+    const dropped = Array.from(e.dataTransfer?.files || []);
+    this.deps.options().onFilesDragOver?.(dropped);
+    this.deps.core.emit("drag-over", {});
+    this.recompute();
+  }
+  handleDragLeave(e) {
+    if (this.disabled || this.deps.props().isProcessing) return;
+    e.preventDefault();
+    const container = e.currentTarget;
+    const destination = e.relatedTarget;
+    if (container && destination && typeof container.contains === "function" && container.contains(destination))
+      return;
+    this.isDragging = false;
+    const dropped = Array.from(e.dataTransfer?.files || []);
+    this.deps.options().onFilesDragLeave?.(dropped);
+    this.deps.core.emit("drag-leave", {});
+    this.recompute();
+  }
+  /** True when the drag payload carries at least one file. */
+  dropHasFiles(e) {
+    const dt = e.dataTransfer;
+    if (!dt) return false;
+    if (dt.files && dt.files.length > 0) return true;
+    const types = dt.types ? Array.from(dt.types) : [];
+    if (types.includes("Files")) return true;
+    return dt.items ? Array.from(dt.items).some((i) => i.kind === "file") : false;
+  }
+  async handleDrop(e) {
+    const p = this.deps.props();
+    if (p.isProcessing || p.disableDragDrop) return;
+    const active = this.deps.orchestrator.getSnapshot().activeSource;
+    if (active && READONLY_DRIVE_SOURCES.has(active) && this.dropHasFiles(e) && this.deps.onReadonlyDropRejected) {
+      e.preventDefault();
+      this.deps.onReadonlyDropRejected(active);
+      this.isDragging = false;
+      this.recompute();
+      return;
+    }
+    if (this.disabled) return;
+    e.preventDefault();
+    if (!e.dataTransfer) {
+      this.isDragging = false;
+      this.recompute();
+      return;
+    }
+    const { files: dropped, skippedDirectory } = await collectDroppedFiles(
+      e.dataTransfer,
+      this.deps.props().folderUploadAllowDrop
+    );
+    if (skippedDirectory) {
+      this.deps.options().onWarn?.(
+        dropped.length > 0 ? "Dropped folders were ignored because folderUpload.allowDrop is disabled." : "Folder drop is disabled. Enable folderUpload.allowDrop to accept dropped folders."
+      );
+      this.deps.core.emit("folder-drop-blocked", {
+        acceptedFiles: dropped.length
+      });
+      if (dropped.length === 0) {
+        this.isDragging = false;
+        this.recompute();
+        return;
+      }
+    }
+    this.deps.options().onFilesDrop?.(dropped);
+    void this.deps.setFiles(dropped);
+    this.deps.core.emit("drop", { files: dropped });
+    this.isDragging = false;
+    this.recompute();
+  }
+  handlePaste(e) {
+    if (!this.deps.options().enablePaste || this.deps.props().isProcessing)
+      return;
+    const items = e.clipboardData?.items;
+    if (!items) return;
+    const files = [];
+    for (const item of Array.from(items)) {
+      if (item.kind === "file") {
+        const f = item.getAsFile();
+        if (f) {
+          const name = f.name === "image.png" || !f.name ? `pasted-${Date.now()}.${f.type.split("/")[1] || "png"}` : f.name;
+          files.push(new File([f], name, { type: f.type }));
+        }
+      }
+    }
+    if (files.length) {
+      e.preventDefault();
+      void this.deps.setFiles(files);
+      this.deps.core.emit("paste", { files });
+    }
+  }
+  destroy() {
+    this.unsubOrchestrator?.();
+    this.unsubOrchestrator = null;
+    this.listeners.clear();
+    this.isDragging = false;
+  }
+};
+
+// src/controllers/server-mode-drive-controller.ts
+var ServerModeDriveController = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.snapshot = {
+      state: { status: "idle" },
+      folderId: void 0,
+      search: ""
+    };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.abort = null;
+    this.authListener = null;
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    this.getSnapshot = () => this.snapshot;
+    this.list = this.list.bind(this);
+    this.refresh = this.refresh.bind(this);
+    this.transfer = this.transfer.bind(this);
+    this.startAuth = this.startAuth.bind(this);
+  }
+  setState(p) {
+    this.snapshot = { ...this.snapshot, ...p };
+    this.listeners.forEach((fn) => {
+      fn();
+    });
+  }
+  /** Initial list. Call on mount. */
+  init() {
+    void this.list();
+  }
+  async list(opts) {
+    const serverUrl = this.deps.serverUrl();
+    if (!serverUrl) {
+      this.setState({
+        state: {
+          status: "error",
+          message: "Server Mode requires `serverUrl` prop"
+        }
+      });
+      return;
+    }
+    this.abort?.abort();
+    const ac = new AbortController();
+    this.abort = ac;
+    this.setState({ state: { status: "loading" } });
+    const params = new URLSearchParams();
+    const nextFolder = opts?.folderId ?? this.snapshot.folderId;
+    const nextSearch = opts?.search ?? this.snapshot.search;
+    if (nextFolder) params.set("folderId", nextFolder);
+    if (nextSearch) params.set("search", nextSearch);
+    try {
+      const res = await fetch(
+        `${serverUrl}/files/${this.deps.provider}${params.toString() ? `?${params}` : ""}`,
+        { credentials: "include", signal: ac.signal }
+      );
+      if (res.status === 401) {
+        const body = await res.clone().json().catch(() => ({}));
+        if (body.reauth) {
+          this.setState({ state: { status: "reauth" } });
+        } else {
+          this.setState({
+            state: {
+              status: "error",
+              message: body.error ?? "Unauthorized",
+              code: "UNAUTHENTICATED"
+            }
+          });
+        }
+        return;
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new UpupNetworkError(text || `${res.status}`, res.status);
+      }
+      const data = await res.json();
+      this.setState({ state: { status: "ready", files: data.files } });
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      this.setState({
+        state: { status: "error", message: err.message }
+      });
+    } finally {
+      if (this.abort === ac) this.abort = null;
+    }
+  }
+  refresh(opts) {
+    return this.list(opts);
+  }
+  async transfer(file) {
+    const serverUrl = this.deps.serverUrl();
+    if (!serverUrl)
+      return {
+        status: "error",
+        message: "Server Mode requires `serverUrl` prop"
+      };
+    try {
+      const res = await fetch(
+        `${serverUrl}/files/${this.deps.provider}/transfer`,
+        {
+          method: "POST",
+          credentials: "include",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            fileId: file.id,
+            fileName: file.name,
+            size: file.size,
+            mimeType: file.mimeType
+          })
+        }
+      );
+      if (res.status === 401) {
+        const body = await res.clone().json().catch(() => ({}));
+        if (body.reauth) return { status: "reauth" };
+        return {
+          status: "error",
+          message: body.error ?? "Unauthorized",
+          code: "UNAUTHENTICATED"
+        };
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { status: "error", message: text || `${res.status}` };
+      }
+      const result = await res.json();
+      return { status: "ok", result };
+    } catch (err) {
+      return { status: "error", message: err.message };
+    }
+  }
+  startAuth() {
+    const serverUrl = this.deps.serverUrl();
+    if (!serverUrl) return;
+    if (this.authListener) {
+      window.removeEventListener("message", this.authListener);
+      this.authListener = null;
+    }
+    const popup = window.open(
+      `${serverUrl}/auth/${this.deps.provider}`,
+      "upup-oauth",
+      "width=600,height=700"
+    );
+    if (!popup) {
+      this.setState({
+        state: {
+          status: "error",
+          message: "Popup blocked. Allow popups and try again."
+        }
+      });
+      return;
+    }
+    const onMessage = (ev) => {
+      const data = ev.data;
+      if (data?.type === "upup:oauth-success" && data.provider === this.deps.provider) {
+        window.removeEventListener("message", onMessage);
+        if (this.authListener === onMessage) this.authListener = null;
+        void this.list();
+      }
+    };
+    this.authListener = onMessage;
+    window.addEventListener("message", onMessage);
+  }
+  setFolderId(id) {
+    this.setState({ folderId: id });
+  }
+  setSearch(s) {
+    this.setState({ search: s });
+  }
+  /** Force the reauth view (used by batch consumers on a transfer 401). */
+  requestReauth() {
+    this.setState({ state: { status: "reauth" } });
+  }
+  /** Force the error view (used by batch consumers on a transfer failure). */
+  setError(message) {
+    this.setState({ state: { status: "error", message } });
+  }
+  destroy() {
+    this.abort?.abort();
+    this.abort = null;
+    if (this.authListener) {
+      window.removeEventListener("message", this.authListener);
+      this.authListener = null;
+    }
+    this.listeners.clear();
+  }
+};
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/utils/source-metadata.ts
+var sourceNameKeys = {
+  ["local" /* LOCAL */]: "myDevice",
+  ["googleDrive" /* GOOGLE_DRIVE */]: "googleDrive",
+  ["oneDrive" /* ONE_DRIVE */]: "oneDrive",
+  ["dropbox" /* DROPBOX */]: "dropbox",
+  ["box" /* BOX */]: "box",
+  ["url" /* URL */]: "link",
+  ["camera" /* CAMERA */]: "camera",
+  ["microphone" /* MICROPHONE */]: "audio",
+  ["screen" /* SCREEN */]: "screenCapture"
+};
+
+// src/file-utils.ts
+var bytesToSize = (bytes) => {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  if (bytes === 0) return "0 Byte";
+  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString());
+  return `${Math.round(bytes / Math.pow(1024, i))} ${sizes[i] ?? ""}`;
+};
+var sizeToBytes = (size, unit = "B") => {
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = sizes.indexOf(unit);
+  return size * Math.pow(1024, i);
+};
+function checkFileSize(file, sizeLimit, mode = "max") {
+  if (!sizeLimit) return true;
+  const limitBytes = sizeToBytes(sizeLimit.size, sizeLimit.unit);
+  if (mode === "min") return file.size >= limitBytes;
+  return file.size <= limitBytes;
+}
+var PREVIEW_MAX_TEXT_SIZE = 512 * 1024;
+var PREVIEW_TEXT_TRUNCATE_LENGTH = 1e5;
+function fileGetIsText(fileType, fileName) {
+  if (!fileType) return false;
+  if (fileType.startsWith("text/")) return true;
+  const lower = (fileName ?? "").toLowerCase();
+  return lower.endsWith(".txt") || lower.endsWith(".md") || lower.endsWith(".json") || lower.endsWith(".csv") || lower.endsWith(".log") || lower.endsWith(".js") || lower.endsWith(".ts") || lower.endsWith(".css") || lower.endsWith(".html");
+}
+function fileCanPreviewText(fileType, fileName, fileSize) {
+  if (!fileGetIsText(fileType, fileName)) return false;
+  if (fileSize === void 0) return true;
+  return fileSize <= PREVIEW_MAX_TEXT_SIZE;
+}
+function fileGetIsImage(fileType) {
+  return typeof fileType === "string" && fileType.startsWith("image/");
+}
+function fileGetIsPdf(fileType, fileName) {
+  if (fileType === "application/pdf") return true;
+  return (fileName ?? "").toLowerCase().endsWith(".pdf");
+}
+function fileGetExtension(fileType, fileName) {
+  const safeName = fileName ?? "";
+  if (!fileType) {
+    return safeName.split(".").pop()?.toLowerCase() || "";
+  }
+  const typeSplit = fileType.split("/");
+  const nameSplit = safeName.split(".");
+  const lastNamePart = nameSplit[nameSplit.length - 1]?.toLowerCase() || "";
+  if (!typeSplit[1]) {
+    return lastNamePart;
+  }
+  if (typeSplit[1].includes(".")) {
+    return lastNamePart;
+  }
+  return typeSplit[1].toLowerCase();
+}
+function fileIs3D(ext) {
+  const threeDExtensions = [
+    "3ds",
+    "3dm",
+    "blend",
+    "dxf",
+    "dwg",
+    "c4d",
+    "ma",
+    "mb",
+    "ply",
+    "stl",
+    "fbx",
+    "obj",
+    "dae",
+    "gltf",
+    "glb",
+    "m3"
+  ];
+  return threeDExtensions.includes(ext.toLowerCase());
+}
+function searchDriveFiles(files, searchTerm, options = {}) {
+  const {
+    caseSensitive = false,
+    exactMatch = false,
+    maxResults = 100
+  } = options;
+  if (!searchTerm) return files.slice(0, maxResults);
+  let searchString = searchTerm;
+  let fileNames;
+  if (!caseSensitive) {
+    searchString = searchTerm.toLowerCase();
+    fileNames = files.map((file) => file.name.toLowerCase());
+  } else {
+    fileNames = files.map((file) => file.name);
+  }
+  return files.filter((_file, index) => {
+    const name = fileNames[index];
+    if (name === void 0) return false;
+    return exactMatch ? name === searchString : name.includes(searchString);
+  }).slice(0, maxResults);
+}
+
+// src/utils/fetch-helpers.ts
+var MIME_EXTENSION_MAP = {
+  "application/json": "json",
+  "application/pdf": "pdf",
+  "application/zip": "zip",
+  "image/jpeg": "jpg",
+  "text/csv": "csv",
+  "text/html": "html",
+  "text/markdown": "md",
+  "text/plain": "txt"
+};
+function sanitizeFileName(value) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    decoded = value;
+  }
+  decoded = decoded.trim();
+  const lastSegment = decoded.split(/[\\/]/).filter(Boolean).pop() ?? "";
+  return lastSegment.replace(/[\x00-\x1f\x7f<>:"/\\|?*]+/g, "_");
+}
+function extensionFromMime(type) {
+  const mime = type.split(";")[0]?.trim().toLowerCase();
+  if (!mime) return "bin";
+  if (MIME_EXTENSION_MAP[mime]) return MIME_EXTENSION_MAP[mime];
+  const subtype = mime.split("/")[1];
+  if (!subtype) return "bin";
+  return subtype.split("+").pop() || subtype;
+}
+function fileNameFromContentDisposition(header) {
+  if (!header) return void 0;
+  const encodedMatch = header.match(/filename\*=([^;]+)/i);
+  if (encodedMatch?.[1]) {
+    const value2 = encodedMatch[1].trim().replace(/^UTF-8''/i, "");
+    const sanitized2 = sanitizeFileName(value2);
+    if (sanitized2) return sanitized2;
+  }
+  const quotedMatch = header.match(/filename=(?:"([^"]+)"|([^;]+))/i);
+  const value = quotedMatch?.[1] ?? quotedMatch?.[2];
+  if (!value) return void 0;
+  const sanitized = sanitizeFileName(value);
+  return sanitized || void 0;
+}
+function deriveFetchedFileName(url, response, blob) {
+  const dispositionName = fileNameFromContentDisposition(
+    response.headers.get("content-disposition")
+  );
+  if (dispositionName) return dispositionName;
+  try {
+    const parsedUrl = new URL(url, globalThis.location.href);
+    if (["http:", "https:", "file:"].includes(parsedUrl.protocol)) {
+      const urlName = sanitizeFileName(parsedUrl.pathname);
+      if (urlName) return urlName;
+    }
+  } catch {
+  }
+  return `${crypto.randomUUID()}.${extensionFromMime(blob.type || response.headers.get("content-type") || "")}`;
+}
+
+export { DEFAULT_MAX_FILE_SIZE, DEFAULT_SOURCES, DragDropController, DriveBrowserController, MIME_EXTENSION_MAP, PREVIEW_MAX_TEXT_SIZE, PREVIEW_TEXT_TRUNCATE_LENGTH, SSEProcessor, ServerModeDriveController, UploaderOrchestrator, b64EncodeUnicode, bindDriveEvents, blobToUploadFile, bytesToSize, checkFileSize, cn, collectDroppedFiles, createChildController, createMotionGate, createTransientUiState, createUploaderController, dataURLtoBlob, deriveFetchedFileName, extensionFromMime, fileAppendParams, fileCanPreviewText, fileGetExtension, fileGetIsImage, fileGetIsPdf, fileGetIsText, fileIs3D, fileNameFromContentDisposition, getDir, loadGoogleIdentityServices, normalizeSource, normalizeUploaderOptions, revokeAndReplace, revokeFileUrl, sanitizeFileName, searchDriveFiles, sizeToBytes, sourceNameKeys };