img-upload-kit 1.1.1 → 2.0.0

package/dist/chunk-U2TWTEBY.cjs

@@ -0,0 +1,2370 @@
+'use client';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkKJVYWKIGcjs = require('./chunk-KJVYWKIG.cjs');
+
+
+
+
+
+
+var _chunkNEDBIIE3cjs = require('./chunk-NEDBIIE3.cjs');
+
+// src/react/hooks/useClipboardPaste.ts
+var _react = require('react');
+function isEditableTextTarget(target) {
+  if (!target || typeof HTMLElement === "undefined" || !(target instanceof HTMLElement)) {
+    return false;
+  }
+  const tag = target.tagName;
+  if (tag === "TEXTAREA" || target.isContentEditable) return true;
+  if (tag === "INPUT") {
+    const type = _optionalChain([target, 'access', _ => _.type, 'optionalAccess', _2 => _2.toLowerCase, 'call', _3 => _3()]);
+    return type !== "file" && type !== "button" && type !== "checkbox" && type !== "radio";
+  }
+  return false;
+}
+function extractClipboardImageFiles(clipboardData, multiple) {
+  if (!clipboardData) return [];
+  const extracted = [];
+  if (clipboardData.files && clipboardData.files.length > 0) {
+    for (let i = 0; i < clipboardData.files.length; i++) {
+      const file = clipboardData.files[i];
+      if (file && file.type.startsWith("image/")) {
+        extracted.push(file);
+      }
+    }
+  }
+  if (extracted.length === 0 && clipboardData.items && clipboardData.items.length > 0) {
+    for (let i = 0; i < clipboardData.items.length; i++) {
+      const item = clipboardData.items[i];
+      if (item && item.kind === "file" && item.type.startsWith("image/")) {
+        const file = item.getAsFile();
+        if (file) extracted.push(file);
+      }
+    }
+  }
+  if (extracted.length === 0) return [];
+  return multiple ? extracted : [extracted[0]];
+}
+function toFileListLike(files) {
+  if (typeof DataTransfer !== "undefined") {
+    try {
+      const dt = new DataTransfer();
+      for (const file of files) dt.items.add(file);
+      if (dt.files.length === files.length) return dt.files;
+    } catch (e2) {
+    }
+  }
+  const arrayWithItem = Object.assign([...files], {
+    item: (index) => _nullishCoalesce(files[index], () => ( null))
+  });
+  return arrayWithItem;
+}
+function useClipboardPaste({
+  enabled = true,
+  pasteTarget = "dropzone",
+  disabled = false,
+  multiple = false,
+  onPasteFiles
+}) {
+  const onPasteFilesRef = _react.useRef.call(void 0, onPasteFiles);
+  onPasteFilesRef.current = onPasteFiles;
+  const handledNativeEventsRef = _react.useRef.call(void 0, /* @__PURE__ */ new WeakSet());
+  const processPaste = _react.useCallback.call(void 0, 
+    (clipboardData, target, nativeEvent, preventDefault) => {
+      if (!enabled || disabled) return;
+      if (handledNativeEventsRef.current.has(nativeEvent)) return;
+      if (isEditableTextTarget(target)) return;
+      const files = extractClipboardImageFiles(clipboardData, multiple);
+      if (files.length === 0) return;
+      handledNativeEventsRef.current.add(nativeEvent);
+      preventDefault();
+      onPasteFilesRef.current(toFileListLike(files));
+    },
+    [enabled, disabled, multiple]
+  );
+  const onPaste = _react.useCallback.call(void 0, 
+    (event) => {
+      processPaste(
+        event.clipboardData,
+        event.target,
+        event.nativeEvent,
+        () => event.preventDefault()
+      );
+    },
+    [processPaste]
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || disabled || pasteTarget !== "document" || typeof document === "undefined") {
+      return;
+    }
+    const handleDocumentPaste = (event) => {
+      processPaste(
+        event.clipboardData,
+        event.target,
+        event,
+        () => event.preventDefault()
+      );
+    };
+    document.addEventListener("paste", handleDocumentPaste);
+    return () => document.removeEventListener("paste", handleDocumentPaste);
+  }, [enabled, disabled, pasteTarget, processPaste]);
+  return { onPaste };
+}
+
+// src/react/hooks/useDragAndDrop.ts
+
+function useDragAndDrop({ disabled, onDrop }) {
+  const [isDragging, setIsDragging] = _react.useState.call(void 0, false);
+  const dragDepthRef = _react.useRef.call(void 0, 0);
+  _react.useEffect.call(void 0, () => {
+    if (disabled) {
+      dragDepthRef.current = 0;
+      setIsDragging(false);
+    }
+  }, [disabled]);
+  const handleDragEnter = _react.useCallback.call(void 0, 
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (disabled) return;
+      dragDepthRef.current += 1;
+      setIsDragging(true);
+    },
+    [disabled]
+  );
+  const handleDragLeave = _react.useCallback.call(void 0, (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    dragDepthRef.current = Math.max(0, dragDepthRef.current - 1);
+    if (dragDepthRef.current === 0) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleDragOver = _react.useCallback.call(void 0, (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = _react.useCallback.call(void 0, 
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      dragDepthRef.current = 0;
+      setIsDragging(false);
+      if (disabled) return;
+      const files = _optionalChain([e, 'access', _4 => _4.dataTransfer, 'optionalAccess', _5 => _5.files]);
+      if (files && files.length > 0) {
+        onDrop(files);
+      }
+    },
+    [disabled, onDrop]
+  );
+  return {
+    isDragging,
+    dragHandlers: {
+      onDragEnter: handleDragEnter,
+      onDragLeave: handleDragLeave,
+      onDragOver: handleDragOver,
+      onDrop: handleDrop
+    }
+  };
+}
+
+// src/react/hooks/useSingleImageState.ts
+
+
+// src/react/context.tsx
+
+var _jsxruntime = require('react/jsx-runtime');
+var DEFAULT_CONTEXT = {
+  endpoint: "/api/upload",
+  locale: void 0,
+  storageKeyPrefix: "iuk",
+  requireAltText: true,
+  unstyled: false
+};
+var ImageUploadContext = _react.createContext.call(void 0, DEFAULT_CONTEXT);
+function ImageUploadProvider({
+  children,
+  endpoint = "/api/upload",
+  uploader,
+  headers,
+  withCredentials,
+  locale,
+  translations,
+  renderImage,
+  storageKeyPrefix = "iuk",
+  requireAltText = true,
+  unstyled = false,
+  singleClassNames,
+  singleStyles,
+  multiClassNames,
+  multiStyles
+}) {
+  const value = _react.useMemo.call(void 0, 
+    () => ({
+      endpoint,
+      uploader,
+      headers,
+      withCredentials,
+      locale,
+      translations,
+      renderImage,
+      storageKeyPrefix,
+      requireAltText,
+      unstyled,
+      singleClassNames,
+      singleStyles,
+      multiClassNames,
+      multiStyles
+    }),
+    [
+      endpoint,
+      uploader,
+      headers,
+      withCredentials,
+      locale,
+      translations,
+      renderImage,
+      storageKeyPrefix,
+      requireAltText,
+      unstyled,
+      singleClassNames,
+      singleStyles,
+      multiClassNames,
+      multiStyles
+    ]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ImageUploadContext.Provider, { value, children });
+}
+function useImageUploadContext() {
+  return _react.useContext.call(void 0, ImageUploadContext);
+}
+
+// src/react/i18n/ar.ts
+var arTranslations = {
+  uploadWindow: "\u0646\u0627\u0641\u0630\u0629 \u0627\u0644\u0631\u0641\u0639",
+  tapToResume: "\u0627\u0636\u063A\u0637 \u0644\u0644\u0627\u0633\u062A\u0626\u0646\u0627\u0641",
+  restoreUploadWindow: "\u0627\u0633\u062A\u0639\u0627\u062F\u0629 \u0646\u0627\u0641\u0630\u0629 \u0627\u0644\u0631\u0641\u0639",
+  minimize: "\u062A\u0635\u063A\u064A\u0631",
+  minimizeUploader: "\u062A\u0635\u063A\u064A\u0631 \u0646\u0627\u0641\u0630\u0629 \u0627\u0644\u0631\u0641\u0639",
+  close: "\u0625\u063A\u0644\u0627\u0642",
+  editPrefix: "\u062A\u0639\u062F\u064A\u0644 - {title}",
+  uploadImage: "\u0631\u0641\u0639 \u0635\u0648\u0631\u0629",
+  uploadImages: "\u0631\u0641\u0639 \u0635\u0648\u0631",
+  noValidImageFiles: "\u0644\u0645 \u064A\u062A\u0645 \u0627\u0644\u0639\u062B\u0648\u0631 \u0639\u0644\u0649 \u0645\u0644\u0641\u0627\u062A \u0635\u0648\u0631 \u0635\u0627\u0644\u062D\u0629. \u064A\u0631\u062C\u0649 \u0627\u062E\u062A\u064A\u0627\u0631 \u0635\u0648\u0631 (JPEG, PNG, WebP, AVIF, SVG).",
+  selectedImagesSkipped: "\u062A\u0645 \u0627\u062E\u062A\u064A\u0627\u0631 {imageCount} \u0635\u0648\u0631\u0629. \u0648\u062A\u0645 \u062A\u062C\u0627\u0647\u0644 {skippedCount} \u0645\u0644\u0641 \u063A\u064A\u0631 \u0635\u0648\u0631\u064A.",
+  queued: "\u0641\u064A \u0627\u0644\u0627\u0646\u062A\u0638\u0627\u0631...",
+  retrying: "\u062C\u0627\u0631\u064A \u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0645\u062D\u0627\u0648\u0644\u0629...",
+  preparingUpload: "\u062C\u0627\u0631\u064A \u062A\u062C\u0647\u064A\u0632 \u0627\u0644\u0631\u0641\u0639...",
+  uploadFailed: "\u0641\u0634\u0644 \u0627\u0644\u0631\u0641\u0639",
+  failedCreatePreview: "\u062A\u0639\u0630\u0631 \u0625\u0646\u0634\u0627\u0621 \u0627\u0644\u0645\u0639\u0627\u064A\u0646\u0629",
+  failedCreatePreviewFor: "\u062A\u0639\u0630\u0631 \u0625\u0646\u0634\u0627\u0621 \u0645\u0639\u0627\u064A\u0646\u0629 \u0644\u0644\u0645\u0644\u0641: {file}",
+  selectAll: "\u062A\u062D\u062F\u064A\u062F \u0627\u0644\u0643\u0644",
+  deselectAll: "\u0625\u0644\u063A\u0627\u0621 \u062A\u062D\u062F\u064A\u062F \u0627\u0644\u0643\u0644",
+  removeSelected: "\u062D\u0630\u0641 \u0627\u0644\u0645\u062D\u062F\u062F",
+  uploading: "\u062C\u0627\u0631\u064D \u0627\u0644\u0631\u0641\u0639",
+  uploadingCount: "\u062C\u0627\u0631\u064D \u0631\u0641\u0639 {count} \u0635\u0648\u0631\u0629",
+  someUploadsFailed: "\u0641\u0634\u0644 \u0631\u0641\u0639 \u0628\u0639\u0636 \u0627\u0644\u0645\u0644\u0641\u0627\u062A.",
+  retryFailedUploads: "\u0625\u0639\u0627\u062F\u0629 \u0631\u0641\u0639 \u0627\u0644\u0645\u0644\u0641\u0627\u062A \u0627\u0644\u0641\u0627\u0634\u0644\u0629",
+  needsAltBeforeSave: "\u064A\u0648\u062C\u062F {count} \u0635\u0648\u0631\u0629 \u0628\u062F\u0648\u0646 \u0646\u0635 \u0628\u062F\u064A\u0644. \u0623\u0636\u0641 \u0648\u0635\u0641\u064B\u0627 \u0642\u0628\u0644 \u0627\u0644\u062D\u0641\u0638 \u0645\u0646 \u0632\u0631 \u0627\u0644\u0648\u0635\u0641 \u0639\u0644\u0649 \u0643\u0644 \u0635\u0648\u0631\u0629.",
+  networkError: "\u062E\u0637\u0623 \u0641\u064A \u0627\u0644\u0634\u0628\u0643\u0629 \u0623\u062B\u0646\u0627\u0621 \u0631\u0641\u0639 \u0627\u0644\u0635\u0648\u0631\u0629",
+  invalidUploadResponse: "\u0627\u0633\u062A\u062C\u0627\u0628\u0629 \u063A\u064A\u0631 \u0635\u0627\u0644\u062D\u0629 \u0645\u0646 \u062E\u0627\u062F\u0645 \u0627\u0644\u0631\u0641\u0639",
+  uploadAborted: "\u062A\u0645 \u0625\u0644\u063A\u0627\u0621 \u0627\u0644\u0631\u0641\u0639",
+  uploadStartedLive: "\u0628\u062F\u0623 \u0627\u0644\u0631\u0641\u0639",
+  uploadProgressLive: "\u0627\u0643\u062A\u0645\u0644 \u0627\u0644\u0631\u0641\u0639 \u0628\u0646\u0633\u0628\u0629 {progress}%",
+  uploadCompleteLive: "\u0627\u0643\u062A\u0645\u0644 \u0627\u0644\u0631\u0641\u0639",
+  qualityTitle: "\u062C\u0648\u062F\u0629 \u0627\u0644\u0636\u063A\u0637",
+  qualityLevelAria: "\u0645\u0633\u062A\u0648\u0649 \u0627\u0644\u062C\u0648\u062F\u0629",
+  qualitySaved: "\u062A\u0648\u0641\u064A\u0631",
+  qualityRecommended: "\u2B50 \u0645\u0648\u0635\u0649 \u0628\u0647",
+  selectFilesAria: "\u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u0644\u0641\u0627\u062A",
+  selectMoreFilesAria: "\u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u0644\u0641\u0627\u062A \u0625\u0636\u0627\u0641\u064A\u0629",
+  selectFolderAria: "\u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u062C\u0644\u062F",
+  dropImagesHere: "\u0623\u0633\u0642\u0637 \u0627\u0644\u0635\u0648\u0631 \u0647\u0646\u0627",
+  releaseToUpload: "\u0627\u062A\u0631\u0643 \u0644\u0644\u0625\u0641\u0644\u0627\u062A \u0648\u0627\u0644\u0631\u0641\u0639",
+  dragDropOrChoose: "\u0627\u0633\u062D\u0628 \u0648\u0623\u0641\u0644\u062A \u0627\u0644\u0635\u0648\u0631 \u0647\u0646\u0627\u060C \u0623\u0648 \u0627\u062E\u062A\u0631 \u0637\u0631\u064A\u0642\u0629 \u0627\u0644\u0631\u0641\u0639 \u0645\u0646 \u0627\u0644\u0623\u0633\u0641\u0644",
+  selectFiles: "\u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u0644\u0641\u0627\u062A",
+  selectFolder: "\u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u062C\u0644\u062F",
+  supportsFormats: "\u0627\u0644\u0635\u064A\u063A \u0627\u0644\u0645\u062F\u0639\u0648\u0645\u0629: JPEG, PNG, WebP, AVIF, SVG",
+  maxPerFile: "\u0627\u0644\u062D\u062F \u0627\u0644\u0623\u0642\u0635\u0649 {size}MB \u0644\u0643\u0644 \u0645\u0644\u0641",
+  upToSizeMB: "\u062D\u062A\u0649 {size} \u0645\u064A\u062C\u0627\u0628\u0627\u064A\u062A",
+  dropHere: "\u0623\u0633\u0642\u0637 \u0647\u0646\u0627",
+  addMore: "\u0625\u0636\u0627\u0641\u0629 \u0627\u0644\u0645\u0632\u064A\u062F",
+  files: "\u0645\u0644\u0641\u0627\u062A",
+  folder: "\u0645\u062C\u0644\u062F",
+  withoutAltText: "{count} \u0628\u062F\u0648\u0646 \u0646\u0635 \u0628\u062F\u064A\u0644",
+  saveImages: "\u062D\u0641\u0638 \u0627\u0644\u0635\u0648\u0631",
+  addAltBeforeSaving: "\u064A\u0631\u062C\u0649 \u0625\u0636\u0627\u0641\u0629 \u0646\u0635 \u0628\u062F\u064A\u0644 \u0642\u0628\u0644 \u0627\u0644\u062D\u0641\u0638. \u0627\u0636\u063A\u0637 \u0632\u0631 \u0627\u0644\u0648\u0635\u0641 \u0639\u0644\u0649 \u0627\u0644\u0635\u0648\u0631\u0629.",
+  missingDescription: "\u0627\u0644\u0648\u0635\u0641 \u0645\u0641\u0642\u0648\u062F",
+  saveImage: "\u062D\u0641\u0638 \u0627\u0644\u0635\u0648\u0631\u0629",
+  downloadImage: "\u062A\u062D\u0645\u064A\u0644 \u0627\u0644\u0635\u0648\u0631\u0629",
+  dragDropOrClickToUpload: "\u0627\u0633\u062D\u0628 \u0648\u0623\u0641\u0644\u062A \u0623\u0648 \u0627\u0646\u0642\u0631 \u0644\u0644\u0631\u0641\u0639",
+  browseFiles: "\u062A\u0635\u0641\u062D \u0627\u0644\u0645\u0644\u0641\u0627\u062A",
+  image: "\u0635\u0648\u0631\u0629",
+  processing: "\u062C\u0627\u0631\u064D \u0627\u0644\u0645\u0639\u0627\u0644\u062C\u0629...",
+  uploadImageAria: "\u0631\u0641\u0639 \u0635\u0648\u0631\u0629",
+  fileInputAria: "\u062D\u0642\u0644 \u0627\u062E\u062A\u064A\u0627\u0631 \u0645\u0644\u0641",
+  uploadingAlt: "\u062C\u0627\u0631\u064D \u0627\u0644\u0631\u0641\u0639",
+  previewAlt: "\u0645\u0639\u0627\u064A\u0646\u0629",
+  addImageDescription: "\u0625\u0636\u0627\u0641\u0629 \u0648\u0635\u0641 \u0644\u0644\u0635\u0648\u0631\u0629",
+  describeImagePlaceholder: "\u0635\u0641 \u0647\u0630\u0647 \u0627\u0644\u0635\u0648\u0631\u0629 \u0644\u0625\u0645\u0643\u0627\u0646\u064A\u0629 \u0627\u0644\u0648\u0635\u0648\u0644...",
+  characters: "\u062D\u0631\u0641",
+  usedForA11ySeo: "\u064A\u064F\u0633\u062A\u062E\u062F\u0645 \u0644\u0625\u0645\u0643\u0627\u0646\u064A\u0629 \u0627\u0644\u0648\u0635\u0648\u0644 \u0648\u062A\u062D\u0633\u064A\u0646 \u0627\u0644\u0638\u0647\u0648\u0631 \u0641\u064A \u0627\u0644\u0628\u062D\u062B",
+  cancel: "\u0625\u0644\u063A\u0627\u0621",
+  saveDescription: "\u062D\u0641\u0638 \u0627\u0644\u0648\u0635\u0641",
+  selectImageAria: "\u062A\u062D\u062F\u064A\u062F \u0627\u0644\u0635\u0648\u0631\u0629",
+  editAltTextAria: "\u062A\u0639\u062F\u064A\u0644 \u0627\u0644\u0646\u0635 \u0627\u0644\u0628\u062F\u064A\u0644",
+  addAltTextAria: "\u0625\u0636\u0627\u0641\u0629 \u0646\u0635 \u0628\u062F\u064A\u0644",
+  addDescriptionForA11y: "\u0623\u0636\u0641 \u0648\u0635\u0641\u064B\u0627 \u0644\u0625\u0645\u0643\u0627\u0646\u064A\u0629 \u0627\u0644\u0648\u0635\u0648\u0644",
+  adjustBlurColorAria: "\u0636\u0628\u0637 \u0627\u0644\u062A\u0645\u0648\u064A\u0647 \u0648\u0627\u0644\u0644\u0648\u0646",
+  adjustBlurColorTitle: "\u0645\u0639\u0627\u064A\u0646\u0629 \u0628\u064A\u0627\u0646\u0627\u062A \u0627\u0644\u062A\u0645\u0648\u064A\u0647 \u0648\u0636\u0628\u0637 \u0627\u0644\u0623\u0644\u0648\u0627\u0646",
+  removeImageAria: "\u062D\u0630\u0641 \u0627\u0644\u0635\u0648\u0631\u0629",
+  pasteHint: "\u0623\u0648 \u0627\u0644\u0635\u0642 \u0645\u0646 \u0627\u0644\u062D\u0627\u0641\u0638\u0629",
+  cancelUpload: "\u0625\u0644\u063A\u0627\u0621 \u0627\u0644\u0631\u0641\u0639",
+  retryUpload: "\u0625\u0639\u0627\u062F\u0629 \u0631\u0641\u0639 \u0627\u0644\u0635\u0648\u0631\u0629",
+  minImagesError: "\u064A\u0631\u062C\u0649 \u0631\u0641\u0639 {min} \u0635\u0648\u0631\u0629 \u0639\u0644\u0649 \u0627\u0644\u0623\u0642\u0644.",
+  requiredFieldError: "\u0647\u0630\u0627 \u0627\u0644\u062D\u0642\u0644 \u0645\u0637\u0644\u0648\u0628.",
+  blurModal: {
+    title: "\u0645\u0639\u0627\u064A\u0646\u0629 \u0627\u0644\u062A\u0645\u0648\u064A\u0647 \u0648\u0627\u0644\u0644\u0648\u0646 \u0627\u0644\u0633\u0627\u0626\u062F",
+    closeModal: "\u0625\u063A\u0644\u0627\u0642 \u0627\u0644\u0645\u0639\u0627\u064A\u0646\u0629",
+    adjustColor: "\u0644\u0648\u0646 \u0627\u0644\u062E\u0644\u0641\u064A\u0629 \u0627\u0644\u0633\u0627\u0626\u062F",
+    clickToSample: "\u0627\u0646\u0642\u0631 \u0641\u064A \u0623\u064A \u0645\u0643\u0627\u0646 \u0639\u0644\u0649 \u0627\u0644\u0635\u0648\u0631\u0629 \u0644\u0627\u0644\u062A\u0642\u0627\u0637 \u0644\u0648\u0646 \u0627\u0644\u0628\u0643\u0633\u0644",
+    pickColorNote: "\u0627\u062E\u062A\u0631 \u0644\u0648\u0646\u064B\u0627 \u0645\u0646 \u0627\u0644\u0623\u062F\u0627\u0629\u060C \u0623\u0648 \u0623\u062F\u062E\u0644 \u0643\u0648\u062F HEX\u060C \u0623\u0648 \u0627\u0644\u062A\u0642\u0637 \u0645\u0628\u0627\u0634\u0631\u0629 \u0645\u0646 \u0627\u0644\u0635\u0648\u0631\u0629",
+    enterHexColor: "\u0623\u062F\u062E\u0644 \u0643\u0648\u062F \u0627\u0644\u0644\u0648\u0646 HEX",
+    hexPlaceholder: "F5F5F5",
+    enablePenMode: "\u0627\u0644\u062A\u0642\u0627\u0637 \u0644\u0648\u0646 \u0645\u0646 \u0627\u0644\u0635\u0648\u0631\u0629",
+    disablePenMode: "\u0625\u064A\u0642\u0627\u0641 \u0627\u0644\u0627\u0644\u062A\u0642\u0627\u0637",
+    penModeActive: "\u0648\u0636\u0639 \u0627\u0644\u0627\u0644\u062A\u0642\u0627\u0637 \u0645\u0641\u0639\u0644",
+    resetToDetected: "\u0627\u0633\u062A\u0639\u0627\u062F\u0629 \u0627\u0644\u0644\u0648\u0646 \u0627\u0644\u062A\u0644\u0642\u0627\u0626\u064A",
+    sampled: "\u062A\u0645 \u0627\u0644\u062A\u0642\u0627\u0637",
+    livePreview: "\u0645\u0639\u0627\u064A\u0646\u0629 \u062D\u064A\u0629 \u0644\u0644\u062A\u0645\u0648\u064A\u0647 \u0648\u0627\u0644\u0635\u0648\u0631\u0629",
+    showingOriginal: "\u0639\u0631\u0636 \u0627\u0644\u0635\u0648\u0631\u0629 \u0627\u0644\u0623\u0635\u0644\u064A\u0629 (\u0644\u0627 \u064A\u062A\u0648\u0641\u0631 \u062A\u0645\u0648\u064A\u0647 \u0628\u0639\u062F)",
+    saved: "\u0627\u0644\u062A\u0648\u0641\u064A\u0631 \u0641\u064A \u0627\u0644\u062D\u062C\u0645:",
+    accessibility: "\u0625\u0645\u0643\u0627\u0646\u064A\u0629 \u0627\u0644\u0648\u0635\u0648\u0644 \u0648\u0645\u062D\u0631\u0643\u0627\u062A \u0627\u0644\u0628\u062D\u062B",
+    altText: "\u0627\u0644\u0646\u0635 \u0627\u0644\u0628\u062F\u064A\u0644 \u0644\u0644\u0635\u0648\u0631\u0629 (Alt Text)",
+    altTextPlaceholder: "\u0635\u0641 \u0645\u062D\u062A\u0648\u0649 \u0627\u0644\u0635\u0648\u0631\u0629 \u0644\u0642\u0627\u0631\u0626\u0627\u062A \u0627\u0644\u0634\u0627\u0634\u0629 \u0648\u0645\u062D\u0631\u0643\u0627\u062A \u0627\u0644\u0628\u062D\u062B...",
+    saveAndClose: "\u062D\u0641\u0638 \u0648\u0625\u063A\u0644\u0627\u0642"
+  }
+};
+
+// src/react/i18n/en.ts
+var enTranslations = {
+  uploadWindow: "Upload window",
+  tapToResume: "Tap to resume",
+  restoreUploadWindow: "Restore upload window",
+  minimize: "Minimize",
+  minimizeUploader: "Minimize uploader",
+  close: "Close",
+  editPrefix: "Edit - {title}",
+  uploadImage: "Upload Image",
+  uploadImages: "Upload Images",
+  noValidImageFiles: "No valid image files found. Please select image files (JPEG, PNG, WebP, AVIF, SVG).",
+  selectedImagesSkipped: "{imageCount} image{imageSuffix} selected. {skippedCount} non-image file{skippedSuffix} skipped.",
+  queued: "Queued...",
+  retrying: "Retrying...",
+  preparingUpload: "Preparing upload...",
+  uploadFailed: "Upload failed",
+  failedCreatePreview: "Failed to create preview",
+  failedCreatePreviewFor: "Failed to create preview for {file}",
+  selectAll: "Select All",
+  deselectAll: "Deselect All",
+  removeSelected: "Remove Selected",
+  uploading: "Uploading",
+  uploadingCount: "Uploading {count} image{suffix}",
+  someUploadsFailed: "Some uploads failed.",
+  retryFailedUploads: "Retry Failed Uploads",
+  needsAltBeforeSave: "{count} image{suffix} need{verbSuffix} alt text before saving. Click the description button on each image.",
+  networkError: "Network error during image upload",
+  invalidUploadResponse: "Invalid JSON response from upload endpoint",
+  uploadAborted: "Upload cancelled",
+  uploadStartedLive: "Upload started",
+  uploadProgressLive: "Upload {progress}% complete",
+  uploadCompleteLive: "Upload complete",
+  qualityTitle: "Compression Quality",
+  qualityLevelAria: "Quality level",
+  qualitySaved: "saved",
+  qualityRecommended: "\u2B50 Recommended",
+  selectFilesAria: "Select files",
+  selectMoreFilesAria: "Select more files",
+  selectFolderAria: "Select folder",
+  dropImagesHere: "Drop images here",
+  releaseToUpload: "Release to upload",
+  dragDropOrChoose: "Drag and drop images here, or choose an option below",
+  selectFiles: "Select Files",
+  selectFolder: "Select Folder",
+  supportsFormats: "Supports: JPEG, PNG, WebP, AVIF, SVG",
+  maxPerFile: "Max {size}MB per file",
+  upToSizeMB: "Up to {size} MB",
+  dropHere: "Drop here",
+  addMore: "Add More",
+  files: "Files",
+  folder: "Folder",
+  withoutAltText: "{count} without alt text",
+  saveImages: "Save Images",
+  addAltBeforeSaving: "Please add alt text before saving. Click the description button on the image.",
+  missingDescription: "Missing description",
+  saveImage: "Save Image",
+  downloadImage: "Download Image",
+  dragDropOrClickToUpload: "Drag & drop or click to upload",
+  browseFiles: "Browse Files",
+  image: "Image",
+  processing: "Processing...",
+  uploadImageAria: "Upload image",
+  fileInputAria: "File input",
+  uploadingAlt: "Uploading",
+  previewAlt: "Preview",
+  addImageDescription: "Add Image Description",
+  describeImagePlaceholder: "Describe this image for accessibility...",
+  characters: "characters",
+  usedForA11ySeo: "Used for accessibility & SEO",
+  cancel: "Cancel",
+  saveDescription: "Save Description",
+  selectImageAria: "Select image",
+  editAltTextAria: "Edit alt text",
+  addAltTextAria: "Add alt text",
+  addDescriptionForA11y: "Add description for accessibility",
+  adjustBlurColorAria: "Adjust blur and color",
+  adjustBlurColorTitle: "Visualize blur data and adjust colors",
+  removeImageAria: "Remove image",
+  pasteHint: "or paste from clipboard",
+  cancelUpload: "Cancel upload",
+  retryUpload: "Retry upload",
+  minImagesError: "Please upload at least {min} image{suffix}.",
+  requiredFieldError: "This field is required.",
+  blurModal: {
+    title: "Blur & Dominant Color Inspector",
+    closeModal: "Close inspector",
+    adjustColor: "Dominant Backdrop Color",
+    clickToSample: "Click anywhere on the image preview to sample a pixel color",
+    pickColorNote: "Use the picker, enter a HEX code, or sample directly from the image",
+    enterHexColor: "Enter HEX color",
+    hexPlaceholder: "F5F5F5",
+    enablePenMode: "Eyedropper Sample",
+    disablePenMode: "Exit Eyedropper",
+    penModeActive: "Sampling Active",
+    resetToDetected: "Reset to Detected",
+    sampled: "Sampled",
+    livePreview: "Live Placeholder & Image Preview",
+    showingOriginal: "Showing original image (blur placeholder not generated yet)",
+    saved: "Size Saved:",
+    accessibility: "Accessibility & SEO",
+    altText: "Image Alt Text",
+    altTextPlaceholder: "Describe this image for screen readers and search engines...",
+    saveAndClose: "Save & Close"
+  }
+};
+
+// src/react/i18n.ts
+var DEFAULT_UPLOAD_TRANSLATIONS = enTranslations;
+var ARABIC_UPLOAD_TRANSLATIONS = arTranslations;
+function normalizeUploadLocale(locale) {
+  if (locale) {
+    return locale.toLowerCase().startsWith("ar") ? "ar" : "en";
+  }
+  if (typeof document !== "undefined") {
+    const docLang = _optionalChain([document, 'access', _6 => _6.documentElement, 'access', _7 => _7.getAttribute, 'call', _8 => _8("lang"), 'optionalAccess', _9 => _9.toLowerCase, 'call', _10 => _10()]) || "";
+    const docDir = _optionalChain([document, 'access', _11 => _11.documentElement, 'access', _12 => _12.getAttribute, 'call', _13 => _13("dir"), 'optionalAccess', _14 => _14.toLowerCase, 'call', _15 => _15()]) || "";
+    if (docLang.startsWith("ar") || docDir === "rtl") {
+      return "ar";
+    }
+  }
+  return "en";
+}
+function selectPluralCategory(locale, count) {
+  try {
+    return new Intl.PluralRules(locale).select(count);
+  } catch (e3) {
+    return count === 1 ? "one" : "other";
+  }
+}
+function formatUploadingCount(ui, count, locale, overrides) {
+  if (overrides && !overrides.uploadingCount && (overrides.uploading || overrides.uploadImage || overrides.uploadImages)) {
+    const isOne = selectPluralCategory(locale, count) === "one";
+    return `${ui.uploading} ${count} ${isOne ? ui.uploadImage : ui.uploadImages}`;
+  }
+  const suffix = selectPluralCategory(locale, count) === "one" ? "" : "s";
+  return ui.uploadingCount.replace("{count}", String(count)).replace("{suffix}", suffix);
+}
+function formatNeedsAltMessage(ui, count, locale) {
+  const isOne = selectPluralCategory(locale, count) === "one";
+  return ui.needsAltBeforeSave.replace("{count}", String(count)).replace("{suffix}", isOne ? "" : "s").replace("{verbSuffix}", isOne ? "s" : "");
+}
+function formatSkippedImagesMessage(ui, imageCount, skippedCount, locale) {
+  const imgSuffix = selectPluralCategory(locale, imageCount) === "one" ? "" : "s";
+  const skipSuffix = selectPluralCategory(locale, skippedCount) === "one" ? "" : "s";
+  return ui.selectedImagesSkipped.replace("{imageCount}", String(imageCount)).replace("{imageSuffix}", imgSuffix).replace("{skippedCount}", String(skippedCount)).replace("{skippedSuffix}", skipSuffix);
+}
+var uploadText = {
+  en: enTranslations,
+  ar: arTranslations
+};
+function resolveTranslations(locale, overrides) {
+  const base = uploadText[normalizeUploadLocale(locale)];
+  if (!overrides) return base;
+  return {
+    ...base,
+    ...overrides,
+    blurModal: {
+      ...base.blurModal,
+      ...overrides.blurModal || {}
+    }
+  };
+}
+
+// src/react/utils/sessionMetaCache.ts
+var SIGNED_URL_QUERY_RE = /[?&](?:X-Amz-Signature|X-Amz-Credential|X-Amz-Algorithm|X-Goog-Signature|Signature|AWSAccessKeyId|GoogleAccessId|token|sig|sv|se)=/i;
+function isSignedStorageUrl(url) {
+  return SIGNED_URL_QUERY_RE.test(url);
+}
+function appendCacheBuster(url, options = {}) {
+  if (!url || !options.enabled) return url;
+  if (/^(?:blob:|data:)/i.test(url) || isSignedStorageUrl(url)) return url;
+  if (/[?&](?:v|t)=/i.test(url)) return url;
+  const buster = _nullishCoalesce(options.token, () => ( Date.now()));
+  return `${url}${url.includes("?") ? "&" : "?"}t=${buster}`;
+}
+function readSessionJson(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(key);
+    return raw ? JSON.parse(raw) : null;
+  } catch (e4) {
+    return null;
+  }
+}
+function writeSessionJson(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(key, JSON.stringify(value));
+  } catch (e5) {
+  }
+}
+function createUploadSessionCache(storagePrefix = "iuk") {
+  const altKey = (id) => `${storagePrefix}:alt-meta:${id}`;
+  const blurKey = (id) => `${storagePrefix}:blur-meta:${id}`;
+  const writeAltMetaFor = (info, alt) => {
+    if (!_optionalChain([alt, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()])) return;
+    if (info.url) writeSessionJson(altKey(info.url), alt);
+    if (info.contentHash) writeSessionJson(altKey(info.contentHash), alt);
+  };
+  const readAltMetaFor = (info) => {
+    if (info.contentHash) {
+      const byHash = readSessionJson(altKey(info.contentHash));
+      if (byHash) return byHash;
+    }
+    if (info.url) {
+      const byUrl = readSessionJson(altKey(info.url));
+      if (byUrl) return byUrl;
+    }
+    return null;
+  };
+  const writeBlurMetaFor = (info, meta) => {
+    if (info.url) writeSessionJson(blurKey(info.url), meta);
+    if (info.contentHash) writeSessionJson(blurKey(info.contentHash), meta);
+  };
+  const readBlurMetaFor = (info) => {
+    if (info.contentHash) {
+      const byHash = readSessionJson(blurKey(info.contentHash));
+      if (_optionalChain([byHash, 'optionalAccess', _18 => _18.blurDataUrl]) || _optionalChain([byHash, 'optionalAccess', _19 => _19.blurColor])) return byHash;
+    }
+    if (info.url) {
+      const byUrl = readSessionJson(blurKey(info.url));
+      if (_optionalChain([byUrl, 'optionalAccess', _20 => _20.blurDataUrl]) || _optionalChain([byUrl, 'optionalAccess', _21 => _21.blurColor])) return byUrl;
+    }
+    return null;
+  };
+  return {
+    writeAltMetaFor,
+    readAltMetaFor,
+    writeBlurMetaFor,
+    readBlurMetaFor
+  };
+}
+var MIME_TO_EXT = {
+  "image/avif": "avif",
+  "image/webp": "webp",
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/svg+xml": "svg"
+};
+async function downloadImageWithFallback(url, format) {
+  if (!url || typeof window === "undefined") return;
+  try {
+    const fetchUrl = isSignedStorageUrl(url) ? url : appendCacheBuster(url, { enabled: true });
+    const res = await fetch(fetchUrl, { cache: "no-store" });
+    if (!res.ok) {
+      throw new Error(`Download failed with status ${res.status}`);
+    }
+    const blob = await res.blob();
+    const objectUrl = URL.createObjectURL(blob);
+    const ext = _nullishCoalesce(_nullishCoalesce(format, () => ( MIME_TO_EXT[blob.type])), () => ( "avif"));
+    const anchor = document.createElement("a");
+    anchor.href = objectUrl;
+    anchor.download = `image-${Date.now()}.${ext}`;
+    anchor.style.display = "none";
+    _optionalChain([document, 'access', _22 => _22.body, 'optionalAccess', _23 => _23.appendChild, 'call', _24 => _24(anchor)]);
+    anchor.click();
+    anchor.remove();
+    setTimeout(() => {
+      try {
+        URL.revokeObjectURL(objectUrl);
+      } catch (e6) {
+      }
+    }, 1e3);
+  } catch (e7) {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
+
+// src/react/hooks/singleStateHelpers.ts
+function resolveInitialQualityLevel(quality, preset) {
+  const q = _nullishCoalesce(quality, () => ( _optionalChain([preset, 'optionalAccess', _25 => _25.quality])));
+  if (!q) return _optionalChain([preset, 'optionalAccess', _26 => _26.recommendedQualityLevel]) || "high";
+  if (q <= 55) return "low";
+  if (q <= 78) return "medium";
+  return q <= 90 ? "high" : "maximum";
+}
+function resolveLiveAnnouncement(isUploading, progress, hasCompletedUpload, ui) {
+  if (isUploading) {
+    if (progress >= 75) return ui.uploadProgressLive.replace("{progress}", "75");
+    if (progress >= 50) return ui.uploadProgressLive.replace("{progress}", "50");
+    if (progress >= 25) return ui.uploadProgressLive.replace("{progress}", "25");
+    return ui.uploadStartedLive;
+  }
+  return hasCompletedUpload ? ui.uploadCompleteLive : "";
+}
+function stripUrlCacheQuery(u) {
+  return u && !/^(?:blob:|data:)/i.test(u) ? u.split("?")[0] : u;
+}
+function buildSingleImagePayload(params, overrides = {}) {
+  const {
+    uploadedData,
+    objVal,
+    value,
+    preview,
+    altText,
+    blurColor,
+    blurDataUrlState
+  } = params;
+  const base = uploadedData ? { ...uploadedData } : objVal ? { ...objVal } : typeof value === "string" && value.trim() ? {
+    url: value,
+    blurDataUrl: "",
+    blurColor: _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR,
+    altText: "",
+    width: 0,
+    height: 0,
+    format: "webp",
+    size: 0,
+    contentHash: "existing-image",
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  } : null;
+  if (!base) return null;
+  return {
+    ...base,
+    ...overrides,
+    url: (_nullishCoalesce(overrides.url, () => ( base.url))) || preview || "",
+    altText: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(overrides.altText, () => ( altText)), () => ( base.altText)), () => ( "")),
+    blurColor: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(overrides.blurColor, () => ( blurColor)), () => ( base.blurColor)), () => ( _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR)),
+    blurDataUrl: _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(overrides.blurDataUrl, () => ( base.blurDataUrl)), () => ( blurDataUrlState)), () => ( ""))
+  };
+}
+function serializeSingleFormValue(params) {
+  const {
+    formValue = "url",
+    currentImageData,
+    preview,
+    altText,
+    blurColor,
+    blurDataUrlState,
+    isUploading
+  } = params;
+  if (!preview || isUploading && !currentImageData) return "";
+  const nonBlobPreview = preview && !preview.startsWith("blob:") ? preview : null;
+  const resolvedUrl = _optionalChain([currentImageData, 'optionalAccess', _27 => _27.url]) || nonBlobPreview || "";
+  if (!resolvedUrl) return "";
+  if (formValue === "json") {
+    const payload = currentImageData ? {
+      ...currentImageData,
+      altText: altText || currentImageData.altText || "",
+      blurColor: blurColor || currentImageData.blurColor || _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR
+    } : {
+      url: resolvedUrl,
+      altText,
+      blurColor: blurColor || _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR,
+      blurDataUrl: blurDataUrlState
+    };
+    return JSON.stringify(payload);
+  }
+  return resolvedUrl;
+}
+
+// src/react/hooks/useFilePreview.ts
+
+function useFilePreview(options = {}) {
+  const objectUrlsRef = _react.useRef.call(void 0, /* @__PURE__ */ new Set());
+  const errorLabel = options.errorLabel || "Failed to read file";
+  const revokePreview = _react.useCallback.call(void 0, (url) => {
+    if (!url || !url.startsWith("blob:")) return;
+    objectUrlsRef.current.delete(url);
+    if (typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+      try {
+        URL.revokeObjectURL(url);
+      } catch (e8) {
+      }
+    }
+  }, []);
+  const revokeAllPreviews = _react.useCallback.call(void 0, () => {
+    if (typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+      for (const url of objectUrlsRef.current) {
+        try {
+          URL.revokeObjectURL(url);
+        } catch (e9) {
+        }
+      }
+    }
+    objectUrlsRef.current.clear();
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    return () => {
+      revokeAllPreviews();
+    };
+  }, [revokeAllPreviews]);
+  const createPreview = _react.useCallback.call(void 0, 
+    (file) => {
+      if (typeof URL !== "undefined" && typeof URL.createObjectURL === "function") {
+        try {
+          const objectUrl = URL.createObjectURL(file);
+          objectUrlsRef.current.add(objectUrl);
+          return Promise.resolve(objectUrl);
+        } catch (e10) {
+        }
+      }
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+          if (typeof reader.result === "string") {
+            resolve(reader.result);
+          } else {
+            reject(new Error(errorLabel));
+          }
+        };
+        reader.onerror = () => {
+          reject(new Error(errorLabel));
+        };
+        reader.readAsDataURL(file);
+      });
+    },
+    [errorLabel]
+  );
+  return { createPreview, revokePreview, revokeAllPreviews };
+}
+
+// src/react/hooks/useImageUpload.ts
+
+
+// src/react/hooks/uploadTracker.ts
+var uploadCounter = 0;
+function createUploadTracker() {
+  const entries = /* @__PURE__ */ new Map();
+  const clearEntryInterval = (entry) => {
+    if (entry.interval) {
+      clearInterval(entry.interval);
+      entry.interval = null;
+    }
+  };
+  const createEntry = (file, initialMessage, customId, externalSignal) => {
+    uploadCounter += 1;
+    const id = customId || `upload-${Date.now()}-${uploadCounter}`;
+    const controller = new AbortController();
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        controller.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+      }
+    }
+    const existing = entries.get(id);
+    if (existing) {
+      clearEntryInterval(existing);
+      existing.controller.abort();
+      entries.delete(id);
+    }
+    const entry = {
+      id,
+      file,
+      progress: 0,
+      message: initialMessage,
+      controller,
+      interval: null
+    };
+    entries.set(id, entry);
+    return entry;
+  };
+  const removeEntry = (id) => {
+    const entry = entries.get(id);
+    if (entry) {
+      clearEntryInterval(entry);
+      entries.delete(id);
+    }
+  };
+  const abortByIdOrFile = (idOrFile) => {
+    let aborted = false;
+    for (const [key, entry] of entries.entries()) {
+      if (typeof idOrFile === "string" && key === idOrFile || entry.file === idOrFile) {
+        clearEntryInterval(entry);
+        entry.controller.abort();
+        entries.delete(key);
+        aborted = true;
+      }
+    }
+    return aborted;
+  };
+  const abortAll = () => {
+    for (const entry of entries.values()) {
+      clearEntryInterval(entry);
+      entry.controller.abort();
+    }
+    entries.clear();
+  };
+  return {
+    entries,
+    createEntry,
+    removeEntry,
+    abortByIdOrFile,
+    abortAll
+  };
+}
+
+// src/react/hooks/xhrUpload.ts
+var MAX_ERROR_BODY_LENGTH = 160;
+function sanitizeRawErrorBody(rawBody) {
+  const trimmed = rawBody.trim();
+  if (!trimmed) return "";
+  const looksLikeHtml = /<(?:!doctype|html|head|body|title|h[1-6]|p|div|span|center|hr)\b/i.test(
+    trimmed
+  );
+  let cleaned = trimmed;
+  if (looksLikeHtml) {
+    const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const h1Match = trimmed.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    const extracted = (_optionalChain([h1Match, 'optionalAccess', _28 => _28[1]]) || _optionalChain([titleMatch, 'optionalAccess', _29 => _29[1]]) || trimmed).replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    cleaned = extracted;
+  }
+  if (cleaned.length > MAX_ERROR_BODY_LENGTH) {
+    return `${cleaned.slice(0, MAX_ERROR_BODY_LENGTH).trimEnd()}\u2026`;
+  }
+  return cleaned;
+}
+function createUploadAbortError(message = "Upload cancelled") {
+  const err = new Error(message);
+  err.name = "AbortError";
+  return err;
+}
+function isUploadAbortError(err) {
+  return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
+}
+function parseErrorPayload(status, rawBody, fallbackLabel = "Upload failed") {
+  const statusInfo = `status ${status}`;
+  let parsed;
+  try {
+    const json = JSON.parse(rawBody);
+    if (json && typeof json === "object") {
+      parsed = json;
+    }
+  } catch (e11) {
+    parsed = void 0;
+  }
+  const candidateKeys = ["error", "message", "detail", "details"];
+  if (parsed) {
+    for (const key of candidateKeys) {
+      const val = parsed[key];
+      if (typeof val === "string" && val.trim()) {
+        return `${val.trim()} (${statusInfo})`;
+      }
+    }
+  }
+  const cleanedBody = rawBody ? sanitizeRawErrorBody(rawBody) : "";
+  if (cleanedBody) {
+    return `${cleanedBody} (${statusInfo})`;
+  }
+  return `${fallbackLabel} (${statusInfo})`;
+}
+function buildUploadFormData(file, fields = {}) {
+  const {
+    preset,
+    folder,
+    bucket,
+    altText,
+    customFilename,
+    outputFormat,
+    quality,
+    maxDimensions,
+    metadata
+  } = fields;
+  const formData = new FormData();
+  formData.append("file", file);
+  if (preset) formData.append("preset", preset);
+  if (folder) formData.append("folder", folder);
+  if (bucket) formData.append("bucket", bucket);
+  if (altText) formData.append("altText", altText);
+  if (customFilename) formData.append("customFilename", customFilename);
+  if (outputFormat) formData.append("outputFormat", outputFormat);
+  if (quality !== void 0) formData.append("quality", String(quality));
+  if (maxDimensions) {
+    formData.append("maxWidth", String(maxDimensions.width));
+    formData.append("maxHeight", String(maxDimensions.height));
+  }
+  if (metadata && Object.keys(metadata).length > 0) {
+    formData.append("metadata", JSON.stringify(metadata));
+  }
+  return formData;
+}
+function uploadViaXhr(endpoint, formData, options = {}) {
+  const fallbackLabel = options.fallbackErrorLabel || "Upload failed";
+  const networkLabel = options.networkErrorLabel || "Network error during image upload";
+  const invalidJsonLabel = options.invalidResponseLabel || "Invalid JSON response from upload endpoint";
+  const abortedLabel = options.abortedErrorLabel || "Upload cancelled";
+  if (_optionalChain([options, 'access', _30 => _30.signal, 'optionalAccess', _31 => _31.aborted])) {
+    return Promise.reject(createUploadAbortError(abortedLabel));
+  }
+  if (typeof XMLHttpRequest === "undefined") {
+    return fetch(endpoint, {
+      method: "POST",
+      body: formData,
+      headers: options.headers,
+      credentials: options.withCredentials ? "include" : "same-origin",
+      signal: options.signal
+    }).then(async (res) => {
+      const text = await res.text();
+      if (!res.ok) {
+        throw new Error(parseErrorPayload(res.status, text, fallbackLabel));
+      }
+      try {
+        return JSON.parse(text);
+      } catch (e12) {
+        throw new Error(invalidJsonLabel);
+      }
+    });
+  }
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", endpoint, true);
+    xhr.withCredentials = Boolean(options.withCredentials);
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+    }
+    const onSignalAbort = () => {
+      xhr.abort();
+    };
+    _optionalChain([options, 'access', _32 => _32.signal, 'optionalAccess', _33 => _33.addEventListener, 'call', _34 => _34("abort", onSignalAbort, { once: true })]);
+    const cleanup = () => {
+      _optionalChain([options, 'access', _35 => _35.signal, 'optionalAccess', _36 => _36.removeEventListener, 'call', _37 => _37("abort", onSignalAbort)]);
+    };
+    xhr.upload.onprogress = (event) => {
+      if (event.lengthComputable && event.total > 0) {
+        const pct = Math.min(
+          85,
+          Math.round(event.loaded / event.total * 85)
+        );
+        _optionalChain([options, 'access', _38 => _38.onUploadProgress, 'optionalCall', _39 => _39(pct)]);
+      }
+    };
+    xhr.onload = () => {
+      cleanup();
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          const parsed = JSON.parse(xhr.responseText);
+          resolve(parsed);
+        } catch (e13) {
+          reject(new Error(invalidJsonLabel));
+        }
+      } else {
+        reject(
+          new Error(
+            parseErrorPayload(xhr.status, xhr.responseText, fallbackLabel)
+          )
+        );
+      }
+    };
+    xhr.onerror = () => {
+      cleanup();
+      reject(new Error(networkLabel));
+    };
+    xhr.onabort = () => {
+      cleanup();
+      reject(createUploadAbortError(abortedLabel));
+    };
+    xhr.send(formData);
+  });
+}
+
+// src/react/hooks/useImageUpload.ts
+function useImageUpload({
+  preset,
+  folder,
+  bucket,
+  metadata,
+  altText,
+  outputFormat,
+  quality,
+  maxDimensions,
+  customFilename: defaultCustomFilename,
+  endpoint: propEndpoint,
+  uploader: propUploader,
+  headers: propHeaders,
+  withCredentials: propWithCredentials,
+  locale: propLocale,
+  onSuccess,
+  onError,
+  onProgress
+} = {}) {
+  const ctx = useImageUploadContext();
+  const uploadLocale = normalizeUploadLocale(propLocale || ctx.locale);
+  const ui = resolveTranslations(uploadLocale, ctx.translations);
+  const resolvedEndpoint = propEndpoint || ctx.endpoint || "/api/upload";
+  const resolvedUploader = propUploader || ctx.uploader;
+  const resolvedHeaders = propHeaders || ctx.headers;
+  const resolvedCredentials = _nullishCoalesce(propWithCredentials, () => ( ctx.withCredentials));
+  const [isUploading, setIsUploading] = _react.useState.call(void 0, false);
+  const [progress, setProgress] = _react.useState.call(void 0, 0);
+  const [uploadMessage, setUploadMessage] = _react.useState.call(void 0, "");
+  const isMountedRef = _react.useRef.call(void 0, true);
+  const timeoutsRef = _react.useRef.call(void 0, /* @__PURE__ */ new Set());
+  const trackerRef = _react.useRef.call(void 0, null);
+  if (!trackerRef.current) trackerRef.current = createUploadTracker();
+  const clearAllTimeouts = _react.useCallback.call(void 0, () => {
+    timeoutsRef.current.forEach((t) => clearTimeout(t));
+    timeoutsRef.current.clear();
+  }, []);
+  const safeSetTimeout = _react.useCallback.call(void 0, (fn, ms) => {
+    const handle = setTimeout(() => {
+      timeoutsRef.current.delete(handle);
+      if (isMountedRef.current) fn();
+    }, ms);
+    timeoutsRef.current.add(handle);
+    return handle;
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    isMountedRef.current = true;
+    const tracker = trackerRef.current;
+    return () => {
+      isMountedRef.current = false;
+      _optionalChain([tracker, 'optionalAccess', _40 => _40.abortAll, 'call', _41 => _41()]);
+      clearAllTimeouts();
+    };
+  }, [clearAllTimeouts]);
+  const abortUpload = _react.useCallback.call(void 0, (idOrFile) => {
+    const tracker = trackerRef.current;
+    const aborted = tracker.abortByIdOrFile(idOrFile);
+    if (aborted && isMountedRef.current && tracker.entries.size === 0) {
+      setIsUploading(false);
+      setProgress(0);
+      setUploadMessage("");
+    }
+    return aborted;
+  }, []);
+  const abortAll = _react.useCallback.call(void 0, () => {
+    _optionalChain([trackerRef, 'access', _42 => _42.current, 'optionalAccess', _43 => _43.abortAll, 'call', _44 => _44()]);
+    clearAllTimeouts();
+    if (isMountedRef.current) {
+      setIsUploading(false);
+      setProgress(0);
+      setUploadMessage("");
+    }
+  }, [clearAllTimeouts]);
+  const uploadImage = _react.useCallback.call(void 0, 
+    async (file, customAltText, overrideCustomFilename, callOptions) => {
+      const tracker = trackerRef.current;
+      const entry = tracker.createEntry(
+        file,
+        ui.preparingUpload,
+        _optionalChain([callOptions, 'optionalAccess', _45 => _45.uploadId]),
+        _optionalChain([callOptions, 'optionalAccess', _46 => _46.signal])
+      );
+      const { id: uploadId, controller } = entry;
+      const originalSize = file.size;
+      setIsUploading(true);
+      setProgress(0);
+      setUploadMessage(ui.preparingUpload);
+      _optionalChain([onProgress, 'optionalCall', _47 => _47(0, ui.preparingUpload, file, uploadId)]);
+      const updateEntryProgress = (nextPct, maxCap) => {
+        if (!isMountedRef.current || controller.signal.aborted) return;
+        const clamped = Math.max(entry.progress, Math.min(maxCap, nextPct));
+        entry.progress = clamped;
+        const msg = _chunkKJVYWKIGcjs.getStatusMessage.call(void 0, clamped, uploadLocale);
+        entry.message = msg;
+        setProgress(clamped);
+        setUploadMessage(msg);
+        _optionalChain([onProgress, 'optionalCall', _48 => _48(clamped, msg, file, uploadId)]);
+      };
+      const reportProgress = (nextPct) => updateEntryProgress(nextPct, 94);
+      try {
+        entry.interval = setInterval(() => {
+          if (!isMountedRef.current || controller.signal.aborted) {
+            tracker.removeEntry(uploadId);
+            return;
+          }
+          updateEntryProgress(entry.progress + 6, 92);
+        }, 300);
+        const finalAlt = customAltText !== void 0 ? customAltText || void 0 : altText || void 0;
+        const finalCustomFilename = overrideCustomFilename || defaultCustomFilename || void 0;
+        const requestFields = {
+          preset,
+          folder,
+          bucket,
+          altText: finalAlt,
+          customFilename: finalCustomFilename,
+          outputFormat,
+          quality,
+          maxDimensions,
+          metadata
+        };
+        const data = resolvedUploader ? await resolvedUploader(file, {
+          ...requestFields,
+          signal: controller.signal,
+          onUploadProgress: reportProgress
+        }) : await uploadViaXhr(resolvedEndpoint, buildUploadFormData(file, requestFields), {
+          headers: resolvedHeaders,
+          withCredentials: resolvedCredentials,
+          signal: controller.signal,
+          fallbackErrorLabel: ui.uploadFailed,
+          networkErrorLabel: ui.networkError,
+          invalidResponseLabel: ui.invalidUploadResponse,
+          abortedErrorLabel: ui.uploadAborted,
+          onUploadProgress: reportProgress
+        });
+        tracker.removeEntry(uploadId);
+        if (!isMountedRef.current || controller.signal.aborted) return null;
+        entry.progress = 100;
+        setProgress(100);
+        const successMsg = _chunkKJVYWKIGcjs.createSuccessMessage.call(void 0, originalSize, data.size, false, uploadLocale);
+        setUploadMessage(successMsg);
+        _optionalChain([onProgress, 'optionalCall', _49 => _49(100, successMsg, file, uploadId)]);
+        safeSetTimeout(() => {
+          if (tracker.entries.size === 0) setUploadMessage("");
+        }, 5e3);
+        _optionalChain([onSuccess, 'optionalCall', _50 => _50(data, file, uploadId)]);
+        return data;
+      } catch (err) {
+        tracker.removeEntry(uploadId);
+        if (!isMountedRef.current || controller.signal.aborted || isUploadAbortError(err)) {
+          return null;
+        }
+        const errorMsg = err instanceof Error ? err.message : ui.uploadFailed;
+        setUploadMessage("");
+        _optionalChain([onError, 'optionalCall', _51 => _51(errorMsg, file, uploadId)]);
+        return null;
+      } finally {
+        tracker.removeEntry(uploadId);
+        if (isMountedRef.current && tracker.entries.size === 0) {
+          setIsUploading(false);
+          safeSetTimeout(() => {
+            if (tracker.entries.size === 0) setProgress(0);
+          }, 1e3);
+        }
+      }
+    },
+    [
+      preset,
+      folder,
+      bucket,
+      metadata,
+      altText,
+      outputFormat,
+      quality,
+      maxDimensions,
+      defaultCustomFilename,
+      resolvedEndpoint,
+      resolvedUploader,
+      resolvedHeaders,
+      resolvedCredentials,
+      uploadLocale,
+      ui.preparingUpload,
+      ui.uploadFailed,
+      ui.networkError,
+      ui.invalidUploadResponse,
+      ui.uploadAborted,
+      onSuccess,
+      onError,
+      onProgress,
+      safeSetTimeout
+    ]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    abortAll();
+  }, [abortAll]);
+  return { uploadImage, abortUpload, abortAll, isUploading, progress, uploadMessage, reset };
+}
+
+// src/react/hooks/useSingleImageState.ts
+function useSingleImageState(props) {
+  const {
+    value,
+    onChange,
+    preset,
+    folder,
+    bucket,
+    metadata,
+    endpoint,
+    uploader,
+    headers,
+    withCredentials,
+    locale: propLocale,
+    translations,
+    initialAltText: propInitialAltText,
+    maxSizeMB: propMaxSizeMB,
+    maxDimensions,
+    requireAltText: propRequireAltText,
+    required,
+    isOpen,
+    onClose,
+    outputFormat,
+    quality: initialQualityProp,
+    customFilename,
+    formValue
+  } = props;
+  const ctx = useImageUploadContext();
+  const locale = normalizeUploadLocale(propLocale || ctx.locale);
+  const ui = resolveTranslations(locale, translations || ctx.translations);
+  const requireAltText = _nullishCoalesce(propRequireAltText, () => ( ctx.requireAltText));
+  const standardPreset = preset ? _chunkNEDBIIE3cjs.STANDARD_PRESETS[preset] : void 0;
+  const maxSizeMB = _nullishCoalesce(_nullishCoalesce(propMaxSizeMB, () => ( _optionalChain([standardPreset, 'optionalAccess', _52 => _52.maxSizeMB]))), () => ( 10));
+  const requiresManualCommit = Boolean(isOpen);
+  const cache = _react.useMemo.call(void 0, () => createUploadSessionCache(ctx.storageKeyPrefix || "iuk"), [ctx.storageKeyPrefix]);
+  const objVal = typeof value === "object" && value ? value : null;
+  const initPreview = typeof value === "string" ? value : _optionalChain([objVal, 'optionalAccess', _53 => _53.url]) || null;
+  const initAlt = _optionalChain([objVal, 'optionalAccess', _54 => _54.altText]) || propInitialAltText || "";
+  const initColor = _optionalChain([objVal, 'optionalAccess', _55 => _55.blurColor]) || _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR;
+  const [preview, setPreview] = _react.useState.call(void 0, initPreview);
+  const previewRef = _react.useRef.call(void 0, initPreview);
+  previewRef.current = preview;
+  const [altText, setAltText] = _react.useState.call(void 0, initAlt);
+  const [blurColor, setBlurColor] = _react.useState.call(void 0, initColor);
+  const [detectedBlurColor, setDetectedBlurColor] = _react.useState.call(void 0, initColor);
+  const [blurDataUrlState, setBlurDataUrlState] = _react.useState.call(void 0, _optionalChain([objVal, 'optionalAccess', _56 => _56.blurDataUrl]) || "");
+  const [hasColorOverride, setHasColorOverride] = _react.useState.call(void 0, false);
+  const [validationError, setValidationError] = _react.useState.call(void 0, "");
+  const [showMissingAltWarning, setShowMissingAltWarning] = _react.useState.call(void 0, false);
+  const [editingAltText, setEditingAltText] = _react.useState.call(void 0, false);
+  const [sizeInfo, setSizeInfo] = _react.useState.call(void 0, null);
+  const [uploadedData, setUploadedData] = _react.useState.call(void 0, objVal && "url" in objVal ? objVal : null);
+  const [isBlurModalOpen, setIsBlurModalOpen] = _react.useState.call(void 0, false);
+  const [selectedFile, setSelectedFile] = _react.useState.call(void 0, null);
+  const [qualityLevel, setQualityLevel] = _react.useState.call(void 0, () => resolveInitialQualityLevel(initialQualityProp, standardPreset));
+  const fileInputRef = _react.useRef.call(void 0, null);
+  const lastAltRef = _react.useRef.call(void 0, initAlt);
+  const activeUploadIdRef = _react.useRef.call(void 0, null);
+  const uploadSeqRef = _react.useRef.call(void 0, 0);
+  const resetColorAndErrorState = () => {
+    setValidationError("");
+    setHasColorOverride(false);
+    setBlurColor(_chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR);
+    setDetectedBlurColor(_chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR);
+    setIsBlurModalOpen(false);
+  };
+  const { createPreview, revokePreview } = useFilePreview({ errorLabel: ui.failedCreatePreview });
+  const { uploadImage, abortAll, isUploading, progress, uploadMessage, reset } = useImageUpload({
+    preset,
+    folder,
+    bucket,
+    metadata,
+    outputFormat,
+    maxDimensions,
+    customFilename,
+    quality: _chunkKJVYWKIGcjs.QUALITY_PRESETS[qualityLevel].value,
+    endpoint,
+    uploader,
+    headers,
+    withCredentials,
+    locale,
+    onSuccess: (data, _file, uploadId) => {
+      if (uploadId && activeUploadIdRef.current && uploadId !== activeUploadIdRef.current) return;
+      if (previewRef.current && previewRef.current !== data.url) revokePreview(previewRef.current);
+      setPreview(data.url);
+      setSizeInfo({ original: data.originalSize || 0, optimized: data.size });
+      const normColor = data.blurColor || _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR;
+      setBlurColor(normColor);
+      setDetectedBlurColor(normColor);
+      setHasColorOverride(false);
+      setBlurDataUrlState(data.blurDataUrl || "");
+      const keyInfo = { url: data.url, contentHash: data.contentHash };
+      cache.writeBlurMetaFor(keyInfo, { blurDataUrl: data.blurDataUrl || "", blurColor: normColor });
+      const currentAlt = lastAltRef.current || data.altText || "";
+      setAltText(currentAlt);
+      lastAltRef.current = currentAlt;
+      const payload = { ...data, altText: currentAlt, blurColor: normColor };
+      setUploadedData(payload);
+      cache.writeAltMetaFor(keyInfo, currentAlt);
+      if (!requiresManualCommit) onChange(payload);
+    },
+    onError: (errorMsg, _file, uploadId) => {
+      if (uploadId && activeUploadIdRef.current && uploadId !== activeUploadIdRef.current) return;
+      revokePreview(previewRef.current);
+      setValidationError(errorMsg);
+      setPreview(null);
+      setUploadedData(null);
+    }
+  });
+  _react.useEffect.call(void 0, () => {
+    if (isOpen === false) abortAll();
+  }, [isOpen, abortAll]);
+  _react.useEffect.call(void 0, () => {
+    const incomingObj = typeof value === "object" && value ? value : null;
+    const nextPreview = typeof value === "string" ? value : _optionalChain([incomingObj, 'optionalAccess', _57 => _57.url]) || null;
+    const rawAlt = _optionalChain([incomingObj, 'optionalAccess', _58 => _58.altText]) || propInitialAltText || "";
+    const cachedAlt = cache.readAltMetaFor({ url: incomingObj ? incomingObj.url : nextPreview, contentHash: _nullishCoalesce(_optionalChain([incomingObj, 'optionalAccess', _59 => _59.contentHash]), () => ( null)) });
+    const nextAlt = rawAlt.trim() === "" && nextPreview === preview && (lastAltRef.current.trim() !== "" || _optionalChain([cachedAlt, 'optionalAccess', _60 => _60.trim, 'call', _61 => _61()])) ? lastAltRef.current.trim() || cachedAlt || rawAlt : rawAlt;
+    const nextColor = _optionalChain([incomingObj, 'optionalAccess', _62 => _62.blurColor]) || _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR;
+    if (stripUrlCacheQuery(nextPreview) !== stripUrlCacheQuery(preview)) setPreview(nextPreview);
+    if (nextAlt !== altText && (nextPreview !== preview || nextAlt.trim() !== "" || !altText.trim())) {
+      setAltText(nextAlt);
+      lastAltRef.current = nextAlt;
+    }
+    const nextIsFallback = nextColor === _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR;
+    if (nextColor !== blurColor && (nextPreview !== preview || !hasColorOverride && (!nextIsFallback || blurColor === _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR))) {
+      setBlurColor(nextColor);
+      setDetectedBlurColor(nextColor);
+      setHasColorOverride(false);
+    }
+    const nextBlurUrl = _optionalChain([incomingObj, 'optionalAccess', _63 => _63.blurDataUrl]) || "";
+    if (nextPreview !== preview || nextBlurUrl && nextBlurUrl !== blurDataUrlState) {
+      setBlurDataUrlState(nextBlurUrl);
+    }
+    if (nextPreview) {
+      const cached = cache.readBlurMetaFor({
+        url: nextPreview,
+        contentHash: _optionalChain([incomingObj, 'optionalAccess', _64 => _64.contentHash]) || _optionalChain([uploadedData, 'optionalAccess', _65 => _65.contentHash])
+      });
+      if (_optionalChain([cached, 'optionalAccess', _66 => _66.blurDataUrl]) && !nextBlurUrl) setBlurDataUrlState(cached.blurDataUrl);
+      if (_optionalChain([cached, 'optionalAccess', _67 => _67.blurColor]) && nextIsFallback && blurColor === _chunkNEDBIIE3cjs.DEFAULT_BLUR_COLOR) {
+        setBlurColor(cached.blurColor);
+        setDetectedBlurColor(cached.blurColor);
+      }
+    }
+    if (!value) {
+      setUploadedData(null);
+      setBlurDataUrlState("");
+      setSizeInfo(null);
+      setSelectedFile(null);
+      lastAltRef.current = propInitialAltText || "";
+      if (fileInputRef.current) fileInputRef.current.value = "";
+    } else if (_optionalChain([incomingObj, 'optionalAccess', _68 => _68.url])) {
+      setUploadedData((prev) => _optionalChain([prev, 'optionalAccess', _69 => _69.url]) === incomingObj.url ? prev : incomingObj);
+    }
+  }, [value, propInitialAltText]);
+  const commitIfAuto = (overrides) => {
+    if (!requiresManualCommit) {
+      const payload = buildSingleImagePayload(
+        { uploadedData, objVal, value, preview, altText, blurColor, blurDataUrlState },
+        overrides
+      );
+      if (payload) onChange(payload);
+    }
+  };
+  const applyBlurColor = (color, options = {}) => {
+    const normalized = _chunkNEDBIIE3cjs.normalizeColorInput.call(void 0, color);
+    if (!normalized) return;
+    setBlurColor(normalized);
+    setHasColorOverride(options.markOverride !== false);
+    setUploadedData((prev) => prev ? { ...prev, blurColor: normalized } : prev);
+    if (preview) cache.writeBlurMetaFor({ url: preview, contentHash: _optionalChain([uploadedData, 'optionalAccess', _70 => _70.contentHash]) }, { blurDataUrl: blurDataUrlState, blurColor: normalized });
+    commitIfAuto({ blurColor: normalized });
+  };
+  const handleResetColor = () => {
+    if (detectedBlurColor) applyBlurColor(detectedBlurColor, { markOverride: false });
+  };
+  const handleFileSelect = async (files) => {
+    const file = files[0];
+    if (!file) return;
+    abortAll();
+    setSelectedFile(file);
+    resetColorAndErrorState();
+    const err = _chunkNEDBIIE3cjs.validateImageFile.call(void 0, file, maxSizeMB, locale);
+    if (err) {
+      setValidationError(err);
+      return;
+    }
+    uploadSeqRef.current += 1;
+    const uploadId = `single-${uploadSeqRef.current}`;
+    activeUploadIdRef.current = uploadId;
+    try {
+      const nextBlobUrl = await createPreview(file);
+      if (activeUploadIdRef.current !== uploadId) {
+        revokePreview(nextBlobUrl);
+        return;
+      }
+      revokePreview(previewRef.current);
+      setPreview(nextBlobUrl);
+      setAltText("");
+      lastAltRef.current = "";
+    } catch (e14) {
+      setValidationError(ui.failedCreatePreview);
+      return;
+    }
+    await uploadImage(file, "", customFilename, { uploadId });
+  };
+  const handleCancelUpload = () => {
+    activeUploadIdRef.current = null;
+    abortAll();
+    revokePreview(previewRef.current);
+    setPreview(null);
+    setSelectedFile(null);
+    reset();
+    if (fileInputRef.current) fileInputRef.current.value = "";
+  };
+  const handleRemoveTile = () => {
+    handleCancelUpload();
+    setAltText("");
+    lastAltRef.current = "";
+    setBlurDataUrlState("");
+    setSizeInfo(null);
+    setUploadedData(null);
+    resetColorAndErrorState();
+    if (!requiresManualCommit) onChange(null);
+  };
+  const handleAltTextSave = (newAltText) => {
+    setAltText(newAltText);
+    lastAltRef.current = newAltText;
+    if (preview) cache.writeAltMetaFor({ url: preview, contentHash: _optionalChain([uploadedData, 'optionalAccess', _71 => _71.contentHash]) }, newAltText);
+    setShowMissingAltWarning(false);
+    setEditingAltText(false);
+    commitIfAuto({ altText: newAltText });
+  };
+  const handleSaveImage = () => {
+    if (required && !preview) {
+      setValidationError(ui.requiredFieldError);
+      return;
+    }
+    if (requireAltText && preview && !_optionalChain([altText, 'optionalAccess', _72 => _72.trim, 'call', _73 => _73()])) {
+      setShowMissingAltWarning(true);
+      setValidationError(ui.addAltBeforeSaving);
+      return;
+    }
+    setShowMissingAltWarning(false);
+    setValidationError("");
+    const payload = buildSingleImagePayload({ uploadedData, objVal, value, preview, altText, blurColor, blurDataUrlState });
+    if (payload) {
+      lastAltRef.current = payload.altText || lastAltRef.current;
+      cache.writeAltMetaFor({ url: payload.url, contentHash: payload.contentHash }, payload.altText || "");
+      onChange(payload);
+    }
+    _optionalChain([onClose, 'optionalCall', _74 => _74()]);
+  };
+  const currentImageData = preview ? _nullishCoalesce(uploadedData, () => ( objVal)) : null;
+  const downloadUrl = preview ? _nullishCoalesce(_nullishCoalesce(_optionalChain([uploadedData, 'optionalAccess', _75 => _75.url]), () => ( (typeof value === "string" ? value : _optionalChain([objVal, 'optionalAccess', _76 => _76.url])))), () => ( null)) : null;
+  const handleDownload = _react.useCallback.call(void 0, async () => {
+    if (downloadUrl) await downloadImageWithFallback(downloadUrl, _optionalChain([uploadedData, 'optionalAccess', _77 => _77.format]));
+  }, [downloadUrl, _optionalChain([uploadedData, 'optionalAccess', _78 => _78.format])]);
+  const liveAnnouncement = resolveLiveAnnouncement(isUploading, progress, Boolean(sizeInfo && !isUploading), ui);
+  const serializedFormValue = serializeSingleFormValue({
+    formValue,
+    currentImageData,
+    preview,
+    altText,
+    blurColor,
+    blurDataUrlState,
+    isUploading
+  });
+  return {
+    locale,
+    ui,
+    requireAltText,
+    maxSizeMB,
+    fileInputRef,
+    preview,
+    altText,
+    blurColor,
+    detectedBlurColor,
+    blurDataUrlState,
+    validationError,
+    showMissingAltWarning,
+    editingAltText,
+    setEditingAltText,
+    sizeInfo,
+    uploadedData,
+    isBlurModalOpen,
+    setIsBlurModalOpen,
+    selectedFile,
+    qualityLevel,
+    setQualityLevel,
+    isUploading,
+    progress,
+    uploadMessage,
+    liveAnnouncement,
+    currentImageData,
+    canDownload: Boolean(downloadUrl),
+    serializedFormValue,
+    applyBlurColor,
+    handleResetColor,
+    handleFileSelect,
+    handleCancelUpload,
+    handleRemoveTile,
+    handleAltTextSave,
+    handleSaveImage,
+    handleDownload
+  };
+}
+
+// src/react/utils/slotStyles.ts
+var HIDDEN_INPUT_STYLE = {
+  position: "absolute",
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  border: 0
+};
+function cx(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+function resolveSlotClass(defaultClass, unstyled, ...customClasses) {
+  const merged = unstyled ? cx(...customClasses) : cx(defaultClass, ...customClasses);
+  return merged || void 0;
+}
+function resolveSlotStyle(...styles) {
+  let result;
+  for (const style of styles) {
+    if (style) {
+      result = result ? { ...result, ...style } : { ...style };
+    }
+  }
+  return result;
+}
+function resolveUploadDataState(flags) {
+  if (flags.disabled) return "disabled";
+  if (flags.isDragging) return "dragging";
+  if (flags.isUploading) return "uploading";
+  if (flags.hasError) return "error";
+  if (flags.hasContent) return "ready";
+  return "idle";
+}
+
+// src/react/headless/useSingleUpload.ts
+var DEFAULT_ACCEPT = "image/jpeg,image/png,image/webp,image/avif,image/svg+xml";
+function useSingleUpload(options) {
+  const {
+    accept = DEFAULT_ACCEPT,
+    disabled = false,
+    error: externalError,
+    capture,
+    enablePaste = true,
+    pasteTarget = "dropzone",
+    required = false,
+    onBlur
+  } = options;
+  const {
+    locale,
+    ui,
+    maxSizeMB,
+    fileInputRef,
+    preview,
+    altText,
+    blurColor,
+    detectedBlurColor,
+    blurDataUrlState,
+    validationError,
+    sizeInfo,
+    uploadedData,
+    qualityLevel,
+    setQualityLevel,
+    isUploading,
+    progress,
+    uploadMessage,
+    currentImageData,
+    canDownload,
+    applyBlurColor,
+    handleResetColor,
+    handleFileSelect,
+    handleCancelUpload,
+    handleRemoveTile,
+    handleAltTextSave,
+    handleSaveImage,
+    handleDownload
+  } = useSingleImageState(options);
+  const { isDragging, dragHandlers } = useDragAndDrop({
+    disabled,
+    onDrop: (files) => {
+      void handleFileSelect(files);
+    }
+  });
+  const { onPaste } = useClipboardPaste({
+    enabled: enablePaste,
+    pasteTarget,
+    disabled,
+    multiple: false,
+    onPasteFiles: (files) => {
+      void handleFileSelect(files);
+    }
+  });
+  const displayError = externalError || validationError || "";
+  const blurDataUrl = blurDataUrlState || _optionalChain([currentImageData, 'optionalAccess', _79 => _79.blurDataUrl]) || "";
+  const state = resolveUploadDataState({
+    disabled,
+    hasError: Boolean(displayError),
+    isUploading,
+    isDragging,
+    hasContent: Boolean(preview)
+  });
+  const openFileDialog = () => {
+    if (!disabled) _optionalChain([fileInputRef, 'access', _80 => _80.current, 'optionalAccess', _81 => _81.click, 'call', _82 => _82()]);
+  };
+  const getDropzoneProps = (overrides) => ({
+    ...overrides,
+    role: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _83 => _83.role]), () => ( "button")),
+    tabIndex: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _84 => _84.tabIndex]), () => ( (disabled ? -1 : 0))),
+    "aria-label": _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _85 => _85["aria-label"]]), () => ( ui.uploadImageAria)),
+    "aria-disabled": disabled || void 0,
+    "aria-required": required || void 0,
+    "aria-invalid": Boolean(displayError) || void 0,
+    "data-state": state,
+    "data-dragging": isDragging || void 0,
+    "data-uploading": isUploading || void 0,
+    "data-disabled": disabled || void 0,
+    "data-error": Boolean(displayError) || void 0,
+    onClick: (event) => {
+      if (event.target === fileInputRef.current) return;
+      _optionalChain([overrides, 'optionalAccess', _86 => _86.onClick, 'optionalCall', _87 => _87(event)]);
+      if (!event.defaultPrevented && !disabled) openFileDialog();
+    },
+    onKeyDown: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _88 => _88.onKeyDown, 'optionalCall', _89 => _89(event)]);
+      if (!event.defaultPrevented && !disabled && event.target === event.currentTarget && (event.key === "Enter" || event.key === " ")) {
+        event.preventDefault();
+        openFileDialog();
+      }
+    },
+    onBlur: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _90 => _90.onBlur, 'optionalCall', _91 => _91(event)]);
+      if (!event.currentTarget.contains(event.relatedTarget)) {
+        _optionalChain([onBlur, 'optionalCall', _92 => _92()]);
+      }
+    },
+    onPaste: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _93 => _93.onPaste, 'optionalCall', _94 => _94(event)]);
+      if (!event.defaultPrevented) onPaste(event);
+    },
+    onDragEnter: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _95 => _95.onDragEnter, 'optionalCall', _96 => _96(event)]);
+      dragHandlers.onDragEnter(event);
+    },
+    onDragLeave: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _97 => _97.onDragLeave, 'optionalCall', _98 => _98(event)]);
+      dragHandlers.onDragLeave(event);
+    },
+    onDragOver: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _99 => _99.onDragOver, 'optionalCall', _100 => _100(event)]);
+      dragHandlers.onDragOver(event);
+    },
+    onDrop: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _101 => _101.onDrop, 'optionalCall', _102 => _102(event)]);
+      dragHandlers.onDrop(event);
+    }
+  });
+  const getInputProps = (overrides) => ({
+    ...overrides,
+    ...capture !== void 0 && _optionalChain([overrides, 'optionalAccess', _103 => _103.capture]) === void 0 ? { capture } : {},
+    ref: fileInputRef,
+    type: "file",
+    accept: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _104 => _104.accept]), () => ( accept)),
+    disabled: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _105 => _105.disabled]), () => ( disabled)),
+    "aria-label": _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _106 => _106["aria-label"]]), () => ( ui.fileInputAria)),
+    style: _optionalChain([overrides, 'optionalAccess', _107 => _107.style]) ? { ...HIDDEN_INPUT_STYLE, ...overrides.style } : HIDDEN_INPUT_STYLE,
+    onClick: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _108 => _108.onClick, 'optionalCall', _109 => _109(event)]);
+      event.stopPropagation();
+    },
+    onChange: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _110 => _110.onChange, 'optionalCall', _111 => _111(event)]);
+      if (!event.defaultPrevented) {
+        const files = event.target.files;
+        if (files && files.length > 0) void handleFileSelect(files);
+        event.target.value = "";
+      }
+    }
+  });
+  return {
+    state,
+    preview,
+    uploadedData,
+    altText,
+    blurColor,
+    detectedBlurColor,
+    blurDataUrl,
+    isDragging,
+    isUploading,
+    progress,
+    uploadMessage,
+    error: displayError,
+    sizeInfo,
+    qualityLevel,
+    maxSizeMB,
+    disabled,
+    canDownload,
+    locale,
+    ui,
+    openFileDialog,
+    selectFiles: handleFileSelect,
+    remove: handleRemoveTile,
+    cancel: handleCancelUpload,
+    cancelUpload: handleCancelUpload,
+    save: handleSaveImage,
+    download: handleDownload,
+    setQualityLevel,
+    setAltText: handleAltTextSave,
+    setBlurColor: (hex) => applyBlurColor(hex),
+    resetBlurColor: handleResetColor,
+    getDropzoneProps,
+    getInputProps
+  };
+}
+
+// src/react/headless/useMultiUpload.ts
+
+
+// src/react/hooks/useMultiImageState.ts
+
+
+// src/react/hooks/uploadQueue.ts
+function mapUploadedToPreview(img, prev) {
+  const altText = _optionalChain([prev, 'optionalAccess', _112 => _112.altText]) && !_optionalChain([img, 'access', _113 => _113.altText, 'optionalAccess', _114 => _114.trim, 'call', _115 => _115()]) ? prev.altText : img.altText;
+  return {
+    id: _optionalChain([prev, 'optionalAccess', _116 => _116.id]) || img.url,
+    url: img.url,
+    file: null,
+    uploadMessage: null,
+    originalSize: _nullishCoalesce(img.originalSize, () => ( _optionalChain([prev, 'optionalAccess', _117 => _117.originalSize]))),
+    optimizedSize: _nullishCoalesce(img.size, () => ( _optionalChain([prev, 'optionalAccess', _118 => _118.optimizedSize]))),
+    data: { ...img, altText },
+    altText,
+    blurColor: img.blurColor || _optionalChain([prev, 'optionalAccess', _119 => _119.blurColor])
+  };
+}
+function resolveInitialQuality(q, fallback = "high") {
+  if (!q) return fallback;
+  return q <= 55 ? "low" : q <= 78 ? "medium" : q <= 90 ? "high" : "maximum";
+}
+function collectUploadedData(list, readyOnly) {
+  return list.filter((p) => p.data && (!readyOnly || !p.isUploading)).map((p) => ({
+    ...p.data,
+    altText: _nullishCoalesce(p.altText, () => ( p.data.altText)),
+    blurColor: _nullishCoalesce(p.blurColor, () => ( p.data.blurColor))
+  }));
+}
+function syncPreviewsWithValue(current, value, requiresManualCommit, uncommittedIds) {
+  const prevMap = /* @__PURE__ */ new Map();
+  current.forEach((p) => {
+    prevMap.set(p.id, p);
+    if (p.url) prevMap.set(p.url, p);
+    if (_optionalChain([p, 'access', _120 => _120.data, 'optionalAccess', _121 => _121.url])) prevMap.set(p.data.url, p);
+  });
+  const synced = value.map(
+    (img) => mapUploadedToPreview(img, prevMap.get(img.url))
+  );
+  const pending = current.filter((p) => {
+    const inValue = value.some(
+      (img) => img.url === p.id || p.url && img.url === p.url || _optionalChain([p, 'access', _122 => _122.data, 'optionalAccess', _123 => _123.url]) && img.url === p.data.url
+    );
+    if (inValue) return false;
+    if (p.isUploading || Boolean(p.error)) return true;
+    if (requiresManualCommit && Boolean(p.data) && (uncommittedIds ? uncommittedIds.has(p.id) : p.id.startsWith("temp-"))) {
+      return true;
+    }
+    return false;
+  });
+  const next = [...synced, ...pending];
+  const isSame = next.length === current.length && next.every((it, idx) => {
+    const p = current[idx];
+    return p && p.id === it.id && p.url === it.url && p.altText === it.altText && p.blurColor === it.blurColor && p.isUploading === it.isUploading && p.error === it.error;
+  });
+  return isSame ? current : next;
+}
+async function runParallelUploadPool(items, maxParallel, workerFn) {
+  if (items.length === 0) return;
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(maxParallel, items.length));
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (nextIndex < items.length) {
+        const item = items[nextIndex];
+        nextIndex += 1;
+        await workerFn(item);
+      }
+    })
+  );
+}
+function serializeMultiFormValue(previews, formValue = "json") {
+  const uploaded = collectUploadedData(previews, true);
+  if (uploaded.length === 0) return "";
+  if (formValue === "url") {
+    return uploaded.map((img) => img.url).join(",");
+  }
+  return JSON.stringify(uploaded);
+}
+function formatMinImagesMessage(template, minImages) {
+  return template.replace("{min}", String(minImages)).replace("{suffix}", minImages === 1 ? "" : "s");
+}
+
+// src/react/hooks/useMultiImageState.ts
+var EMPTY_IMAGES = [];
+var tempIdCounter = 0;
+function useMultiImageState(options) {
+  const { onChange, preset, isOpen, onClose, minImages, required, formValue } = options;
+  const value = _nullishCoalesce(options.value, () => ( EMPTY_IMAGES));
+  const maxImages = _nullishCoalesce(options.maxImages, () => ( 999));
+  const maxParallelUploads = _nullishCoalesce(options.maxParallelUploads, () => ( 2));
+  const ctx = useImageUploadContext();
+  const locale = normalizeUploadLocale(options.locale || ctx.locale);
+  const ui = resolveTranslations(locale, options.translations || ctx.translations);
+  const requireAltText = _nullishCoalesce(options.requireAltText, () => ( ctx.requireAltText));
+  const standardPreset = preset ? _chunkNEDBIIE3cjs.STANDARD_PRESETS[preset] : void 0;
+  const maxSizeMB = _nullishCoalesce(_nullishCoalesce(options.maxSizeMB, () => ( _optionalChain([standardPreset, 'optionalAccess', _124 => _124.maxSizeMB]))), () => ( 10));
+  const requiresManualCommit = Boolean(isOpen);
+  const [previews, setPreviews] = _react.useState.call(void 0, () => value.map((img) => mapUploadedToPreview(img)));
+  const previewsRef = _react.useRef.call(void 0, previews);
+  previewsRef.current = previews;
+  const uncommittedIdsRef = _react.useRef.call(void 0, /* @__PURE__ */ new Set());
+  const isRetryingRef = _react.useRef.call(void 0, false);
+  const [validationError, setValidationError] = _react.useState.call(void 0, "");
+  const [infoMessage, setInfoMessage] = _react.useState.call(void 0, "");
+  const [selectedPreviews, setSelectedPreviews] = _react.useState.call(void 0, () => /* @__PURE__ */ new Set());
+  const [uploadStats, setUploadStats] = _react.useState.call(void 0, { total: 0, completed: 0, failed: 0 });
+  const [editingAltTextId, setEditingAltTextId] = _react.useState.call(void 0, null);
+  const [showMissingAltWarning, setShowMissingAltWarning] = _react.useState.call(void 0, false);
+  const [qualityLevel, setQualityLevel] = _react.useState.call(void 0, 
+    () => resolveInitialQuality(_nullishCoalesce(options.quality, () => ( _optionalChain([standardPreset, 'optionalAccess', _125 => _125.quality]))), _optionalChain([standardPreset, 'optionalAccess', _126 => _126.recommendedQualityLevel]))
+  );
+  const { createPreview, revokePreview } = useFilePreview({ errorLabel: ui.failedCreatePreview });
+  const infoTimeoutRef = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => () => {
+    if (infoTimeoutRef.current) clearTimeout(infoTimeoutRef.current);
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    setPreviews((current) => {
+      const resolved = syncPreviewsWithValue(current, value, requiresManualCommit, uncommittedIdsRef.current);
+      previewsRef.current = resolved;
+      return resolved;
+    });
+  }, [value, requiresManualCommit]);
+  const emitImmediateChange = (nextPreviews) => {
+    if (!requiresManualCommit) onChange(collectUploadedData(nextPreviews, true));
+  };
+  const patchByIdOrFile = (uploadId, file, patch, emit = false) => {
+    const next = previewsRef.current.map((p) => {
+      if (!(uploadId ? p.id === uploadId : p.file === file)) return p;
+      if (patch.url && p.url && p.url !== patch.url) revokePreview(p.url);
+      return { ...p, ...patch };
+    });
+    previewsRef.current = next;
+    setPreviews(next);
+    if (emit) emitImmediateChange(next);
+  };
+  const patchPreview = (id, patch) => {
+    const next = previewsRef.current.map((p) => p.id === id ? patch(p) : p);
+    previewsRef.current = next;
+    setPreviews(next);
+    emitImmediateChange(next);
+  };
+  const { uploadImage, abortUpload, abortAll } = useImageUpload({
+    preset,
+    folder: options.folder,
+    bucket: options.bucket,
+    metadata: options.metadata,
+    outputFormat: options.outputFormat,
+    quality: _chunkKJVYWKIGcjs.QUALITY_PRESETS[qualityLevel].value,
+    maxDimensions: options.maxDimensions,
+    customFilename: options.customFilename,
+    endpoint: options.endpoint,
+    uploader: options.uploader,
+    headers: options.headers,
+    withCredentials: options.withCredentials,
+    locale,
+    onSuccess: (data, file, uploadId) => {
+      if (uploadId && requiresManualCommit) uncommittedIdsRef.current.add(uploadId);
+      patchByIdOrFile(uploadId, file, {
+        url: data.url,
+        uploadMessage: void 0,
+        originalSize: data.originalSize,
+        optimizedSize: data.size,
+        data,
+        blurColor: data.blurColor,
+        error: void 0,
+        isUploading: false,
+        progress: 100
+      }, true);
+      setUploadStats((s) => ({ ...s, completed: s.completed + 1 }));
+    },
+    onError: (error, file, uploadId) => {
+      patchByIdOrFile(uploadId, file, { uploadMessage: void 0, error, isUploading: false, progress: 0 });
+      setUploadStats((s) => ({ ...s, failed: s.failed + 1 }));
+    },
+    onProgress: (progress, uploadMessage, file, uploadId) => {
+      patchByIdOrFile(uploadId, file, { uploadMessage, progress, isUploading: true });
+    }
+  });
+  _react.useEffect.call(void 0, () => {
+    if (isOpen === false) {
+      abortAll();
+      uncommittedIdsRef.current.clear();
+    }
+  }, [isOpen, abortAll]);
+  const runBatchUploads = async (items, files) => {
+    _optionalChain([options, 'access', _127 => _127.onUploadStart, 'optionalCall', _128 => _128(files)]);
+    const completedBatch = [];
+    await runParallelUploadPool(items, maxParallelUploads, async (item) => {
+      if (!previewsRef.current.some((p) => p.id === item.id) || !item.file) return;
+      const uploaded = await uploadImage(item.file, item.altText, void 0, { uploadId: item.id });
+      if (uploaded) completedBatch.push(uploaded);
+    });
+    if (completedBatch.length > 0) _optionalChain([options, 'access', _129 => _129.onUploadComplete, 'optionalCall', _130 => _130(completedBatch)]);
+  };
+  const handleFileSelect = async (files) => {
+    setValidationError("");
+    setInfoMessage("");
+    const allFiles = Array.from(files);
+    const imageFiles = allFiles.filter((file) => file.type.startsWith("image/"));
+    if (imageFiles.length === 0) {
+      setValidationError(ui.noValidImageFiles);
+      return;
+    }
+    if (allFiles.length > imageFiles.length) {
+      setInfoMessage(formatSkippedImagesMessage(ui, imageFiles.length, allFiles.length - imageFiles.length, locale));
+      if (infoTimeoutRef.current) clearTimeout(infoTimeoutRef.current);
+      infoTimeoutRef.current = setTimeout(() => setInfoMessage(""), 5e3);
+    }
+    const activeCount = previewsRef.current.filter((p) => !p.error).length;
+    const validationResult = _chunkNEDBIIE3cjs.validateMultipleFiles.call(void 0, imageFiles, maxSizeMB, activeCount, maxImages, locale);
+    if (validationResult) {
+      setValidationError(validationResult);
+      return;
+    }
+    setUploadStats({ total: imageFiles.length, completed: 0, failed: 0 });
+    const newPreviews = [];
+    for (const file of imageFiles) {
+      try {
+        const url = await createPreview(file);
+        tempIdCounter += 1;
+        newPreviews.push({
+          id: `temp-${Date.now()}-${tempIdCounter}`,
+          url,
+          file,
+          fileName: file.name,
+          uploadMessage: ui.queued,
+          originalSize: file.size,
+          optimizedSize: null,
+          isUploading: true,
+          progress: 0
+        });
+      } catch (e15) {
+        setValidationError(ui.failedCreatePreviewFor.replace("{file}", file.name));
+        return;
+      }
+    }
+    const nextBatch = [...previewsRef.current, ...newPreviews];
+    previewsRef.current = nextBatch;
+    setPreviews(nextBatch);
+    await runBatchUploads(newPreviews, imageFiles);
+  };
+  const removeIds = (ids) => {
+    for (const p of previewsRef.current) {
+      if (ids.has(p.id)) {
+        abortUpload(p.id);
+        if (p.file) abortUpload(p.file);
+        revokePreview(p.url);
+        uncommittedIdsRef.current.delete(p.id);
+      }
+    }
+    const next = previewsRef.current.filter((p) => !ids.has(p.id));
+    previewsRef.current = next;
+    setPreviews(next);
+    emitImmediateChange(next);
+  };
+  const handleRemove = (id) => {
+    removeIds(/* @__PURE__ */ new Set([id]));
+    setSelectedPreviews((prev) => {
+      if (!prev.has(id)) return prev;
+      const copy = new Set(prev);
+      copy.delete(id);
+      return copy;
+    });
+  };
+  const handleCancelUpload = (id) => {
+    if (!previewsRef.current.some((p) => p.id === id)) return;
+    handleRemove(id);
+    _optionalChain([options, 'access', _131 => _131.onUploadCancel, 'optionalCall', _132 => _132(id)]);
+  };
+  const handleRemoveSelected = () => {
+    removeIds(new Set(selectedPreviews));
+    setSelectedPreviews(/* @__PURE__ */ new Set());
+  };
+  const handleClearAll = () => {
+    removeIds(new Set(previewsRef.current.map((p) => p.id)));
+    setSelectedPreviews(/* @__PURE__ */ new Set());
+    setValidationError("");
+  };
+  const toggleSelect = (id) => {
+    setSelectedPreviews((prev) => {
+      const copy = new Set(prev);
+      if (copy.has(id)) copy.delete(id);
+      else copy.add(id);
+      return copy;
+    });
+  };
+  const handleRetryUpload = async (id) => {
+    const target = previewsRef.current.find((p) => p.id === id && p.error && p.file);
+    if (!target || !target.file) return;
+    setUploadStats({ total: 1, completed: 0, failed: 0 });
+    const updated = previewsRef.current.map(
+      (p) => p.id === id ? { ...p, error: void 0, isUploading: true, progress: 0, uploadMessage: ui.retrying } : p
+    );
+    previewsRef.current = updated;
+    setPreviews(updated);
+    await runBatchUploads([target], [target.file]);
+  };
+  const handleRetryFailed = async () => {
+    if (isRetryingRef.current) return;
+    const failedItems = previewsRef.current.filter((p) => p.error && p.file);
+    if (failedItems.length === 0) return;
+    isRetryingRef.current = true;
+    try {
+      setUploadStats({ total: failedItems.length, completed: 0, failed: 0 });
+      const failedIds = new Set(failedItems.map((p) => p.id));
+      const updated = previewsRef.current.map(
+        (p) => failedIds.has(p.id) ? { ...p, error: void 0, isUploading: true, progress: 0, uploadMessage: ui.retrying } : p
+      );
+      previewsRef.current = updated;
+      setPreviews(updated);
+      await runBatchUploads(failedItems, failedItems.map((p) => p.file).filter(Boolean));
+    } finally {
+      isRetryingRef.current = false;
+    }
+  };
+  const handleAltTextSave = (previewId, altText) => {
+    patchPreview(previewId, (p) => ({ ...p, altText, data: p.data ? { ...p.data, altText } : p.data }));
+    setEditingAltTextId(null);
+    setShowMissingAltWarning(false);
+  };
+  const handleColorChange = (previewId, blurColor) => {
+    patchPreview(previewId, (p) => ({ ...p, blurColor, data: p.data ? { ...p.data, blurColor } : p.data }));
+  };
+  const isUploading = previews.some((p) => p.isUploading);
+  const hasFailedUploads = previews.some((p) => Boolean(p.error));
+  const uploadingPreviews = previews.filter((p) => p.isUploading);
+  const completedPreviews = previews.filter((p) => Boolean(p.data) && !p.isUploading);
+  const imagesWithoutAlt = completedPreviews.filter((p) => !p.altText || !p.altText.trim());
+  const editingTarget = editingAltTextId ? _nullishCoalesce(previews.find((p) => p.id === editingAltTextId), () => ( null)) : null;
+  const minImagesWarning = !isUploading && minImages && previews.length > 0 && completedPreviews.length < minImages ? formatMinImagesMessage(ui.minImagesError, minImages) : "";
+  const serializedFormValue = serializeMultiFormValue(previews, _nullishCoalesce(formValue, () => ( "json")));
+  const handleSaveImages = () => {
+    if (required && completedPreviews.length === 0) {
+      setValidationError(ui.requiredFieldError);
+      return;
+    }
+    if (minImages && completedPreviews.length < minImages) {
+      setValidationError(formatMinImagesMessage(ui.minImagesError, minImages));
+      return;
+    }
+    if (requireAltText && imagesWithoutAlt.length > 0) {
+      setShowMissingAltWarning(true);
+      setValidationError(formatNeedsAltMessage(ui, imagesWithoutAlt.length, locale));
+      return;
+    }
+    setShowMissingAltWarning(false);
+    setValidationError("");
+    uncommittedIdsRef.current.clear();
+    onChange(collectUploadedData(previews, false));
+    _optionalChain([onClose, 'optionalCall', _133 => _133()]);
+  };
+  return {
+    locale,
+    ui,
+    requireAltText,
+    maxSizeMB,
+    previews,
+    validationError: validationError || minImagesWarning,
+    infoMessage,
+    selectedPreviews,
+    setSelectedPreviews,
+    uploadStats,
+    editingAltTextId,
+    setEditingAltTextId,
+    showMissingAltWarning,
+    qualityLevel,
+    setQualityLevel,
+    isUploading,
+    hasFailedUploads,
+    uploadingPreviews,
+    completedPreviews,
+    imagesWithoutAlt,
+    editingTarget,
+    serializedFormValue,
+    handleFileSelect,
+    handleRemove,
+    handleCancelUpload,
+    handleRemoveSelected,
+    handleClearAll,
+    toggleSelect,
+    handleRetryUpload,
+    handleRetryFailed,
+    handleAltTextSave,
+    handleColorChange,
+    handleSaveImages
+  };
+}
+
+// src/react/headless/useMultiUpload.ts
+var DEFAULT_ACCEPT2 = "image/jpeg,image/png,image/webp,image/avif,image/svg+xml";
+function useMultiUpload(options) {
+  const {
+    accept = DEFAULT_ACCEPT2,
+    disabled = false,
+    error: externalError,
+    maxImages = 999,
+    capture,
+    enablePaste = true,
+    pasteTarget = "dropzone",
+    required = false,
+    onBlur
+  } = options;
+  const fileInputRef = _react.useRef.call(void 0, null);
+  const folderInputRef = _react.useRef.call(void 0, null);
+  const {
+    locale,
+    ui,
+    maxSizeMB,
+    previews,
+    validationError,
+    infoMessage,
+    selectedPreviews,
+    setSelectedPreviews,
+    uploadStats,
+    qualityLevel,
+    setQualityLevel,
+    isUploading,
+    hasFailedUploads,
+    uploadingPreviews,
+    completedPreviews,
+    handleFileSelect,
+    handleRemove,
+    handleCancelUpload,
+    handleRemoveSelected,
+    handleClearAll,
+    toggleSelect,
+    handleRetryUpload,
+    handleRetryFailed,
+    handleAltTextSave,
+    handleColorChange,
+    handleSaveImages
+  } = useMultiImageState(options);
+  const { isDragging, dragHandlers } = useDragAndDrop({
+    disabled,
+    onDrop: (files) => {
+      void handleFileSelect(files);
+    }
+  });
+  const { onPaste } = useClipboardPaste({
+    enabled: enablePaste,
+    pasteTarget,
+    disabled,
+    multiple: true,
+    onPasteFiles: (files) => {
+      void handleFileSelect(files);
+    }
+  });
+  const displayError = externalError || validationError || "";
+  const remainingCount = Math.max(0, maxImages - previews.length);
+  const state = resolveUploadDataState({
+    disabled,
+    hasError: Boolean(displayError),
+    isUploading,
+    isDragging,
+    hasContent: previews.length > 0
+  });
+  const openFileDialog = () => {
+    if (!disabled) _optionalChain([fileInputRef, 'access', _134 => _134.current, 'optionalAccess', _135 => _135.click, 'call', _136 => _136()]);
+  };
+  const openFolderDialog = () => {
+    if (!disabled) _optionalChain([folderInputRef, 'access', _137 => _137.current, 'optionalAccess', _138 => _138.click, 'call', _139 => _139()]);
+  };
+  const getDropzoneProps = (overrides) => ({
+    ...overrides,
+    role: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _140 => _140.role]), () => ( "button")),
+    tabIndex: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _141 => _141.tabIndex]), () => ( (disabled ? -1 : 0))),
+    "aria-label": _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _142 => _142["aria-label"]]), () => ( ui.selectFilesAria)),
+    "aria-disabled": disabled || void 0,
+    "aria-required": required || void 0,
+    "aria-invalid": Boolean(displayError) || void 0,
+    "data-state": state,
+    "data-dragging": isDragging || void 0,
+    "data-uploading": isUploading || void 0,
+    "data-disabled": disabled || void 0,
+    "data-error": Boolean(displayError) || void 0,
+    onClick: (event) => {
+      if (event.target === fileInputRef.current || event.target === folderInputRef.current) return;
+      _optionalChain([overrides, 'optionalAccess', _143 => _143.onClick, 'optionalCall', _144 => _144(event)]);
+      if (!event.defaultPrevented && !disabled) openFileDialog();
+    },
+    onKeyDown: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _145 => _145.onKeyDown, 'optionalCall', _146 => _146(event)]);
+      if (!event.defaultPrevented && !disabled && event.target === event.currentTarget && (event.key === "Enter" || event.key === " ")) {
+        event.preventDefault();
+        openFileDialog();
+      }
+    },
+    onBlur: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _147 => _147.onBlur, 'optionalCall', _148 => _148(event)]);
+      if (!event.currentTarget.contains(event.relatedTarget)) {
+        _optionalChain([onBlur, 'optionalCall', _149 => _149()]);
+      }
+    },
+    onPaste: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _150 => _150.onPaste, 'optionalCall', _151 => _151(event)]);
+      if (!event.defaultPrevented) onPaste(event);
+    },
+    onDragEnter: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _152 => _152.onDragEnter, 'optionalCall', _153 => _153(event)]);
+      dragHandlers.onDragEnter(event);
+    },
+    onDragLeave: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _154 => _154.onDragLeave, 'optionalCall', _155 => _155(event)]);
+      dragHandlers.onDragLeave(event);
+    },
+    onDragOver: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _156 => _156.onDragOver, 'optionalCall', _157 => _157(event)]);
+      dragHandlers.onDragOver(event);
+    },
+    onDrop: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _158 => _158.onDrop, 'optionalCall', _159 => _159(event)]);
+      dragHandlers.onDrop(event);
+    }
+  });
+  const buildInputProps = (ref, defaultAriaLabel, isFolder, overrides) => ({
+    ...overrides,
+    ...isFolder ? { webkitdirectory: "", directory: "" } : capture !== void 0 && _optionalChain([overrides, 'optionalAccess', _160 => _160.capture]) === void 0 ? { capture } : {},
+    ref,
+    type: "file",
+    multiple: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _161 => _161.multiple]), () => ( true)),
+    accept: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _162 => _162.accept]), () => ( accept)),
+    disabled: _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _163 => _163.disabled]), () => ( disabled)),
+    "aria-label": _nullishCoalesce(_optionalChain([overrides, 'optionalAccess', _164 => _164["aria-label"]]), () => ( defaultAriaLabel)),
+    style: _optionalChain([overrides, 'optionalAccess', _165 => _165.style]) ? { ...HIDDEN_INPUT_STYLE, ...overrides.style } : HIDDEN_INPUT_STYLE,
+    onClick: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _166 => _166.onClick, 'optionalCall', _167 => _167(event)]);
+      event.stopPropagation();
+    },
+    onChange: (event) => {
+      _optionalChain([overrides, 'optionalAccess', _168 => _168.onChange, 'optionalCall', _169 => _169(event)]);
+      if (!event.defaultPrevented) {
+        const files = event.target.files;
+        if (files && files.length > 0) void handleFileSelect(files);
+        event.target.value = "";
+      }
+    }
+  });
+  return {
+    state,
+    items: previews,
+    completedItems: completedPreviews,
+    uploadingItems: uploadingPreviews,
+    selectedIds: selectedPreviews,
+    stats: uploadStats,
+    isDragging,
+    isUploading,
+    hasFailedUploads,
+    error: displayError,
+    infoMessage,
+    qualityLevel,
+    maxSizeMB,
+    maxImages,
+    remainingCount,
+    disabled,
+    locale,
+    ui,
+    openFileDialog,
+    openFolderDialog,
+    selectFiles: handleFileSelect,
+    remove: handleRemove,
+    removeSelected: handleRemoveSelected,
+    clear: handleClearAll,
+    cancel: handleCancelUpload,
+    cancelUpload: handleCancelUpload,
+    retry: handleRetryUpload,
+    retryUpload: handleRetryUpload,
+    retryAll: handleRetryFailed,
+    toggleSelect,
+    selectAll: () => setSelectedPreviews(new Set(previews.map((p) => p.id))),
+    clearSelection: () => setSelectedPreviews(/* @__PURE__ */ new Set()),
+    retryFailed: handleRetryFailed,
+    save: handleSaveImages,
+    setQualityLevel,
+    setAltText: handleAltTextSave,
+    setBlurColor: handleColorChange,
+    getDropzoneProps,
+    getInputProps: (overrides) => buildInputProps(fileInputRef, ui.selectFilesAria, false, overrides),
+    getFolderInputProps: (overrides) => buildInputProps(folderInputRef, ui.selectFolderAria, true, overrides)
+  };
+}
+
+// src/react/headless/HeadlessSingleUpload.tsx
+
+function HeadlessSingleUpload(props) {
+  const controller = useSingleUpload(props);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: props.children(controller) });
+}
+
+// src/react/headless/HeadlessMultiUpload.tsx
+
+function HeadlessMultiUpload(props) {
+  const controller = useMultiUpload(props);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: props.children(controller) });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HIDDEN_INPUT_STYLE = HIDDEN_INPUT_STYLE; exports.cx = cx; exports.resolveSlotClass = resolveSlotClass; exports.resolveSlotStyle = resolveSlotStyle; exports.resolveUploadDataState = resolveUploadDataState; exports.arTranslations = arTranslations; exports.enTranslations = enTranslations; exports.DEFAULT_UPLOAD_TRANSLATIONS = DEFAULT_UPLOAD_TRANSLATIONS; exports.ARABIC_UPLOAD_TRANSLATIONS = ARABIC_UPLOAD_TRANSLATIONS; exports.normalizeUploadLocale = normalizeUploadLocale; exports.selectPluralCategory = selectPluralCategory; exports.formatUploadingCount = formatUploadingCount; exports.formatNeedsAltMessage = formatNeedsAltMessage; exports.formatSkippedImagesMessage = formatSkippedImagesMessage; exports.uploadText = uploadText; exports.resolveTranslations = resolveTranslations; exports.ImageUploadProvider = ImageUploadProvider; exports.useImageUploadContext = useImageUploadContext; exports.extractClipboardImageFiles = extractClipboardImageFiles; exports.toFileListLike = toFileListLike; exports.useClipboardPaste = useClipboardPaste; exports.useDragAndDrop = useDragAndDrop; exports.useFilePreview = useFilePreview; exports.createUploadAbortError = createUploadAbortError; exports.isUploadAbortError = isUploadAbortError; exports.parseErrorPayload = parseErrorPayload; exports.buildUploadFormData = buildUploadFormData; exports.uploadViaXhr = uploadViaXhr; exports.useImageUpload = useImageUpload; exports.appendCacheBuster = appendCacheBuster; exports.useSingleImageState = useSingleImageState; exports.useSingleUpload = useSingleUpload; exports.useMultiImageState = useMultiImageState; exports.useMultiUpload = useMultiUpload; exports.HeadlessSingleUpload = HeadlessSingleUpload; exports.HeadlessMultiUpload = HeadlessMultiUpload;
+//# sourceMappingURL=chunk-U2TWTEBY.cjs.map