@jobber/components 9.16.7 → 9.16.8

package/dist/InputFile-es.js

@@ -1,1441 +1,1222 @@
-import { a as __awaiter, b as __generator, c as __spread, _ as __rest } from './tslib.es6-es.js';
-import React__default, { useMemo, useRef, useReducer, useEffect, useCallback, forwardRef, useImperativeHandle, Fragment, createContext, useContext } from 'react';
+import { _ as __rest, a as __awaiter } from './tslib.es6-es.js';
+import React__default, { useMemo, useRef, useReducer, useCallback, useEffect, forwardRef, useImperativeHandle, createContext, useContext, useState } from 'react';
 import classnames from 'classnames';
-import { P as PropTypes } from './index-es.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
 import axios from 'axios';
 import { T as Text } from './Text-es.js';
 import { B as Button } from './Button-es.js';
 import { I as InputValidation } from './InputValidation-es.js';
+import { d as defineMessages, u as useAtlantisI18n } from './useAtlantisI18n-es.js';
+import './AtlantisContext-es.js';
 import { C as Content } from './Content-es.js';
 
-var COMMON_MIME_TYPES = new Map([
-    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
-    ['aac', 'audio/aac'],
-    ['abw', 'application/x-abiword'],
-    ['arc', 'application/x-freearc'],
-    ['avif', 'image/avif'],
-    ['avi', 'video/x-msvideo'],
-    ['azw', 'application/vnd.amazon.ebook'],
-    ['bin', 'application/octet-stream'],
-    ['bmp', 'image/bmp'],
-    ['bz', 'application/x-bzip'],
-    ['bz2', 'application/x-bzip2'],
-    ['cda', 'application/x-cdf'],
-    ['csh', 'application/x-csh'],
-    ['css', 'text/css'],
-    ['csv', 'text/csv'],
-    ['doc', 'application/msword'],
-    ['docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
-    ['eot', 'application/vnd.ms-fontobject'],
-    ['epub', 'application/epub+zip'],
-    ['gz', 'application/gzip'],
-    ['gif', 'image/gif'],
-    ['htm', 'text/html'],
-    ['html', 'text/html'],
-    ['ico', 'image/vnd.microsoft.icon'],
-    ['ics', 'text/calendar'],
-    ['jar', 'application/java-archive'],
-    ['jpeg', 'image/jpeg'],
-    ['jpg', 'image/jpeg'],
-    ['js', 'text/javascript'],
-    ['json', 'application/json'],
-    ['jsonld', 'application/ld+json'],
-    ['mid', 'audio/midi'],
-    ['midi', 'audio/midi'],
-    ['mjs', 'text/javascript'],
-    ['mp3', 'audio/mpeg'],
-    ['mp4', 'video/mp4'],
-    ['mpeg', 'video/mpeg'],
-    ['mpkg', 'application/vnd.apple.installer+xml'],
-    ['odp', 'application/vnd.oasis.opendocument.presentation'],
-    ['ods', 'application/vnd.oasis.opendocument.spreadsheet'],
-    ['odt', 'application/vnd.oasis.opendocument.text'],
-    ['oga', 'audio/ogg'],
-    ['ogv', 'video/ogg'],
-    ['ogx', 'application/ogg'],
-    ['opus', 'audio/opus'],
-    ['otf', 'font/otf'],
-    ['png', 'image/png'],
-    ['pdf', 'application/pdf'],
-    ['php', 'application/x-httpd-php'],
-    ['ppt', 'application/vnd.ms-powerpoint'],
-    ['pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
-    ['rar', 'application/vnd.rar'],
-    ['rtf', 'application/rtf'],
-    ['sh', 'application/x-sh'],
-    ['svg', 'image/svg+xml'],
-    ['swf', 'application/x-shockwave-flash'],
-    ['tar', 'application/x-tar'],
-    ['tif', 'image/tiff'],
-    ['tiff', 'image/tiff'],
-    ['ts', 'video/mp2t'],
-    ['ttf', 'font/ttf'],
-    ['txt', 'text/plain'],
-    ['vsd', 'application/vnd.visio'],
-    ['wav', 'audio/wav'],
-    ['weba', 'audio/webm'],
-    ['webm', 'video/webm'],
-    ['webp', 'image/webp'],
-    ['woff', 'font/woff'],
-    ['woff2', 'font/woff2'],
-    ['xhtml', 'application/xhtml+xml'],
-    ['xls', 'application/vnd.ms-excel'],
-    ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
-    ['xml', 'application/xml'],
-    ['xul', 'application/vnd.mozilla.xul+xml'],
-    ['zip', 'application/zip'],
-    ['7z', 'application/x-7z-compressed'],
-    // Others
-    ['mkv', 'video/x-matroska'],
-    ['mov', 'video/quicktime'],
-    ['msg', 'application/vnd.ms-outlook']
+//#region src/mime-default.ts
+/**
+* A small set of the most common file extensions, bundled into the main entry so that
+* {@link fromEvent} guesses a MIME type for typeless files out of the box.
+*
+* This is the single source of truth for these defaults: the full extension-to-MIME table
+* (`COMMON_MIME_TYPES`, exposed via the `file-selector/mime` subpath) spreads this map in
+* rather than redefining these entries, so no value is duplicated across modules.
+*
+* See https://github.com/react-dropzone/file-selector/issues/127
+*/
+const DEFAULT_MIME_TYPES = /* @__PURE__ */ new Map([
+	["avif", "image/avif"],
+	["bmp", "image/bmp"],
+	["css", "text/css"],
+	["csv", "text/csv"],
+	["doc", "application/msword"],
+	["docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+	["gif", "image/gif"],
+	["gz", "application/gzip"],
+	["htm", "text/html"],
+	["html", "text/html"],
+	["ico", "image/x-icon"],
+	["jpeg", "image/jpeg"],
+	["jpg", "image/jpeg"],
+	["js", "application/javascript"],
+	["json", "application/json"],
+	["md", "text/markdown"],
+	["mjs", "application/javascript"],
+	["mp3", "audio/mpeg"],
+	["mp4", "video/mp4"],
+	["ogg", "audio/ogg"],
+	["pdf", "application/pdf"],
+	["png", "image/png"],
+	["ppt", "application/powerpoint"],
+	["pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+	["svg", "image/svg+xml"],
+	["tif", "image/tiff"],
+	["tiff", "image/tiff"],
+	["txt", "text/plain"],
+	["wasm", "application/wasm"],
+	["wav", "audio/x-wav"],
+	["weba", "audio/webm"],
+	["webm", "video/webm"],
+	["webp", "image/webp"],
+	["xls", "application/vnd.ms-excel"],
+	["xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+	["xml", "application/xml"],
+	["zip", "application/zip"]
 ]);
-function toFileWithPath(file, path) {
-    var f = withMimeType(file);
-    if (typeof f.path !== 'string') { // on electron, path is already set to the absolute path
-        var webkitRelativePath = file.webkitRelativePath;
-        Object.defineProperty(f, 'path', {
-            value: typeof path === 'string'
-                ? path
-                // If <input webkitdirectory> is set,
-                // the File will have a {webkitRelativePath} property
-                // https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/webkitdirectory
-                : typeof webkitRelativePath === 'string' && webkitRelativePath.length > 0
-                    ? webkitRelativePath
-                    : file.name,
-            writable: false,
-            configurable: false,
-            enumerable: true
-        });
-    }
-    return f;
-}
-function withMimeType(file) {
-    var name = file.name;
-    var hasExtension = name && name.lastIndexOf('.') !== -1;
-    if (hasExtension && !file.type) {
-        var ext = name.split('.')
-            .pop().toLowerCase();
-        var type = COMMON_MIME_TYPES.get(ext);
-        if (type) {
-            Object.defineProperty(file, 'type', {
-                value: type,
-                writable: false,
-                configurable: false,
-                enumerable: true
-            });
-        }
-    }
-    return file;
-}
 
-var FILES_TO_IGNORE = [
-    // Thumbnail cache files for macOS and Windows
-    '.DS_Store',
-    'Thumbs.db' // Windows
-];
+//#region src/error.ts
+var UnexpectedObjectError = class extends Error {
+	constructor(item) {
+		super("DataTransferItem is not a file");
+		this.item = item;
+		this.name = "UnexpectedObjectError";
+	}
+};
+//#endregion
+//#region src/file.ts
+function toFileWithPath(file, path, h) {
+	const f = file;
+	const { webkitRelativePath } = file;
+	const p = typeof path === "string" ? path : typeof webkitRelativePath === "string" && webkitRelativePath.length > 0 ? webkitRelativePath : `./${file.name}`;
+	if (typeof f.path !== "string") setObjProp(f, "path", p);
+	if (h !== void 0) Object.defineProperty(f, "handle", {
+		value: h,
+		writable: false,
+		configurable: false,
+		enumerable: true
+	});
+	setObjProp(f, "relativePath", p);
+	return f;
+}
 /**
- * Convert a DragEvent's DataTrasfer object to a list of File objects
- * NOTE: If some of the items are folders,
- * everything will be flattened and placed in the same list but the paths will be kept as a {path} property.
- *
- * EXPERIMENTAL: A list of https://developer.mozilla.org/en-US/docs/Web/API/FileSystemHandle objects can also be passed as an arg
- * and a list of File objects will be returned.
- *
- * @param evt
- */
-function fromEvent(evt) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            if (isObject(evt) && isDataTransfer(evt)) {
-                return [2 /*return*/, getDataTransferFiles(evt.dataTransfer, evt.type)];
-            }
-            else if (isChangeEvt(evt)) {
-                return [2 /*return*/, getInputFiles(evt)];
-            }
-            else if (Array.isArray(evt) && evt.every(function (item) { return 'getFile' in item && typeof item.getFile === 'function'; })) {
-                return [2 /*return*/, getFsHandleFiles(evt)];
-            }
-            return [2 /*return*/, []];
-        });
-    });
+* Sets a File's `type` from its extension using the provided `mimeTypes` lookup,
+* but only when the browser didn't already set a type. Returns the same File.
+*/
+function withMimeType(file, mimeTypes = DEFAULT_MIME_TYPES) {
+	const { name } = file;
+	if (name && name.lastIndexOf(".") !== -1 && !file.type) {
+		const ext = name.split(".").pop().toLowerCase();
+		const type = mimeTypes.get(ext);
+		if (type) Object.defineProperty(file, "type", {
+			value: type,
+			writable: false,
+			configurable: false,
+			enumerable: true
+		});
+	}
+	return file;
+}
+function setObjProp(f, key, value) {
+	Object.defineProperty(f, key, {
+		value,
+		writable: false,
+		configurable: false,
+		enumerable: true
+	});
+}
+//#endregion
+//#region src/file-selector.ts
+const FILES_TO_IGNORE = [".DS_Store", "Thumbs.db"];
+/**
+* Convert a DragEvent's DataTrasfer object to a list of File objects
+* NOTE: If some of the items are folders,
+* everything will be flattened and placed in the same list but the paths will be kept as a {path} property.
+*
+* A https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent (e.g. a paste of a screenshot)
+* is also supported: its files are read from {clipboardData}.
+*
+* EXPERIMENTAL: A list of https://developer.mozilla.org/en-US/docs/Web/API/FileSystemHandle objects can also be passed as an arg
+* and a list of File objects will be returned.
+*
+* @param evt
+* @param options
+*/
+async function fromEvent(evt, { mimeTypes = DEFAULT_MIME_TYPES } = {}) {
+	return (await getFilesOrItems(evt)).map((item) => item instanceof File ? withMimeType(item, mimeTypes) : item);
+}
+async function getFilesOrItems(evt) {
+	if (isObject(evt) && isDataTransfer(evt.dataTransfer)) return getDataTransferFiles(evt.dataTransfer, evt.type);
+	else if (isClipboardEvt(evt)) return getClipboardFiles(evt.clipboardData);
+	else if (isChangeEvt(evt)) return getInputFiles(evt);
+	else if (Array.isArray(evt) && evt.every((item) => "getFile" in item && typeof item.getFile === "function")) return getFsHandleFiles(evt);
+	return [];
 }
 function isDataTransfer(value) {
-    return isObject(value.dataTransfer);
+	return isObject(value);
+}
+function isClipboardEvt(value) {
+	return isObject(value) && isDataTransfer(value.clipboardData);
 }
 function isChangeEvt(value) {
-    return isObject(value) && isObject(value.target);
+	return isObject(value) && isObject(value.target);
 }
 function isObject(v) {
-    return typeof v === 'object' && v !== null;
+	return typeof v === "object" && v !== null;
 }
 function getInputFiles(evt) {
-    return fromList(evt.target.files).map(function (file) { return toFileWithPath(file); });
-}
-// Ee expect each handle to be https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileHandle
-function getFsHandleFiles(handles) {
-    return __awaiter(this, void 0, void 0, function () {
-        var files;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, Promise.all(handles.map(function (h) { return h.getFile(); }))];
-                case 1:
-                    files = _a.sent();
-                    return [2 /*return*/, files.map(function (file) { return toFileWithPath(file); })];
-            }
-        });
-    });
+	return fromList(evt.target.files).map((file) => toFileWithPath(file));
 }
-function getDataTransferFiles(dt, type) {
-    return __awaiter(this, void 0, void 0, function () {
-        var items, files;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (dt === null) {
-                        return [2 /*return*/, []];
-                    }
-                    if (!dt.items) return [3 /*break*/, 2];
-                    items = fromList(dt.items)
-                        .filter(function (item) { return item.kind === 'file'; });
-                    // According to https://html.spec.whatwg.org/multipage/dnd.html#dndevents,
-                    // only 'dragstart' and 'drop' has access to the data (source node)
-                    if (type !== 'drop') {
-                        return [2 /*return*/, items];
-                    }
-                    return [4 /*yield*/, Promise.all(items.map(toFilePromises))];
-                case 1:
-                    files = _a.sent();
-                    return [2 /*return*/, noIgnoredFiles(flatten(files))];
-                case 2: return [2 /*return*/, noIgnoredFiles(fromList(dt.files)
-                        .map(function (file) { return toFileWithPath(file); }))];
-            }
-        });
-    });
+async function getFsHandleFiles(handles) {
+	return (await Promise.all(handles.map((h) => h.getFile()))).map((file) => toFileWithPath(file));
+}
+async function getDataTransferFiles(dt, type) {
+	const items = fromList(dt.items).filter((item) => item.kind === "file");
+	if (type !== "drop") return items;
+	return noIgnoredFiles(flatten(await Promise.all(items.map(toFilePromises))));
+}
+function getClipboardFiles(dt) {
+	const fromItems = fromList(dt.items).filter((item) => item.kind === "file").map((item) => item.getAsFile()).filter((file) => file !== null);
+	return noIgnoredFiles((fromItems.length > 0 ? fromItems : fromList(dt.files)).map((file) => toFileWithPath(file)));
 }
 function noIgnoredFiles(files) {
-    return files.filter(function (file) { return FILES_TO_IGNORE.indexOf(file.name) === -1; });
+	return files.filter((file) => FILES_TO_IGNORE.indexOf(file.name) === -1);
 }
-// IE11 does not support Array.from()
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from#Browser_compatibility
-// https://developer.mozilla.org/en-US/docs/Web/API/FileList
-// https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList
 function fromList(items) {
-    if (items === null) {
-        return [];
-    }
-    var files = [];
-    // tslint:disable: prefer-for-of
-    for (var i = 0; i < items.length; i++) {
-        var file = items[i];
-        files.push(file);
-    }
-    return files;
+	if (items === null) return [];
+	return Array.from(items);
 }
-// https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem
-function toFilePromises(item) {
-    if (typeof item.webkitGetAsEntry !== 'function') {
-        return fromDataTransferItem(item);
-    }
-    var entry = item.webkitGetAsEntry();
-    // Safari supports dropping an image node from a different window and can be retrieved using
-    // the DataTransferItem.getAsFile() API
-    // NOTE: FileSystemEntry.file() throws if trying to get the file
-    if (entry && entry.isDirectory) {
-        return fromDirEntry(entry);
-    }
-    return fromDataTransferItem(item);
+async function toFilePromises(item) {
+	if (typeof item.webkitGetAsEntry !== "function") return fromDataTransferItem(item);
+	const entry = item.webkitGetAsEntry();
+	if (entry?.isDirectory) {
+		const handle = await getFsHandle(item);
+		if (handle?.kind === "directory") return fromDirHandle(handle, `/${handle.name}`);
+		return fromDirEntry(entry);
+	}
+	return fromDataTransferItem(item, entry);
 }
 function flatten(items) {
-    return items.reduce(function (acc, files) { return __spread(acc, (Array.isArray(files) ? flatten(files) : [files])); }, []);
+	const result = [];
+	for (const item of items) if (Array.isArray(item)) result.push(...flatten(item));
+	else result.push(item);
+	return result;
 }
-function fromDataTransferItem(item) {
-    var file = item.getAsFile();
-    if (!file) {
-        return Promise.reject(item + " is not a File");
-    }
-    var fwp = toFileWithPath(file);
-    return Promise.resolve(fwp);
-}
-// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemEntry
-function fromEntry(entry) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, entry.isDirectory ? fromDirEntry(entry) : fromFileEntry(entry)];
-        });
-    });
+async function fromDataTransferItem(item, entry) {
+	const syncFile = item.getAsFile();
+	const h = await getFsHandle(item);
+	if (h !== null && h !== void 0) {
+		const file = syncFile ?? await h.getFile();
+		file.handle = h;
+		return toFileWithPath(file);
+	}
+	if (!syncFile) throw new UnexpectedObjectError(item);
+	return toFileWithPath(syncFile, entry?.fullPath ?? void 0);
+}
+async function getFsHandle(item) {
+	if (globalThis.isSecureContext && typeof item.getAsFileSystemHandle === "function") return item.getAsFileSystemHandle();
+}
+async function fromDirHandle(handle, path) {
+	const files = [];
+	for await (const child of handle.values()) {
+		const childPath = `${path}/${child.name}`;
+		if (child.kind === "directory") files.push(...await fromDirHandle(child, childPath));
+		else {
+			const file = await child.getFile();
+			files.push(toFileWithPath(file, childPath, child));
+		}
+	}
+	return files;
+}
+async function fromEntry(entry) {
+	return entry.isDirectory ? fromDirEntry(entry) : fromFileEntry(entry);
 }
-// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryEntry
 function fromDirEntry(entry) {
-    var reader = entry.createReader();
-    return new Promise(function (resolve, reject) {
-        var entries = [];
-        function readEntries() {
-            var _this = this;
-            // https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryEntry/createReader
-            // https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryReader/readEntries
-            reader.readEntries(function (batch) { return __awaiter(_this, void 0, void 0, function () {
-                var files, err_1, items;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!!batch.length) return [3 /*break*/, 5];
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, Promise.all(entries)];
-                        case 2:
-                            files = _a.sent();
-                            resolve(files);
-                            return [3 /*break*/, 4];
-                        case 3:
-                            err_1 = _a.sent();
-                            reject(err_1);
-                            return [3 /*break*/, 4];
-                        case 4: return [3 /*break*/, 6];
-                        case 5:
-                            items = Promise.all(batch.map(fromEntry));
-                            entries.push(items);
-                            // Continue reading
-                            readEntries();
-                            _a.label = 6;
-                        case 6: return [2 /*return*/];
-                    }
-                });
-            }); }, function (err) {
-                reject(err);
-            });
-        }
-        readEntries();
-    });
+	const reader = entry.createReader();
+	return new Promise((resolve, reject) => {
+		const entries = [];
+		function readEntries() {
+			reader.readEntries(async (batch) => {
+				if (!batch.length) try {
+					resolve(await Promise.all(entries));
+				} catch (err) {
+					reject(err);
+				}
+				else {
+					const items = Promise.all(batch.map(fromEntry));
+					entries.push(items);
+					readEntries();
+				}
+			}, (err) => {
+				reject(err);
+			});
+		}
+		readEntries();
+	});
 }
-// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileEntry
-function fromFileEntry(entry) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve, reject) {
-                    entry.file(function (file) {
-                        var fwp = toFileWithPath(file, entry.fullPath);
-                        resolve(fwp);
-                    }, function (err) {
-                        reject(err);
-                    });
-                })];
-        });
-    });
+async function fromFileEntry(entry) {
+	return new Promise((resolve, reject) => {
+		entry.file((file) => {
+			resolve(toFileWithPath(file, entry.fullPath));
+		}, (err) => {
+			reject(err);
+		});
+	});
 }
 
-var _default = function (file, acceptedFiles) {
-  if (file && acceptedFiles) {
-    var acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(',');
-    var fileName = file.name || '';
-    var mimeType = (file.type || '').toLowerCase();
-    var baseMimeType = mimeType.replace(/\/.*$/, '');
-    return acceptedFilesArray.some(function (type) {
-      var validType = type.trim().toLowerCase();
-
-      if (validType.charAt(0) === '.') {
-        return fileName.toLowerCase().endsWith(validType);
-      } else if (validType.endsWith('/*')) {
-        // This is something like a image/* mime type
-        return baseMimeType === validType.replace(/\/.*$/, '');
-      }
-
-      return mimeType === validType;
-    });
-  }
-
-  return true;
-};
-
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$1(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _slicedToArray$1(arr, i) { return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest$1(); }
-
-function _nonIterableRest$1() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
-
-function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit$1(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles$1(arr) { if (Array.isArray(arr)) return arr; }
-
-var FILE_INVALID_TYPE = 'file-invalid-type';
-var FILE_TOO_LARGE = 'file-too-large';
-var FILE_TOO_SMALL = 'file-too-small';
-var TOO_MANY_FILES = 'too-many-files';
+//#region src/index.ts
+/**
+* Check if the provided file should be accepted by an `<input type="file">`
+* with the given `accept` attribute value.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#attr-accept
+*
+* Inspired by https://github.com/enyo/dropzone.
+*
+* @param file The file to check. When omitted or `null`, the file is accepted.
+* @param acceptedFiles One or more MIME types and/or file extensions, either as
+* a comma-delimited string or an array. When omitted or empty, any file is accepted.
+* @returns `true` if the file matches (or when there is nothing to match against).
+*/
+function accept(file, acceptedFiles) {
+	if (file && acceptedFiles) {
+		const acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(",");
+		if (acceptedFilesArray.length === 0) return true;
+		const fileName = file.name || "";
+		const mimeType = (file.type || "").toLowerCase();
+		const baseMimeType = mimeType.replace(/\/.*$/, "");
+		return acceptedFilesArray.some((type) => {
+			const validType = type.trim().toLowerCase();
+			if (validType.charAt(0) === ".") return fileName.toLowerCase().endsWith(validType);
+			else if (validType.endsWith("/*")) return baseMimeType === validType.replace(/\/.*$/, "");
+			return mimeType === validType;
+		});
+	}
+	return true;
+}
 
-var getInvalidTypeRejectionErr = function getInvalidTypeRejectionErr(accept) {
-  accept = Array.isArray(accept) && accept.length === 1 ? accept[0] : accept;
-  var messageSuffix = Array.isArray(accept) ? "one of ".concat(accept.join(', ')) : accept;
-  return {
-    code: FILE_INVALID_TYPE,
-    message: "File type must be ".concat(messageSuffix)
-  };
-};
-var getTooLargeRejectionErr = function getTooLargeRejectionErr(maxSize) {
-  return {
-    code: FILE_TOO_LARGE,
-    message: "File is larger than ".concat(maxSize, " ").concat(maxSize === 1 ? 'byte' : 'bytes')
-  };
-};
-var getTooSmallRejectionErr = function getTooSmallRejectionErr(minSize) {
-  return {
-    code: FILE_TOO_SMALL,
-    message: "File is smaller than ".concat(minSize, " ").concat(minSize === 1 ? 'byte' : 'bytes')
-  };
+//#region src/utils/index.ts
+const accepts = typeof accept === "function" ? accept : accept.default;
+const FILE_INVALID_TYPE = "file-invalid-type";
+const FILE_TOO_LARGE = "file-too-large";
+const FILE_TOO_SMALL = "file-too-small";
+const TOO_MANY_FILES = "too-many-files";
+function getInvalidTypeRejectionErr(accept = "") {
+	const acceptArr = accept.split(",");
+	const msg = acceptArr.length > 1 ? `one of ${acceptArr.join(", ")}` : acceptArr[0];
+	return {
+		code: FILE_INVALID_TYPE,
+		message: `File type must be ${msg}`
+	};
+}
+const FILE_SIZE_UNITS = [
+	"KB",
+	"MB",
+	"GB",
+	"TB",
+	"PB"
+];
+/**
+* Format a byte count into a human-readable string, e.g. `1111` -> `1.08 KB`.
+* Values below 1 KB are kept in bytes to preserve the singular/plural wording.
+*/
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} ${bytes === 1 ? "byte" : "bytes"}`;
+	let size = bytes / 1024;
+	let unitIndex = 0;
+	while (size >= 1024 && unitIndex < FILE_SIZE_UNITS.length - 1) {
+		size /= 1024;
+		unitIndex++;
+	}
+	return `${Number(size.toFixed(2))} ${FILE_SIZE_UNITS[unitIndex]}`;
+}
+function getTooLargeRejectionErr(maxSize) {
+	return {
+		code: FILE_TOO_LARGE,
+		message: `File is larger than ${formatBytes(maxSize)}`
+	};
+}
+function getTooSmallRejectionErr(minSize) {
+	return {
+		code: FILE_TOO_SMALL,
+		message: `File is smaller than ${formatBytes(minSize)}`
+	};
+}
+const TOO_MANY_FILES_REJECTION = {
+	code: TOO_MANY_FILES,
+	message: "Too many files"
 };
-var TOO_MANY_FILES_REJECTION = {
-  code: TOO_MANY_FILES,
-  message: 'Too many files'
-}; // Firefox versions prior to 53 return a bogus MIME type for every file drag, so dragovers with
-// that MIME type will always be accepted
-
+/**
+* Check if the given file is a DataTransferItem with an empty type.
+*
+* During drag events, browsers may return DataTransferItem objects instead of File objects.
+* Some browsers (e.g., Chrome) return an empty MIME type for certain file types (like .md files)
+* on DataTransferItem during drag events, even though the type is correctly set during drop.
+*/
+function isDataTransferItemWithEmptyType(file) {
+	return file.type === "" && typeof file.getAsFile === "function";
+}
+/**
+* Check if file is accepted.
+*
+* Firefox versions prior to 53 return a bogus MIME type for every file drag,
+* so dragovers with that MIME type will always be accepted.
+*
+* Chrome/other browsers may return an empty MIME type for files during drag events,
+* so we accept those as well (we'll validate properly on drop).
+*/
 function fileAccepted(file, accept) {
-  var isAcceptable = file.type === 'application/x-moz-file' || _default(file, accept);
-  return [isAcceptable, isAcceptable ? null : getInvalidTypeRejectionErr(accept)];
+	const isAcceptable = file.type === "application/x-moz-file" || accepts(file, accept ?? "") || isDataTransferItemWithEmptyType(file);
+	return [isAcceptable, isAcceptable ? null : getInvalidTypeRejectionErr(accept)];
 }
 function fileMatchSize(file, minSize, maxSize) {
-  if (isDefined(file.size)) {
-    if (isDefined(minSize) && isDefined(maxSize)) {
-      if (file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
-      if (file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];
-    } else if (isDefined(minSize) && file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];else if (isDefined(maxSize) && file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
-  }
-
-  return [true, null];
+	if (isDefined(file.size)) {
+		if (isDefined(minSize) && isDefined(maxSize)) {
+			if (file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
+			if (file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];
+		} else if (isDefined(minSize) && file.size < minSize) return [false, getTooSmallRejectionErr(minSize)];
+		else if (isDefined(maxSize) && file.size > maxSize) return [false, getTooLargeRejectionErr(maxSize)];
+	}
+	return [true, null];
 }
-
 function isDefined(value) {
-  return value !== undefined && value !== null;
+	return value !== void 0 && value !== null;
+}
+/**
+* Check if a value is thenable (Promise-like), used to tell a synchronous validator result from an
+* asynchronous one.
+*/
+function isThenable(value) {
+	return value != null && typeof value.then === "function";
+}
+/**
+* Classify a set of dragged files for the `isDragAccept`/`isDragReject`/`isDragUnknown` states.
+*
+* During `dragenter`/`dragover` the browser only exposes `DataTransferItem`s, which carry a MIME
+* `type` but no file name, extension or size (see https://html.spec.whatwg.org/multipage/dnd.html#dndevents).
+* So the drag-time check is deliberately optimistic about anything it can't see:
+*
+* - The custom `validator` is **never** run here. It is typed `(file: File) => ...` and users
+*   routinely read `file.name`/`file.size`, which are `undefined` on a `DataTransferItem` - running
+*   it would throw and abort the whole drag handler (leaving `isDragActive` stuck at `false`).
+*   See https://github.com/react-dropzone/react-dropzone/issues/1408
+* - When a `validator` is configured we therefore can't promise the files are acceptable, so the
+*   verdict is `unknown` rather than a misleading `reject` (or a premature `accept`).
+*   See https://github.com/react-dropzone/react-dropzone/issues/1244
+*
+* The full check (including the `validator`) still runs on drop in {@link fileAccepted}/`setFiles`.
+*/
+function evaluateDragFiles({ files, accept, minSize, maxSize, multiple, maxFiles = 0, validator, getErrorMessage }) {
+	const acceptedFiles = [];
+	const rejections = [];
+	const localizeError = (error, file) => getErrorMessage && typeof File !== "undefined" && file instanceof File ? {
+		...error,
+		message: getErrorMessage(error, file)
+	} : error;
+	files.forEach((file) => {
+		const [accepted, acceptError] = fileAccepted(file, accept);
+		const [sizeMatch, sizeError] = fileMatchSize(file, minSize, maxSize);
+		if (accepted && sizeMatch) acceptedFiles.push(file);
+		else rejections.push({
+			file,
+			errors: [acceptError, sizeError].filter((error) => error != null).map((error) => localizeError(error, file))
+		});
+	});
+	const acceptedFilesLimit = multiple ? maxFiles >= 1 ? maxFiles : Number.POSITIVE_INFINITY : 1;
+	if (acceptedFiles.length > acceptedFilesLimit) acceptedFiles.slice(acceptedFilesLimit).forEach((file) => {
+		rejections.push({
+			file,
+			errors: [localizeError(TOO_MANY_FILES_REJECTION, file)]
+		});
+	});
+	if (rejections.length > 0) return {
+		verdict: "reject",
+		rejections
+	};
+	return {
+		verdict: validator ? "unknown" : "accept",
+		rejections
+	};
 }
-
-function allFilesAccepted(_ref) {
-  var files = _ref.files,
-      accept = _ref.accept,
-      minSize = _ref.minSize,
-      maxSize = _ref.maxSize,
-      multiple = _ref.multiple,
-      maxFiles = _ref.maxFiles;
-
-  if (!multiple && files.length > 1 || multiple && maxFiles >= 1 && files.length > maxFiles) {
-    return false;
-  }
-
-  return files.every(function (file) {
-    var _fileAccepted = fileAccepted(file, accept),
-        _fileAccepted2 = _slicedToArray$1(_fileAccepted, 1),
-        accepted = _fileAccepted2[0];
-
-    var _fileMatchSize = fileMatchSize(file, minSize, maxSize),
-        _fileMatchSize2 = _slicedToArray$1(_fileMatchSize, 1),
-        sizeMatch = _fileMatchSize2[0];
-
-    return accepted && sizeMatch;
-  });
-} // React's synthetic events has event.isPropagationStopped,
-// but to remain compatibility with other libs (Preact) fall back
-// to check event.cancelBubble
-
 function isPropagationStopped(event) {
-  if (typeof event.isPropagationStopped === 'function') {
-    return event.isPropagationStopped();
-  } else if (typeof event.cancelBubble !== 'undefined') {
-    return event.cancelBubble;
-  }
-
-  return false;
+	if (typeof event.isPropagationStopped === "function") return event.isPropagationStopped();
+	else if (typeof event.cancelBubble !== "undefined") return event.cancelBubble;
+	return false;
 }
 function isEvtWithFiles(event) {
-  if (!event.dataTransfer) {
-    return !!event.target && !!event.target.files;
-  } // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/types
-  // https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Recommended_drag_types#file
-
-
-  return Array.prototype.some.call(event.dataTransfer.types, function (type) {
-    return type === 'Files' || type === 'application/x-moz-file';
-  });
+	const dataTransfer = event.dataTransfer ?? event.clipboardData;
+	if (!dataTransfer) return !!event.target && !!event.target.files;
+	return Array.prototype.some.call(dataTransfer.types, (type) => type === "Files" || type === "application/x-moz-file") || Array.prototype.some.call(dataTransfer.items ?? [], isKindFile);
+}
+function isKindFile(item) {
+	return typeof item === "object" && item !== null && item.kind === "file";
 }
-
 function onDocumentDragOver(event) {
-  event.preventDefault();
+	event.preventDefault();
 }
-
 function isIe(userAgent) {
-  return userAgent.indexOf('MSIE') !== -1 || userAgent.indexOf('Trident/') !== -1;
+	return userAgent.indexOf("MSIE") !== -1 || userAgent.indexOf("Trident/") !== -1;
 }
-
 function isEdge(userAgent) {
-  return userAgent.indexOf('Edge/') !== -1;
+	return userAgent.indexOf("Edge/") !== -1;
 }
-
-function isIeOrEdge() {
-  var userAgent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window.navigator.userAgent;
-  return isIe(userAgent) || isEdge(userAgent);
+function isIeOrEdge(userAgent = window.navigator.userAgent) {
+	return isIe(userAgent) || isEdge(userAgent);
 }
 /**
- * This is intended to be used to compose event handlers
- * They are executed in order until one of them calls `event.isPropagationStopped()`.
- * Note that the check is done on the first invoke too,
- * meaning that if propagation was stopped before invoking the fns,
- * no handlers will be executed.
- *
- * @param {Function} fns the event hanlder functions
- * @return {Function} the event handler to add to an element
- */
-
-function composeEventHandlers() {
-  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
-    fns[_key] = arguments[_key];
-  }
-
-  return function (event) {
-    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      args[_key2 - 1] = arguments[_key2];
-    }
-
-    return fns.some(function (fn) {
-      if (!isPropagationStopped(event) && fn) {
-        fn.apply(void 0, [event].concat(args));
-      }
-
-      return isPropagationStopped(event);
-    });
-  };
+* This is intended to be used to compose event handlers.
+* They are executed in order until one of them calls `event.isPropagationStopped()`.
+* Note that the check is done on the first invoke too,
+* meaning that if propagation was stopped before invoking the fns,
+* no handlers will be executed.
+*/
+function composeEventHandlers(...fns) {
+	return (event, ...args) => fns.some((fn) => {
+		if (!isPropagationStopped(event) && fn) fn(event, ...args);
+		return isPropagationStopped(event);
+	});
 }
 /**
- * canUseFileSystemAccessAPI checks if the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API)
- * is supported by the browser.
- * @returns {boolean}
- */
-
+* canUseFileSystemAccessAPI checks if the File System Access API is supported by the browser.
+*/
 function canUseFileSystemAccessAPI() {
-  return 'showOpenFilePicker' in window;
+	return "showOpenFilePicker" in window;
 }
 /**
- * filePickerOptionsTypes returns the {types} option for https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker
- * based on the accept attr (see https://github.com/react-dropzone/attr-accept)
- * E.g: converts ['image/*', 'text/*'] to {'image/*': [], 'text/*': []}
- * @param {string|string[]} accept
- */
-
-function filePickerOptionsTypes(accept) {
-  accept = typeof accept === 'string' ? accept.split(',') : accept;
-  return [{
-    description: 'everything',
-    // TODO: Need to handle filtering more elegantly than this!
-    accept: Array.isArray(accept) // Accept just MIME types as per spec
-    // NOTE: accept can be https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#unique_file_type_specifiers
-    ? accept.filter(function (item) {
-      return item === 'audio/*' || item === 'video/*' || item === 'image/*' || item === 'text/*' || /\w+\/[-+.\w]+/g.test(item);
-    }).reduce(function (a, b) {
-      return _objectSpread$1(_objectSpread$1({}, a), {}, _defineProperty$1({}, b, []));
-    }, {}) : {}
-  }];
+* Coerce an `accept` extension value to an array. `window.showOpenFilePicker` allows a single
+* extension string as well as an array, so we accept both and normalize to an array. Anything
+* else (a malformed value) collapses to an empty list.
+*/
+function toExtensions(ext) {
+	if (Array.isArray(ext)) return ext;
+	if (typeof ext === "string") return [ext];
+	return [];
 }
-
-var _excluded = ["children"],
-    _excluded2 = ["open"],
-    _excluded3 = ["refKey", "role", "onKeyDown", "onFocus", "onBlur", "onClick", "onDragEnter", "onDragOver", "onDragLeave", "onDrop"],
-    _excluded4 = ["refKey", "onChange", "onClick"];
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 /**
- * Convenience wrapper component for the `useDropzone` hook
- *
- * ```jsx
- * <Dropzone>
- *   {({getRootProps, getInputProps}) => (
- *     <div {...getRootProps()}>
- *       <input {...getInputProps()} />
- *       <p>Drag 'n' drop some files here, or click to select files</p>
- *     </div>
- *   )}
- * </Dropzone>
- * ```
- */
-
-var Dropzone = /*#__PURE__*/forwardRef(function (_ref, ref) {
-  var children = _ref.children,
-      params = _objectWithoutProperties(_ref, _excluded);
-
-  var _useDropzone = useDropzone(params),
-      open = _useDropzone.open,
-      props = _objectWithoutProperties(_useDropzone, _excluded2);
-
-  useImperativeHandle(ref, function () {
-    return {
-      open: open
-    };
-  }, [open]); // TODO: Figure out why react-styleguidist cannot create docs if we don't return a jsx element
-
-  return /*#__PURE__*/React__default.createElement(Fragment, null, children(_objectSpread(_objectSpread({}, props), {}, {
-    open: open
-  })));
-});
-Dropzone.displayName = 'Dropzone'; // Add default props for react-docgen
-
-var defaultProps = {
-  disabled: false,
-  getFilesFromEvent: fromEvent,
-  maxSize: Infinity,
-  minSize: 0,
-  multiple: true,
-  maxFiles: 0,
-  preventDropOnDocument: true,
-  noClick: false,
-  noKeyboard: false,
-  noDrag: false,
-  noDragEventsBubbling: false,
-  validator: null,
-  useFsAccessApi: false
-};
-Dropzone.defaultProps = defaultProps;
-Dropzone.propTypes = {
-  /**
-   * Render function that exposes the dropzone state and prop getter fns
-   *
-   * @param {object} params
-   * @param {Function} params.getRootProps Returns the props you should apply to the root drop container you render
-   * @param {Function} params.getInputProps Returns the props you should apply to hidden file input you render
-   * @param {Function} params.open Open the native file selection dialog
-   * @param {boolean} params.isFocused Dropzone area is in focus
-   * @param {boolean} params.isFileDialogActive File dialog is opened
-   * @param {boolean} params.isDragActive Active drag is in progress
-   * @param {boolean} params.isDragAccept Dragged files are accepted
-   * @param {boolean} params.isDragReject Some dragged files are rejected
-   * @param {File[]} params.draggedFiles Files in active drag
-   * @param {File[]} params.acceptedFiles Accepted files
-   * @param {FileRejection[]} params.fileRejections Rejected files and why they were rejected
-   */
-  children: PropTypes.func,
-
-  /**
-   * Set accepted file types.
-   * See https://github.com/okonet/attr-accept for more information.
-   * Keep in mind that mime type determination is not reliable across platforms. CSV files,
-   * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under
-   * Windows. In some cases there might not be a mime type set at all.
-   * See: https://github.com/react-dropzone/react-dropzone/issues/276
-   */
-  accept: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
-
-  /**
-   * Allow drag 'n' drop (or selection from the file dialog) of multiple files
-   */
-  multiple: PropTypes.bool,
-
-  /**
-   * If false, allow dropped items to take over the current browser window
-   */
-  preventDropOnDocument: PropTypes.bool,
-
-  /**
-   * If true, disables click to open the native file selection dialog
-   */
-  noClick: PropTypes.bool,
-
-  /**
-   * If true, disables SPACE/ENTER to open the native file selection dialog.
-   * Note that it also stops tracking the focus state.
-   */
-  noKeyboard: PropTypes.bool,
-
-  /**
-   * If true, disables drag 'n' drop
-   */
-  noDrag: PropTypes.bool,
-
-  /**
-   * If true, stops drag event propagation to parents
-   */
-  noDragEventsBubbling: PropTypes.bool,
-
-  /**
-   * Minimum file size (in bytes)
-   */
-  minSize: PropTypes.number,
-
-  /**
-   * Maximum file size (in bytes)
-   */
-  maxSize: PropTypes.number,
-
-  /**
-   * Maximum accepted number of files
-   * The default value is 0 which means there is no limitation to how many files are accepted.
-   */
-  maxFiles: PropTypes.number,
-
-  /**
-   * Enable/disable the dropzone
-   */
-  disabled: PropTypes.bool,
-
-  /**
-   * Use this to provide a custom file aggregator
-   *
-   * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
-   */
-  getFilesFromEvent: PropTypes.func,
-
-  /**
-   * Cb for when closing the file dialog with no selection
-   */
-  onFileDialogCancel: PropTypes.func,
-
-  /**
-   * Cb for when opening the file dialog
-   */
-  onFileDialogOpen: PropTypes.func,
-
-  /**
-   * Set to true to use the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API
-   * to open the file picker instead of using an `<input type="file">` click event.
-   */
-  useFsAccessApi: PropTypes.bool,
-
-  /**
-   * Cb for when the `dragenter` event occurs.
-   *
-   * @param {DragEvent} event
-   */
-  onDragEnter: PropTypes.func,
-
-  /**
-   * Cb for when the `dragleave` event occurs
-   *
-   * @param {DragEvent} event
-   */
-  onDragLeave: PropTypes.func,
-
-  /**
-   * Cb for when the `dragover` event occurs
-   *
-   * @param {DragEvent} event
-   */
-  onDragOver: PropTypes.func,
-
-  /**
-   * Cb for when the `drop` event occurs.
-   * Note that this callback is invoked after the `getFilesFromEvent` callback is done.
-   *
-   * Files are accepted or rejected based on the `accept`, `multiple`, `minSize` and `maxSize` props.
-   * `accept` must be a valid [MIME type](http://www.iana.org/assignments/media-types/media-types.xhtml) according to [input element specification](https://www.w3.org/wiki/HTML/Elements/input/file) or a valid file extension.
-   * If `multiple` is set to false and additional files are dropped,
-   * all files besides the first will be rejected.
-   * Any file which does not have a size in the [`minSize`, `maxSize`] range, will be rejected as well.
-   *
-   * Note that the `onDrop` callback will always be invoked regardless if the dropped files were accepted or rejected.
-   * If you'd like to react to a specific scenario, use the `onDropAccepted`/`onDropRejected` props.
-   *
-   * `onDrop` will provide you with an array of [File](https://developer.mozilla.org/en-US/docs/Web/API/File) objects which you can then process and send to a server.
-   * For example, with [SuperAgent](https://github.com/visionmedia/superagent) as a http/ajax library:
-   *
-   * ```js
-   * function onDrop(acceptedFiles) {
-   *   const req = request.post('/upload')
-   *   acceptedFiles.forEach(file => {
-   *     req.attach(file.name, file)
-   *   })
-   *   req.end(callback)
-   * }
-   * ```
-   *
-   * @param {File[]} acceptedFiles
-   * @param {FileRejection[]} fileRejections
-   * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
-   */
-  onDrop: PropTypes.func,
-
-  /**
-   * Cb for when the `drop` event occurs.
-   * Note that if no files are accepted, this callback is not invoked.
-   *
-   * @param {File[]} files
-   * @param {(DragEvent|Event)} event
-   */
-  onDropAccepted: PropTypes.func,
-
-  /**
-   * Cb for when the `drop` event occurs.
-   * Note that if no files are rejected, this callback is not invoked.
-   *
-   * @param {FileRejection[]} fileRejections
-   * @param {(DragEvent|Event)} event
-   */
-  onDropRejected: PropTypes.func,
-
-  /**
-   * Custom validation function
-   * @param {File} file
-   * @returns {FileError|FileError[]}
-   */
-  validator: PropTypes.func
-};
+* Normalize either `accept` form to the internal array of `{description, accept}` groups.
+*
+* - The object form (`{mime: ext}`) becomes a single group; its `description` (which the object
+*   form can't express) is derived from the extensions like any other group.
+* - The array form is passed through; entries missing an `accept` map are dropped.
+*
+* In both cases a missing `description` is filled in later from the group's extensions (see
+* {@link describeAccept}), so the picker always gets the non-empty description it requires
+* (https://crbug.com/1264708). Returns `undefined` when no `accept` is provided.
+*/
+function normalizeAcceptGroups(accept) {
+	if (!isDefined(accept)) return;
+	if (Array.isArray(accept)) return accept.filter((group) => isDefined(group) && isDefined(group.accept));
+	return [{ accept }];
+}
 /**
- * A function that is invoked for the `dragenter`,
- * `dragover` and `dragleave` events.
- * It is not invoked if the items are not files (such as link, text, etc.).
- *
- * @callback dragCb
- * @param {DragEvent} event
- */
-
+* Build a human-readable label for a picker group from its (validated) accept map, used when the
+* caller doesn't supply a `description`. Prefer the file extensions, fall back to the MIME types,
+* then to a generic label - `showOpenFilePicker` requires a non-empty description (crbug 1264708).
+*/
+function describeAccept(accept) {
+	const extensions = [];
+	const mimeTypes = Object.keys(accept);
+	for (const ext of Object.values(accept)) for (const e of toExtensions(ext)) if (!extensions.includes(e)) extensions.push(e);
+	if (extensions.length > 0) return extensions.join(", ");
+	if (mimeTypes.length > 0) return mimeTypes.join(", ");
+	return "Files";
+}
 /**
- * A function that is invoked for the `drop` or input change event.
- * It is not invoked if the items are not files (such as link, text, etc.).
- *
- * @callback dropCb
- * @param {File[]} acceptedFiles List of accepted files
- * @param {FileRejection[]} fileRejections List of rejected files and why they were rejected
- * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
- */
-
+* Merge every `accept` group into a single MIME-type -> extensions map. Duplicate MIME keys union
+* their extensions. This flattened map drives the native `<input accept>` attribute and the
+* drag/drop validators, which have no concept of groups or descriptions.
+*/
+function flattenAccept(accept) {
+	const groups = normalizeAcceptGroups(accept);
+	if (!isDefined(groups)) return;
+	const merged = {};
+	for (const group of groups) for (const [mimeType, ext] of Object.entries(group.accept)) {
+		const existing = merged[mimeType] ?? (merged[mimeType] = []);
+		for (const e of toExtensions(ext)) if (!existing.includes(e)) existing.push(e);
+	}
+	return merged;
+}
 /**
- * A function that is invoked for the `drop` or input change event.
- * It is not invoked if the items are files (such as link, text, etc.).
- *
- * @callback dropAcceptedCb
- * @param {File[]} files List of accepted files that meet the given criteria
- * (`accept`, `multiple`, `minSize`, `maxSize`)
- * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
- */
-
+* Convert the `{accept}` dropzone prop to the `{types}` option for showOpenFilePicker.
+*
+* Each group becomes one filter row in the picker. Invalid MIME types / extensions are dropped
+* with a warning; a group left with no valid entries is omitted entirely (showOpenFilePicker
+* rejects an empty `accept`). Returns `undefined` when nothing valid remains.
+*/
+function pickerOptionsFromAccept(accept) {
+	const groups = normalizeAcceptGroups(accept);
+	if (!isDefined(groups)) return;
+	const options = groups.map((group) => {
+		const acceptForPicker = Object.entries(group.accept).filter(([mimeType, ext]) => {
+			let ok = true;
+			if (!isMIMEType(mimeType)) {
+				console.warn(`Skipped "${mimeType}" because it is not a valid MIME type. Check https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types for a list of valid MIME types.`);
+				ok = false;
+			}
+			if (!(Array.isArray(ext) || typeof ext === "string") || !toExtensions(ext).every(isExt)) {
+				console.warn(`Skipped "${mimeType}" because an invalid file extension was provided.`);
+				ok = false;
+			}
+			return ok;
+		}).reduce((agg, [mimeType, ext]) => {
+			agg[mimeType] = toExtensions(ext);
+			return agg;
+		}, {});
+		return {
+			description: isDefined(group.description) && group.description !== "" ? group.description : describeAccept(acceptForPicker),
+			accept: acceptForPicker
+		};
+	}).filter((option) => Object.keys(option.accept).length > 0);
+	return options.length > 0 ? options : void 0;
+}
 /**
- * A function that is invoked for the `drop` or input change event.
- *
- * @callback dropRejectedCb
- * @param {File[]} files List of rejected files that do not meet the given criteria
- * (`accept`, `multiple`, `minSize`, `maxSize`)
- * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
- */
-
+* Convert the `{accept}` dropzone prop to a comma-separated accept attribute string.
+*
+* When `omitWildcardMimeTypesWithExtensions` is set, a wildcard MIME type (e.g. `image/*`)
+* that is paired with explicit extensions is dropped in favour of those extensions. The
+* accept attribute is an OR list, so leaving `image/*` in would make both the native file
+* picker and the drop-time validator accept ANY file of that type, ignoring the extension
+* restriction. The drag-time `isDragAccept` check keeps the wildcard because file names
+* (and therefore extensions) aren't readable during a drag.
+*
+* See https://github.com/react-dropzone/react-dropzone/issues/1220
+*/
+function acceptPropAsAcceptAttr(accept, { omitWildcardMimeTypesWithExtensions = false } = {}) {
+	if (isDefined(accept)) return Object.entries(accept).reduce((a, [mimeType, extVal]) => {
+		const ext = toExtensions(extVal);
+		if (omitWildcardMimeTypesWithExtensions && isMIMETypeWildcard(mimeType) && ext.some(isExt)) a.push(...ext);
+		else a.push(mimeType, ...ext);
+		return a;
+	}, []).filter((v) => isMIMEType(v) || isExt(v)).join(",");
+}
 /**
- * A function that is used aggregate files,
- * in a asynchronous fashion, from drag or input change events.
- *
- * @callback getFilesFromEvent
- * @param {(DragEvent|Event)} event A drag event or input change event (if files were selected via the file dialog)
- * @returns {(File[]|Promise<File[]>)}
- */
-
+* Check if v is an exception caused by aborting a request (e.g window.showOpenFilePicker()).
+*/
+function isAbort(v) {
+	return v instanceof DOMException && (v.name === "AbortError" || v.code === v.ABORT_ERR);
+}
 /**
- * An object with the current dropzone state and some helper functions.
- *
- * @typedef {object} DropzoneState
- * @property {Function} getRootProps Returns the props you should apply to the root drop container you render
- * @property {Function} getInputProps Returns the props you should apply to hidden file input you render
- * @property {Function} open Open the native file selection dialog
- * @property {boolean} isFocused Dropzone area is in focus
- * @property {boolean} isFileDialogActive File dialog is opened
- * @property {boolean} isDragActive Active drag is in progress
- * @property {boolean} isDragAccept Dragged files are accepted
- * @property {boolean} isDragReject Some dragged files are rejected
- * @property {File[]} draggedFiles Files in active drag
- * @property {File[]} acceptedFiles Accepted files
- * @property {FileRejection[]} fileRejections Rejected files and why they were rejected
- */
-
-var initialState = {
-  isFocused: false,
-  isFileDialogActive: false,
-  isDragActive: false,
-  isDragAccept: false,
-  isDragReject: false,
-  draggedFiles: [],
-  acceptedFiles: [],
-  fileRejections: []
+* Check if v is a security error.
+*/
+function isSecurityError(v) {
+	return v instanceof DOMException && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
+}
+/**
+* Check if v is a "not allowed" error.
+*
+* Some browsers/configurations block `window.showOpenFilePicker()` outright and reject with a
+* `NotAllowedError` instead of showing the picker (e.g. Microsoft Edge for Business, or other
+* restrictive enterprise/security policies). We treat this like a security error and fall back
+* to the native `<input>`. See https://github.com/react-dropzone/react-dropzone/issues/1429
+*/
+function isNotAllowedError(v) {
+	return v instanceof DOMException && v.name === "NotAllowedError";
+}
+/**
+* Check if v is a MIME type string.
+*/
+function isMIMEType(v) {
+	return v === "audio/*" || v === "video/*" || v === "image/*" || v === "text/*" || v === "application/*" || /\w+\/[-+.\w]+/g.test(v);
+}
+/**
+* Check if v is a wildcard MIME type (e.g. `image/*`).
+*/
+function isMIMETypeWildcard(v) {
+	return v.endsWith("/*");
+}
+/**
+* Check if v is a file extension.
+*/
+function isExt(v) {
+	return /^.*\.[\w]+$/.test(v);
+}
+//#endregion
+//#region src/index.tsx
+/**
+* Convenience wrapper component for the `useDropzone` hook
+*
+* ```jsx
+* <Dropzone>
+*   {({getRootProps, getInputProps}) => (
+*     <div {...getRootProps()}>
+*       <input {...getInputProps()} />
+*       <p>Drag 'n' drop some files here, or click to select files</p>
+*     </div>
+*   )}
+* </Dropzone>
+* ```
+*/
+const Dropzone = forwardRef(({ children, ...params }, ref) => {
+	const { open, ...props } = useDropzone(params);
+	useImperativeHandle(ref, () => ({ open }), [open]);
+	return /* @__PURE__ */ jsx(Fragment, { children: children?.({
+		...props,
+		open
+	}) });
+});
+Dropzone.displayName = "Dropzone";
+const initialState = {
+	isFocused: false,
+	isFileDialogActive: false,
+	isDragActive: false,
+	isDragAccept: false,
+	isDragReject: false,
+	isDragUnknown: false,
+	isDragGlobal: false,
+	isProcessing: false,
+	acceptedFiles: [],
+	fileRejections: [],
+	dragFileRejections: []
 };
 /**
- * A React hook that creates a drag 'n' drop area.
- *
- * ```jsx
- * function MyDropzone(props) {
- *   const {getRootProps, getInputProps} = useDropzone({
- *     onDrop: acceptedFiles => {
- *       // do something with the File objects, e.g. upload to some server
- *     }
- *   });
- *   return (
- *     <div {...getRootProps()}>
- *       <input {...getInputProps()} />
- *       <p>Drag and drop some files here, or click to select files</p>
- *     </div>
- *   )
- * }
- * ```
- *
- * @function useDropzone
- *
- * @param {object} props
- * @param {string|string[]} [props.accept] Set accepted file types.
- * See https://github.com/okonet/attr-accept for more information.
- * Keep in mind that mime type determination is not reliable across platforms. CSV files,
- * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under
- * Windows. In some cases there might not be a mime type set at all.
- * See: https://github.com/react-dropzone/react-dropzone/issues/276
- * @param {boolean} [props.multiple=true] Allow drag 'n' drop (or selection from the file dialog) of multiple files
- * @param {boolean} [props.preventDropOnDocument=true] If false, allow dropped items to take over the current browser window
- * @param {boolean} [props.noClick=false] If true, disables click to open the native file selection dialog
- * @param {boolean} [props.noKeyboard=false] If true, disables SPACE/ENTER to open the native file selection dialog.
- * Note that it also stops tracking the focus state.
- * @param {boolean} [props.noDrag=false] If true, disables drag 'n' drop
- * @param {boolean} [props.noDragEventsBubbling=false] If true, stops drag event propagation to parents
- * @param {number} [props.minSize=0] Minimum file size (in bytes)
- * @param {number} [props.maxSize=Infinity] Maximum file size (in bytes)
- * @param {boolean} [props.disabled=false] Enable/disable the dropzone
- * @param {getFilesFromEvent} [props.getFilesFromEvent] Use this to provide a custom file aggregator
- * @param {Function} [props.onFileDialogCancel] Cb for when closing the file dialog with no selection
- * @param {boolean} [props.useFsAccessApi] Set to true to use the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API
- * to open the file picker instead of using an `<input type="file">` click event.
- * @param {Function} [props.onFileDialogOpen] Cb for when opening the file dialog
- * @param {dragCb} [props.onDragEnter] Cb for when the `dragenter` event occurs.
- * @param {dragCb} [props.onDragLeave] Cb for when the `dragleave` event occurs
- * @param {dragCb} [props.onDragOver] Cb for when the `dragover` event occurs
- * @param {dropCb} [props.onDrop] Cb for when the `drop` event occurs.
- * Note that this callback is invoked after the `getFilesFromEvent` callback is done.
- *
- * Files are accepted or rejected based on the `accept`, `multiple`, `minSize` and `maxSize` props.
- * `accept` must be a valid [MIME type](http://www.iana.org/assignments/media-types/media-types.xhtml) according to [input element specification](https://www.w3.org/wiki/HTML/Elements/input/file) or a valid file extension.
- * If `multiple` is set to false and additional files are dropped,
- * all files besides the first will be rejected.
- * Any file which does not have a size in the [`minSize`, `maxSize`] range, will be rejected as well.
- *
- * Note that the `onDrop` callback will always be invoked regardless if the dropped files were accepted or rejected.
- * If you'd like to react to a specific scenario, use the `onDropAccepted`/`onDropRejected` props.
- *
- * `onDrop` will provide you with an array of [File](https://developer.mozilla.org/en-US/docs/Web/API/File) objects which you can then process and send to a server.
- * For example, with [SuperAgent](https://github.com/visionmedia/superagent) as a http/ajax library:
- *
- * ```js
- * function onDrop(acceptedFiles) {
- *   const req = request.post('/upload')
- *   acceptedFiles.forEach(file => {
- *     req.attach(file.name, file)
- *   })
- *   req.end(callback)
- * }
- * ```
- * @param {dropAcceptedCb} [props.onDropAccepted]
- * @param {dropRejectedCb} [props.onDropRejected]
- *
- * @returns {DropzoneState}
- */
-
-function useDropzone() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-  var _defaultProps$options = _objectSpread(_objectSpread({}, defaultProps), options),
-      accept = _defaultProps$options.accept,
-      disabled = _defaultProps$options.disabled,
-      getFilesFromEvent = _defaultProps$options.getFilesFromEvent,
-      maxSize = _defaultProps$options.maxSize,
-      minSize = _defaultProps$options.minSize,
-      multiple = _defaultProps$options.multiple,
-      maxFiles = _defaultProps$options.maxFiles,
-      onDragEnter = _defaultProps$options.onDragEnter,
-      onDragLeave = _defaultProps$options.onDragLeave,
-      onDragOver = _defaultProps$options.onDragOver,
-      onDrop = _defaultProps$options.onDrop,
-      onDropAccepted = _defaultProps$options.onDropAccepted,
-      onDropRejected = _defaultProps$options.onDropRejected,
-      onFileDialogCancel = _defaultProps$options.onFileDialogCancel,
-      onFileDialogOpen = _defaultProps$options.onFileDialogOpen,
-      useFsAccessApi = _defaultProps$options.useFsAccessApi,
-      preventDropOnDocument = _defaultProps$options.preventDropOnDocument,
-      noClick = _defaultProps$options.noClick,
-      noKeyboard = _defaultProps$options.noKeyboard,
-      noDrag = _defaultProps$options.noDrag,
-      noDragEventsBubbling = _defaultProps$options.noDragEventsBubbling,
-      validator = _defaultProps$options.validator;
-
-  var onFileDialogOpenCb = useMemo(function () {
-    return typeof onFileDialogOpen === 'function' ? onFileDialogOpen : noop;
-  }, [onFileDialogOpen]);
-  var onFileDialogCancelCb = useMemo(function () {
-    return typeof onFileDialogCancel === 'function' ? onFileDialogCancel : noop;
-  }, [onFileDialogCancel]);
-  var rootRef = useRef(null);
-  var inputRef = useRef(null);
-
-  var _useReducer = useReducer(reducer, initialState),
-      _useReducer2 = _slicedToArray(_useReducer, 2),
-      state = _useReducer2[0],
-      dispatch = _useReducer2[1];
-
-  var isFocused = state.isFocused,
-      isFileDialogActive = state.isFileDialogActive,
-      draggedFiles = state.draggedFiles; // Update file dialog active state when the window is focused on
-
-  var onWindowFocus = function onWindowFocus() {
-    // Execute the timeout only if the file dialog is opened in the browser
-    if (isFileDialogActive) {
-      setTimeout(function () {
-        if (inputRef.current) {
-          var files = inputRef.current.files;
-
-          if (!files.length) {
-            dispatch({
-              type: 'closeDialog'
-            });
-            onFileDialogCancelCb();
-          }
-        }
-      }, 300);
-    }
-  };
-
-  useEffect(function () {
-    if (useFsAccessApi && canUseFileSystemAccessAPI()) {
-      return function () {};
-    }
-
-    window.addEventListener('focus', onWindowFocus, false);
-    return function () {
-      window.removeEventListener('focus', onWindowFocus, false);
-    };
-  }, [inputRef, isFileDialogActive, onFileDialogCancelCb, useFsAccessApi]);
-  var dragTargetsRef = useRef([]);
-
-  var onDocumentDrop = function onDocumentDrop(event) {
-    if (rootRef.current && rootRef.current.contains(event.target)) {
-      // If we intercepted an event for our instance, let it propagate down to the instance's onDrop handler
-      return;
-    }
-
-    event.preventDefault();
-    dragTargetsRef.current = [];
-  };
-
-  useEffect(function () {
-    if (preventDropOnDocument) {
-      document.addEventListener('dragover', onDocumentDragOver, false);
-      document.addEventListener('drop', onDocumentDrop, false);
-    }
-
-    return function () {
-      if (preventDropOnDocument) {
-        document.removeEventListener('dragover', onDocumentDragOver);
-        document.removeEventListener('drop', onDocumentDrop);
-      }
-    };
-  }, [rootRef, preventDropOnDocument]);
-  var onDragEnterCb = useCallback(function (event) {
-    event.preventDefault(); // Persist here because we need the event later after getFilesFromEvent() is done
-
-    event.persist();
-    stopPropagation(event);
-    dragTargetsRef.current = [].concat(_toConsumableArray(dragTargetsRef.current), [event.target]);
-
-    if (isEvtWithFiles(event)) {
-      Promise.resolve(getFilesFromEvent(event)).then(function (draggedFiles) {
-        if (isPropagationStopped(event) && !noDragEventsBubbling) {
-          return;
-        }
-
-        dispatch({
-          draggedFiles: draggedFiles,
-          isDragActive: true,
-          type: 'setDraggedFiles'
-        });
-
-        if (onDragEnter) {
-          onDragEnter(event);
-        }
-      });
-    }
-  }, [getFilesFromEvent, onDragEnter, noDragEventsBubbling]);
-  var onDragOverCb = useCallback(function (event) {
-    event.preventDefault();
-    event.persist();
-    stopPropagation(event);
-    var hasFiles = isEvtWithFiles(event);
-
-    if (hasFiles && event.dataTransfer) {
-      try {
-        event.dataTransfer.dropEffect = 'copy';
-      } catch (_unused) {}
-      /* eslint-disable-line no-empty */
-
-    }
-
-    if (hasFiles && onDragOver) {
-      onDragOver(event);
-    }
-
-    return false;
-  }, [onDragOver, noDragEventsBubbling]);
-  var onDragLeaveCb = useCallback(function (event) {
-    event.preventDefault();
-    event.persist();
-    stopPropagation(event); // Only deactivate once the dropzone and all children have been left
-
-    var targets = dragTargetsRef.current.filter(function (target) {
-      return rootRef.current && rootRef.current.contains(target);
-    }); // Make sure to remove a target present multiple times only once
-    // (Firefox may fire dragenter/dragleave multiple times on the same element)
-
-    var targetIdx = targets.indexOf(event.target);
-
-    if (targetIdx !== -1) {
-      targets.splice(targetIdx, 1);
-    }
-
-    dragTargetsRef.current = targets;
-
-    if (targets.length > 0) {
-      return;
-    }
-
-    dispatch({
-      isDragActive: false,
-      type: 'setDraggedFiles',
-      draggedFiles: []
-    });
-
-    if (isEvtWithFiles(event) && onDragLeave) {
-      onDragLeave(event);
-    }
-  }, [rootRef, onDragLeave, noDragEventsBubbling]);
-  var setFiles = useCallback(function (files, event) {
-    var acceptedFiles = [];
-    var fileRejections = [];
-    files.forEach(function (file) {
-      var _fileAccepted = fileAccepted(file, accept),
-          _fileAccepted2 = _slicedToArray(_fileAccepted, 2),
-          accepted = _fileAccepted2[0],
-          acceptError = _fileAccepted2[1];
-
-      var _fileMatchSize = fileMatchSize(file, minSize, maxSize),
-          _fileMatchSize2 = _slicedToArray(_fileMatchSize, 2),
-          sizeMatch = _fileMatchSize2[0],
-          sizeError = _fileMatchSize2[1];
-
-      var customErrors = validator ? validator(file) : null;
-
-      if (accepted && sizeMatch && !customErrors) {
-        acceptedFiles.push(file);
-      } else {
-        var errors = [acceptError, sizeError];
-
-        if (customErrors) {
-          errors = errors.concat(customErrors);
-        }
-
-        fileRejections.push({
-          file: file,
-          errors: errors.filter(function (e) {
-            return e;
-          })
-        });
-      }
-    });
-
-    if (!multiple && acceptedFiles.length > 1 || multiple && maxFiles >= 1 && acceptedFiles.length > maxFiles) {
-      // Reject everything and empty accepted files
-      acceptedFiles.forEach(function (file) {
-        fileRejections.push({
-          file: file,
-          errors: [TOO_MANY_FILES_REJECTION]
-        });
-      });
-      acceptedFiles.splice(0);
-    }
-
-    dispatch({
-      acceptedFiles: acceptedFiles,
-      fileRejections: fileRejections,
-      type: 'setFiles'
-    });
-
-    if (onDrop) {
-      onDrop(acceptedFiles, fileRejections, event);
-    }
-
-    if (fileRejections.length > 0 && onDropRejected) {
-      onDropRejected(fileRejections, event);
-    }
-
-    if (acceptedFiles.length > 0 && onDropAccepted) {
-      onDropAccepted(acceptedFiles, event);
-    }
-  }, [dispatch, multiple, accept, minSize, maxSize, maxFiles, onDrop, onDropAccepted, onDropRejected, validator]);
-  var onDropCb = useCallback(function (event) {
-    event.preventDefault(); // Persist here because we need the event later after getFilesFromEvent() is done
-
-    event.persist();
-    stopPropagation(event);
-    dragTargetsRef.current = [];
-
-    if (isEvtWithFiles(event)) {
-      Promise.resolve(getFilesFromEvent(event)).then(function (files) {
-        if (isPropagationStopped(event) && !noDragEventsBubbling) {
-          return;
-        }
-
-        setFiles(files, event);
-      });
-    }
-
-    dispatch({
-      type: 'reset'
-    });
-  }, [getFilesFromEvent, setFiles, noDragEventsBubbling]); // Fn for opening the file dialog programmatically
-
-  var openFileDialog = useCallback(function () {
-    if (useFsAccessApi && canUseFileSystemAccessAPI()) {
-      dispatch({
-        type: 'openDialog'
-      });
-      onFileDialogOpenCb(); // https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker
-
-      var opts = {
-        multiple: multiple,
-        types: filePickerOptionsTypes(accept)
-      };
-      window.showOpenFilePicker(opts).then(function (handles) {
-        return getFilesFromEvent(handles);
-      }).then(function (files) {
-        return setFiles(files, null);
-      }).catch(function (e) {
-        return onFileDialogCancelCb(e);
-      }).finally(function () {
-        return dispatch({
-          type: 'closeDialog'
-        });
-      });
-      return;
-    }
-
-    if (inputRef.current) {
-      dispatch({
-        type: 'openDialog'
-      });
-      onFileDialogOpenCb();
-      inputRef.current.value = null;
-      inputRef.current.click();
-    }
-  }, [dispatch, onFileDialogOpenCb, onFileDialogCancelCb, useFsAccessApi, setFiles, accept, multiple]); // Cb to open the file dialog when SPACE/ENTER occurs on the dropzone
-
-  var onKeyDownCb = useCallback(function (event) {
-    // Ignore keyboard events bubbling up the DOM tree
-    if (!rootRef.current || !rootRef.current.isEqualNode(event.target)) {
-      return;
-    }
-
-    if (event.keyCode === 32 || event.keyCode === 13) {
-      event.preventDefault();
-      openFileDialog();
-    }
-  }, [rootRef, inputRef, openFileDialog]); // Update focus state for the dropzone
-
-  var onFocusCb = useCallback(function () {
-    dispatch({
-      type: 'focus'
-    });
-  }, []);
-  var onBlurCb = useCallback(function () {
-    dispatch({
-      type: 'blur'
-    });
-  }, []); // Cb to open the file dialog when click occurs on the dropzone
-
-  var onClickCb = useCallback(function () {
-    if (noClick) {
-      return;
-    } // In IE11/Edge the file-browser dialog is blocking, therefore, use setTimeout()
-    // to ensure React can handle state changes
-    // See: https://github.com/react-dropzone/react-dropzone/issues/450
-
-
-    if (isIeOrEdge()) {
-      setTimeout(openFileDialog, 0);
-    } else {
-      openFileDialog();
-    }
-  }, [inputRef, noClick, openFileDialog]);
-
-  var composeHandler = function composeHandler(fn) {
-    return disabled ? null : fn;
-  };
-
-  var composeKeyboardHandler = function composeKeyboardHandler(fn) {
-    return noKeyboard ? null : composeHandler(fn);
-  };
-
-  var composeDragHandler = function composeDragHandler(fn) {
-    return noDrag ? null : composeHandler(fn);
-  };
-
-  var stopPropagation = function stopPropagation(event) {
-    if (noDragEventsBubbling) {
-      event.stopPropagation();
-    }
-  };
-
-  var getRootProps = useMemo(function () {
-    return function () {
-      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref2$refKey = _ref2.refKey,
-          refKey = _ref2$refKey === void 0 ? 'ref' : _ref2$refKey,
-          role = _ref2.role,
-          onKeyDown = _ref2.onKeyDown,
-          onFocus = _ref2.onFocus,
-          onBlur = _ref2.onBlur,
-          onClick = _ref2.onClick,
-          onDragEnter = _ref2.onDragEnter,
-          onDragOver = _ref2.onDragOver,
-          onDragLeave = _ref2.onDragLeave,
-          onDrop = _ref2.onDrop,
-          rest = _objectWithoutProperties(_ref2, _excluded3);
-
-      return _objectSpread(_objectSpread(_defineProperty({
-        onKeyDown: composeKeyboardHandler(composeEventHandlers(onKeyDown, onKeyDownCb)),
-        onFocus: composeKeyboardHandler(composeEventHandlers(onFocus, onFocusCb)),
-        onBlur: composeKeyboardHandler(composeEventHandlers(onBlur, onBlurCb)),
-        onClick: composeHandler(composeEventHandlers(onClick, onClickCb)),
-        onDragEnter: composeDragHandler(composeEventHandlers(onDragEnter, onDragEnterCb)),
-        onDragOver: composeDragHandler(composeEventHandlers(onDragOver, onDragOverCb)),
-        onDragLeave: composeDragHandler(composeEventHandlers(onDragLeave, onDragLeaveCb)),
-        onDrop: composeDragHandler(composeEventHandlers(onDrop, onDropCb)),
-        role: typeof role === 'string' && role !== '' ? role : 'button'
-      }, refKey, rootRef), !disabled && !noKeyboard ? {
-        tabIndex: 0
-      } : {}), rest);
-    };
-  }, [rootRef, onKeyDownCb, onFocusCb, onBlurCb, onClickCb, onDragEnterCb, onDragOverCb, onDragLeaveCb, onDropCb, noKeyboard, noDrag, disabled]);
-  var onInputElementClick = useCallback(function (event) {
-    event.stopPropagation();
-  }, []);
-  var getInputProps = useMemo(function () {
-    return function () {
-      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref3$refKey = _ref3.refKey,
-          refKey = _ref3$refKey === void 0 ? 'ref' : _ref3$refKey,
-          onChange = _ref3.onChange,
-          onClick = _ref3.onClick,
-          rest = _objectWithoutProperties(_ref3, _excluded4);
-
-      var inputProps = _defineProperty({
-        accept: accept,
-        multiple: multiple,
-        type: 'file',
-        style: {
-          display: 'none'
-        },
-        onChange: composeHandler(composeEventHandlers(onChange, onDropCb)),
-        onClick: composeHandler(composeEventHandlers(onClick, onInputElementClick)),
-        autoComplete: 'off',
-        tabIndex: -1
-      }, refKey, inputRef);
-
-      return _objectSpread(_objectSpread({}, inputProps), rest);
-    };
-  }, [inputRef, accept, multiple, onDropCb, disabled]);
-  var fileCount = draggedFiles.length;
-  var isDragAccept = fileCount > 0 && allFilesAccepted({
-    files: draggedFiles,
-    accept: accept,
-    minSize: minSize,
-    maxSize: maxSize,
-    multiple: multiple,
-    maxFiles: maxFiles
-  });
-  var isDragReject = fileCount > 0 && !isDragAccept;
-  return _objectSpread(_objectSpread({}, state), {}, {
-    isDragAccept: isDragAccept,
-    isDragReject: isDragReject,
-    isFocused: isFocused && !disabled,
-    getRootProps: getRootProps,
-    getInputProps: getInputProps,
-    rootRef: rootRef,
-    inputRef: inputRef,
-    open: composeHandler(openFileDialog)
-  });
+* A React hook that creates a drag 'n' drop area.
+*
+* ```jsx
+* function MyDropzone(props) {
+*   const {getRootProps, getInputProps} = useDropzone({
+*     onDrop: acceptedFiles => {
+*       // do something with the File objects, e.g. upload to some server
+*     }
+*   });
+*   return (
+*     <div {...getRootProps()}>
+*       <input {...getInputProps()} />
+*       <p>Drag and drop some files here, or click to select files</p>
+*     </div>
+*   )
+* }
+* ```
+*/
+function useDropzone(props = {}) {
+	const { accept, disabled = false, getFilesFromEvent = fromEvent, maxSize = Number.POSITIVE_INFINITY, minSize = 0, multiple = true, maxFiles = 0, onDragEnter, onDragLeave, onDragOver, onDrop, onDropAccepted, onDropRejected, onFileDialogCancel, onFileDialogOpen, useFsAccessApi = false, autoFocus = false, preventDropOnDocument = true, noClick = false, noKeyboard = false, noDrag = false, noDragEventsBubbling = false, noPaste = false, onError, validator, getErrorMessage } = props;
+	const flatAccept = useMemo(() => flattenAccept(accept), [accept]);
+	const acceptAttr = useMemo(() => acceptPropAsAcceptAttr(flatAccept), [flatAccept]);
+	const inputAcceptAttr = useMemo(() => acceptPropAsAcceptAttr(flatAccept, { omitWildcardMimeTypesWithExtensions: true }), [flatAccept]);
+	const pickerTypes = useMemo(() => pickerOptionsFromAccept(accept), [accept]);
+	const onFileDialogOpenCb = useMemo(() => typeof onFileDialogOpen === "function" ? onFileDialogOpen : noop, [onFileDialogOpen]);
+	const onFileDialogCancelCb = useMemo(() => typeof onFileDialogCancel === "function" ? onFileDialogCancel : noop, [onFileDialogCancel]);
+	const rootRef = useRef(null);
+	const inputRef = useRef(null);
+	const [state, dispatch] = useReducer(reducer, initialState);
+	const { isFocused, isFileDialogActive } = state;
+	const isFileDialogActiveRef = useRef(isFileDialogActive);
+	isFileDialogActiveRef.current = isFileDialogActive;
+	const processingAbortRef = useRef(null);
+	const beginProcessing = useCallback(() => {
+		processingAbortRef.current?.abort();
+		const controller = new AbortController();
+		processingAbortRef.current = controller;
+		dispatch({
+			type: "setProcessing",
+			isProcessing: true
+		});
+		return controller.signal;
+	}, []);
+	const endProcessing = useCallback((signal) => {
+		if (!signal.aborted) dispatch({
+			type: "setProcessing",
+			isProcessing: false
+		});
+	}, []);
+	const fsAccessApiWorksRef = useRef(typeof window !== "undefined" && window.isSecureContext && useFsAccessApi && canUseFileSystemAccessAPI());
+	const onWindowFocus = () => {
+		if (!fsAccessApiWorksRef.current && isFileDialogActive) setTimeout(() => {
+			if (inputRef.current) {
+				const { files } = inputRef.current;
+				if (!files?.length) {
+					dispatch({ type: "closeDialog" });
+					onFileDialogCancelCb();
+				}
+			}
+		}, 300);
+	};
+	useEffect(() => {
+		window.addEventListener("focus", onWindowFocus, false);
+		return () => {
+			window.removeEventListener("focus", onWindowFocus, false);
+		};
+	}, [
+		inputRef,
+		isFileDialogActive,
+		onFileDialogCancelCb,
+		fsAccessApiWorksRef
+	]);
+	const dragTargetsRef = useRef([]);
+	const globalDragTargetsRef = useRef([]);
+	const onDocumentDrop = (event) => {
+		if (rootRef.current && event.target && rootRef.current.contains(event.target) && event.defaultPrevented) return;
+		event.preventDefault();
+		dragTargetsRef.current = [];
+	};
+	useEffect(() => {
+		if (preventDropOnDocument) {
+			document.addEventListener("dragover", onDocumentDragOver, false);
+			document.addEventListener("drop", onDocumentDrop, false);
+		}
+		return () => {
+			if (preventDropOnDocument) {
+				document.removeEventListener("dragover", onDocumentDragOver);
+				document.removeEventListener("drop", onDocumentDrop);
+			}
+		};
+	}, [rootRef, preventDropOnDocument]);
+	useEffect(() => {
+		const onDocumentDragEnter = (event) => {
+			if (event.target) globalDragTargetsRef.current = [...globalDragTargetsRef.current, event.target];
+			if (isEvtWithFiles(event)) dispatch({
+				isDragGlobal: true,
+				type: "setDragGlobal"
+			});
+		};
+		const onDocumentDragLeave = (event) => {
+			globalDragTargetsRef.current = globalDragTargetsRef.current.filter((el) => el !== event.target && el !== null);
+			if (globalDragTargetsRef.current.length > 0) return;
+			dispatch({
+				isDragGlobal: false,
+				type: "setDragGlobal"
+			});
+		};
+		const onDocumentDragEnd = () => {
+			globalDragTargetsRef.current = [];
+			dispatch({
+				isDragGlobal: false,
+				type: "setDragGlobal"
+			});
+		};
+		const onDocumentDropGlobal = () => {
+			globalDragTargetsRef.current = [];
+			dispatch({
+				isDragGlobal: false,
+				type: "setDragGlobal"
+			});
+		};
+		document.addEventListener("dragenter", onDocumentDragEnter, false);
+		document.addEventListener("dragleave", onDocumentDragLeave, false);
+		document.addEventListener("dragend", onDocumentDragEnd, false);
+		document.addEventListener("drop", onDocumentDropGlobal, false);
+		return () => {
+			document.removeEventListener("dragenter", onDocumentDragEnter);
+			document.removeEventListener("dragleave", onDocumentDragLeave);
+			document.removeEventListener("dragend", onDocumentDragEnd);
+			document.removeEventListener("drop", onDocumentDropGlobal);
+		};
+	}, [rootRef]);
+	useEffect(() => {
+		if (!disabled && autoFocus && rootRef.current) rootRef.current.focus();
+		return () => {};
+	}, [
+		rootRef,
+		autoFocus,
+		disabled
+	]);
+	const onErrCb = useCallback((e) => {
+		if (onError) onError(e);
+		else console.error(e);
+	}, [onError]);
+	const onDragEnterCb = useCallback((event) => {
+		event.preventDefault();
+		event.persist?.();
+		stopPropagation(event);
+		if (isFileDialogActiveRef.current) return;
+		dragTargetsRef.current = [...dragTargetsRef.current, event.target];
+		if (isEvtWithFiles(event)) Promise.resolve(getFilesFromEvent(event)).then((files) => {
+			if (isPropagationStopped(event) && !noDragEventsBubbling) return;
+			const evaluation = files.length > 0 ? evaluateDragFiles({
+				files,
+				accept: acceptAttr,
+				minSize,
+				maxSize,
+				multiple,
+				maxFiles,
+				validator,
+				getErrorMessage
+			}) : null;
+			dispatch({
+				isDragAccept: evaluation?.verdict === "accept",
+				isDragReject: evaluation?.verdict === "reject",
+				isDragUnknown: evaluation?.verdict === "unknown",
+				isDragActive: true,
+				dragFileRejections: evaluation?.rejections ?? [],
+				type: "setDraggedFiles"
+			});
+			if (onDragEnter) onDragEnter(event);
+		}).catch((e) => onErrCb(e));
+	}, [
+		getFilesFromEvent,
+		onDragEnter,
+		onErrCb,
+		noDragEventsBubbling,
+		acceptAttr,
+		minSize,
+		maxSize,
+		multiple,
+		maxFiles,
+		validator,
+		getErrorMessage
+	]);
+	const onDragOverCb = useCallback((event) => {
+		event.preventDefault();
+		event.persist?.();
+		stopPropagation(event);
+		if (isFileDialogActiveRef.current) return false;
+		const hasFiles = isEvtWithFiles(event);
+		if (hasFiles && event.dataTransfer) try {
+			event.dataTransfer.dropEffect = "copy";
+		} catch {}
+		if (hasFiles && onDragOver) onDragOver(event);
+		return false;
+	}, [onDragOver, noDragEventsBubbling]);
+	const onDragLeaveCb = useCallback((event) => {
+		event.preventDefault();
+		event.persist?.();
+		stopPropagation(event);
+		const targets = dragTargetsRef.current.filter((target) => rootRef.current?.contains(target));
+		const targetIdx = targets.indexOf(event.target);
+		if (targetIdx !== -1) targets.splice(targetIdx, 1);
+		dragTargetsRef.current = targets;
+		if (targets.length > 0) return;
+		dispatch({
+			type: "setDraggedFiles",
+			isDragActive: false,
+			isDragAccept: false,
+			isDragReject: false,
+			isDragUnknown: false,
+			dragFileRejections: []
+		});
+		if (isEvtWithFiles(event) && onDragLeave) onDragLeave(event);
+	}, [
+		rootRef,
+		onDragLeave,
+		noDragEventsBubbling
+	]);
+	const setFiles = useCallback(async (files, event, signal) => {
+		const localizeError = (error, file) => getErrorMessage ? {
+			...error,
+			message: getErrorMessage(error, file)
+		} : error;
+		const commit = (results) => {
+			const acceptedFiles = [];
+			const fileRejections = [];
+			results.forEach(({ file, accepted, acceptError, sizeMatch, sizeError, customErrors }) => {
+				const valid = !customErrors || Array.isArray(customErrors) && customErrors.length === 0;
+				if (accepted && sizeMatch && valid) acceptedFiles.push(file);
+				else {
+					let errors = [acceptError, sizeError];
+					if (customErrors) errors = errors.concat(customErrors);
+					fileRejections.push({
+						file,
+						errors: errors.filter((e) => e != null).map((error) => localizeError(error, file))
+					});
+				}
+			});
+			const acceptedFilesLimit = multiple ? maxFiles >= 1 ? maxFiles : Number.POSITIVE_INFINITY : 1;
+			if (acceptedFiles.length > acceptedFilesLimit) acceptedFiles.splice(acceptedFilesLimit).forEach((file) => {
+				fileRejections.push({
+					file,
+					errors: [localizeError(TOO_MANY_FILES_REJECTION, file)]
+				});
+			});
+			dispatch({
+				acceptedFiles,
+				fileRejections,
+				type: "setFiles"
+			});
+			if (onDrop) onDrop(acceptedFiles, fileRejections, event);
+			if (fileRejections.length > 0 && onDropRejected) onDropRejected(fileRejections, event);
+			if (acceptedFiles.length > 0 && onDropAccepted) onDropAccepted(acceptedFiles, event);
+		};
+		const pending = files.map((file) => {
+			const [accepted, acceptError] = fileAccepted(file, inputAcceptAttr);
+			const [sizeMatch, sizeError] = fileMatchSize(file, minSize, maxSize);
+			return {
+				file,
+				accepted,
+				acceptError,
+				sizeMatch,
+				sizeError,
+				customErrors: validator ? validator(file) : null
+			};
+		});
+		if (!pending.some(({ customErrors }) => isThenable(customErrors))) {
+			commit(pending);
+			return;
+		}
+		let results;
+		try {
+			results = await Promise.all(pending.map(async ({ customErrors, ...rest }) => ({
+				...rest,
+				customErrors: await customErrors
+			})));
+		} catch (e) {
+			if (!signal.aborted) {
+				endProcessing(signal);
+				onErrCb(e);
+			}
+			return;
+		}
+		if (signal.aborted) return;
+		commit(results);
+	}, [
+		dispatch,
+		multiple,
+		inputAcceptAttr,
+		minSize,
+		maxSize,
+		maxFiles,
+		onDrop,
+		onDropAccepted,
+		onDropRejected,
+		validator,
+		getErrorMessage,
+		onErrCb,
+		endProcessing
+	]);
+	const onDropCb = useCallback((event) => {
+		event.preventDefault();
+		event.persist?.();
+		stopPropagation(event);
+		dragTargetsRef.current = [];
+		if (isFileDialogActiveRef.current && event.dataTransfer) return;
+		dispatch({ type: "reset" });
+		if (isEvtWithFiles(event)) {
+			const signal = beginProcessing();
+			Promise.resolve(getFilesFromEvent(event)).then((files) => {
+				if (signal.aborted) return;
+				if (isPropagationStopped(event) && !noDragEventsBubbling) {
+					endProcessing(signal);
+					return;
+				}
+				return setFiles(files, event, signal);
+			}).catch((e) => {
+				if (!signal.aborted) {
+					endProcessing(signal);
+					onErrCb(e);
+				}
+			});
+		}
+	}, [
+		getFilesFromEvent,
+		setFiles,
+		onErrCb,
+		noDragEventsBubbling,
+		beginProcessing,
+		endProcessing
+	]);
+	const onPasteCb = useCallback((event) => {
+		if (!isEvtWithFiles(event)) return;
+		event.preventDefault();
+		event.persist?.();
+		stopPropagation(event);
+		const signal = beginProcessing();
+		Promise.resolve(getFilesFromEvent(event)).then((files) => {
+			if (signal.aborted) return;
+			if (isPropagationStopped(event) && !noDragEventsBubbling) {
+				endProcessing(signal);
+				return;
+			}
+			return setFiles(files, event, signal);
+		}).catch((e) => {
+			if (!signal.aborted) {
+				endProcessing(signal);
+				onErrCb(e);
+			}
+		});
+	}, [
+		getFilesFromEvent,
+		setFiles,
+		onErrCb,
+		noDragEventsBubbling,
+		beginProcessing,
+		endProcessing
+	]);
+	const openFileDialog = useCallback(() => {
+		if (fsAccessApiWorksRef.current) {
+			dispatch({ type: "openDialog" });
+			onFileDialogOpenCb();
+			const opts = {
+				multiple,
+				types: pickerTypes
+			};
+			let signal;
+			window.showOpenFilePicker(opts).then((handles) => {
+				signal = beginProcessing();
+				return getFilesFromEvent(handles);
+			}).then((files) => {
+				dispatch({ type: "closeDialog" });
+				if (signal.aborted) return;
+				return setFiles(files, null, signal);
+			}).catch((e) => {
+				if (signal) endProcessing(signal);
+				if (isAbort(e)) {
+					onFileDialogCancelCb(e);
+					dispatch({ type: "closeDialog" });
+				} else if (isSecurityError(e) || isNotAllowedError(e)) {
+					fsAccessApiWorksRef.current = false;
+					if (inputRef.current) {
+						inputRef.current.value = "";
+						inputRef.current.click();
+					} else onErrCb(/* @__PURE__ */ new Error("Cannot open the file picker because the https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API is not supported and no <input> was provided."));
+				} else onErrCb(e);
+			});
+			return;
+		}
+		if (inputRef.current) {
+			dispatch({ type: "openDialog" });
+			onFileDialogOpenCb();
+			inputRef.current.value = "";
+			inputRef.current.click();
+		}
+	}, [
+		dispatch,
+		onFileDialogOpenCb,
+		onFileDialogCancelCb,
+		useFsAccessApi,
+		setFiles,
+		onErrCb,
+		pickerTypes,
+		multiple,
+		beginProcessing,
+		endProcessing
+	]);
+	const onKeyDownCb = useCallback((event) => {
+		if (!rootRef.current?.isEqualNode(event.target)) return;
+		if (event.key === " " || event.key === "Enter" || event.keyCode === 32 || event.keyCode === 13) {
+			event.preventDefault();
+			openFileDialog();
+		}
+	}, [rootRef, openFileDialog]);
+	const onFocusCb = useCallback(() => {
+		dispatch({ type: "focus" });
+	}, []);
+	const onBlurCb = useCallback(() => {
+		dispatch({ type: "blur" });
+	}, []);
+	const onClickCb = useCallback(() => {
+		if (noClick) return;
+		if (isIeOrEdge()) setTimeout(openFileDialog, 0);
+		else openFileDialog();
+	}, [noClick, openFileDialog]);
+	const composeHandler = (fn) => {
+		return disabled ? null : fn;
+	};
+	const composeKeyboardHandler = (fn) => {
+		return noKeyboard ? null : composeHandler(fn);
+	};
+	const composeDragHandler = (fn) => {
+		return noDrag ? null : composeHandler(fn);
+	};
+	const composePasteHandler = (fn) => {
+		return noPaste ? null : composeHandler(fn);
+	};
+	const stopPropagation = (event) => {
+		if (noDragEventsBubbling) event.stopPropagation();
+	};
+	const getRootProps = useMemo(() => ({ refKey = "ref", role, onKeyDown, onFocus, onBlur, onClick, onDragEnter, onDragOver, onDragLeave, onDrop, onPaste, ...rest } = {}) => ({
+		onKeyDown: composeKeyboardHandler(composeEventHandlers(onKeyDown, onKeyDownCb)),
+		onFocus: composeKeyboardHandler(composeEventHandlers(onFocus, onFocusCb)),
+		onBlur: composeKeyboardHandler(composeEventHandlers(onBlur, onBlurCb)),
+		onClick: composeHandler(composeEventHandlers(onClick, onClickCb)),
+		onDragEnter: composeDragHandler(composeEventHandlers(onDragEnter, onDragEnterCb)),
+		onDragOver: composeDragHandler(composeEventHandlers(onDragOver, onDragOverCb)),
+		onDragLeave: composeDragHandler(composeEventHandlers(onDragLeave, onDragLeaveCb)),
+		onDrop: composeDragHandler(composeEventHandlers(onDrop, onDropCb)),
+		onPaste: composePasteHandler(composeEventHandlers(onPaste, onPasteCb)),
+		role: typeof role === "string" && role !== "" ? role : "presentation",
+		[refKey]: rootRef,
+		...!disabled && !noKeyboard ? { tabIndex: 0 } : {},
+		...disabled ? { "aria-disabled": true } : {},
+		...rest
+	}), [
+		rootRef,
+		onKeyDownCb,
+		onFocusCb,
+		onBlurCb,
+		onClickCb,
+		onDragEnterCb,
+		onDragOverCb,
+		onDragLeaveCb,
+		onDropCb,
+		onPasteCb,
+		noKeyboard,
+		noDrag,
+		noPaste,
+		disabled
+	]);
+	const onInputElementClick = useCallback((event) => {
+		event.stopPropagation();
+	}, []);
+	const getInputProps = useMemo(() => ({ refKey = "ref", onChange, onClick, ...rest } = {}) => {
+		return {
+			accept: inputAcceptAttr,
+			multiple,
+			type: "file",
+			"aria-label": "file upload",
+			style: {
+				border: 0,
+				display: "block",
+				height: 0,
+				margin: 0,
+				opacity: 0,
+				overflow: "hidden",
+				padding: 0,
+				width: 0
+			},
+			onChange: composeHandler(composeEventHandlers(onChange, onDropCb)),
+			onClick: composeHandler(composeEventHandlers(onClick, onInputElementClick)),
+			tabIndex: -1,
+			[refKey]: inputRef,
+			...rest
+		};
+	}, [
+		inputRef,
+		accept,
+		multiple,
+		onDropCb,
+		disabled
+	]);
+	return {
+		...state,
+		isFocused: isFocused && !disabled,
+		getRootProps,
+		getInputProps,
+		rootRef,
+		inputRef,
+		open: composeHandler(openFileDialog)
+	};
 }
-
 function reducer(state, action) {
-  /* istanbul ignore next */
-  switch (action.type) {
-    case 'focus':
-      return _objectSpread(_objectSpread({}, state), {}, {
-        isFocused: true
-      });
-
-    case 'blur':
-      return _objectSpread(_objectSpread({}, state), {}, {
-        isFocused: false
-      });
-
-    case 'openDialog':
-      return _objectSpread(_objectSpread({}, initialState), {}, {
-        isFileDialogActive: true
-      });
-
-    case 'closeDialog':
-      return _objectSpread(_objectSpread({}, state), {}, {
-        isFileDialogActive: false
-      });
-
-    case 'setDraggedFiles':
-      /* eslint no-case-declarations: 0 */
-      var isDragActive = action.isDragActive,
-          draggedFiles = action.draggedFiles;
-      return _objectSpread(_objectSpread({}, state), {}, {
-        draggedFiles: draggedFiles,
-        isDragActive: isDragActive
-      });
-
-    case 'setFiles':
-      return _objectSpread(_objectSpread({}, state), {}, {
-        acceptedFiles: action.acceptedFiles,
-        fileRejections: action.fileRejections
-      });
-
-    case 'reset':
-      return _objectSpread({}, initialState);
-
-    default:
-      return state;
-  }
+	switch (action.type) {
+		case "focus": return {
+			...state,
+			isFocused: true
+		};
+		case "blur": return {
+			...state,
+			isFocused: false
+		};
+		case "openDialog": return {
+			...initialState,
+			isFileDialogActive: true
+		};
+		case "closeDialog": return {
+			...state,
+			isFileDialogActive: false
+		};
+		case "setDraggedFiles": return {
+			...state,
+			isDragActive: action.isDragActive,
+			isDragAccept: action.isDragAccept,
+			isDragReject: action.isDragReject,
+			isDragUnknown: action.isDragUnknown,
+			dragFileRejections: action.dragFileRejections
+		};
+		case "setProcessing": return {
+			...state,
+			isProcessing: action.isProcessing
+		};
+		case "setFiles": return {
+			...state,
+			acceptedFiles: action.acceptedFiles,
+			fileRejections: action.fileRejections,
+			dragFileRejections: [],
+			isProcessing: false,
+			isDragReject: false,
+			isDragUnknown: false
+		};
+		case "setDragGlobal": return {
+			...state,
+			isDragGlobal: action.isDragGlobal
+		};
+		case "reset": return { ...initialState };
+		default: return state;
+	}
 }
-
 function noop() {}
 
 var styles = {"dropZoneBase":"fSDkYM-382I-","dropZone":"yT6m1v71VK8-","active":"fCb0O1wAjR0-","error":"Cm5wIem0XQI-","validationErrors":"wyjYhAlF1qA-","dropzoneContent":"sAxF04DcAi4-"};
@@ -1532,38 +1313,46 @@ function InputFileValidationErrors({ validationErrors, }) {
     if (validationErrors.length === 0) {
         return null;
     }
-    return (React__default.createElement("div", { className: styles.validationErrors }, validationErrors.map(error => (React__default.createElement(InputValidation, { message: error.message, key: error.code })))));
+    return (React__default.createElement("div", { className: styles.validationErrors }, validationErrors.map((error, index) => (React__default.createElement(InputValidation, { message: error.message, key: `${error.code}-${index}` })))));
 }
 
+const inputFileMessages = defineMessages({
+    fileLimit: {
+        en: {
+            one: "Cannot exceed a maximum of {count} file.",
+            other: "Cannot exceed a maximum of {count} files.",
+        },
+        es: {
+            one: "No se puede superar el máximo de {count} archivo.",
+            other: "No se puede superar el máximo de {count} archivos.",
+        },
+    },
+    uploadFile: {
+        en: "Upload file",
+        es: "Subir archivo",
+    },
+});
+
 /* eslint-disable max-statements */
 function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: providedButtonLabel, allowMultiple = false, allowedTypes = "all", description, hintText, maxFilesValidation, getUploadParams, onUploadStart, onUploadProgress, onUploadComplete, onUploadError, validator, children, }) {
+    const { t, plural } = useAtlantisI18n(inputFileMessages);
     const maxFiles = (maxFilesValidation === null || maxFilesValidation === void 0 ? void 0 : maxFilesValidation.maxFiles) || 0;
     const numberOfCurrentFiles = (maxFilesValidation === null || maxFilesValidation === void 0 ? void 0 : maxFilesValidation.numberOfCurrentFiles) || 0;
-    const handleValidation = useCallback((file) => {
-        if (maxFiles &&
-            numberOfCurrentFiles &&
-            maxFiles - numberOfCurrentFiles <= 0) {
-            return {
-                code: "too-many-files",
-                message: `Cannot exceed a maximum of ${maxFiles} files.`,
-            };
-        }
-        return validator ? validator(file) : null;
-    }, [maxFiles, numberOfCurrentFiles, validator]);
+    const [limitError, setLimitError] = useState();
     const options = {
-        multiple: allowMultiple,
-        maxFiles: maxFiles - numberOfCurrentFiles,
-        onDrop: useCallback(handleDrop, [uploadFile]),
-        validator: handleValidation,
+        // InputFile applies count limits after per-file validation, including single-file drops.
+        multiple: true,
+        onDrop: handleDrop,
+        validator,
     };
     if (allowedTypes === "images") {
-        options.accept = "image/*";
+        options.accept = { "image/*": [] };
     }
     else if (allowedTypes === "basicImages") {
-        options.accept = convertToMimeTypes(BASIC_IMAGE_TYPES).join(",");
+        options.accept = mimeTypesToAccept(convertToMimeTypes(BASIC_IMAGE_TYPES));
     }
     else if (Array.isArray(allowedTypes)) {
-        options.accept = convertToMimeTypes(allowedTypes).join(",");
+        options.accept = mimeTypesToAccept(convertToMimeTypes(allowedTypes));
     }
     const { getRootProps, getInputProps, isDragActive, fileRejections } = useDropzone(options);
     const allowedTypesString = Array.isArray(allowedTypes)
@@ -1571,15 +1360,7 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
         : allowedTypes;
     const validationErrors = fileRejections === null || fileRejections === void 0 ? void 0 : fileRejections.reduce((acc, { file, errors }) => {
         errors.forEach(error => {
-            if (error.code === "too-many-files") {
-                if (!acc.some(e => e.code === "too-many-files")) {
-                    acc.push({
-                        code: "too-many-files",
-                        message: `Cannot exceed a maximum of ${maxFiles} files.`,
-                    });
-                }
-            }
-            else if (error.code === "file-invalid-type") {
+            if (error.code === "file-invalid-type") {
                 let formatMessage;
                 if (allowedTypes === "basicImages") {
                     formatMessage = formatMimeTypes(BASIC_IMAGE_TYPES.map(mimeTypeToReadable));
@@ -1607,10 +1388,12 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
         });
         return acc;
     }, []);
+    if (limitError)
+        validationErrors.push(limitError);
     const dropZone = classnames(styles.dropZoneBase, {
         [styles.dropZone]: variation === "dropzone",
         [styles.active]: isDragActive,
-        [styles.error]: (fileRejections === null || fileRejections === void 0 ? void 0 : fileRejections.length) > 0,
+        [styles.error]: validationErrors.length > 0,
     });
     const fileType = allowedTypes === "images" || allowedTypes === "basicImages"
         ? "Image"
@@ -1632,11 +1415,27 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
                     React__default.createElement(InputFile.Description, null)))))),
         variation === "button" && React__default.createElement(InputFile.Button, { fullWidth: true })));
     return (React__default.createElement(React__default.Fragment, null,
-        React__default.createElement("div", Object.assign({}, getRootProps({ className: dropZone }), { tabIndex: variation === "button" ? -1 : 0 }),
-            React__default.createElement("input", Object.assign({}, getInputProps(), { "data-testid": "input-file-input", name: name })),
+        React__default.createElement("div", Object.assign({}, getRootProps({ className: dropZone, role: "button" }), { tabIndex: variation === "button" ? -1 : 0 }),
+            React__default.createElement("input", Object.assign({}, getInputProps({
+                multiple: allowMultiple,
+                "aria-label": providedButtonLabel || t("uploadFile"),
+            }), { "data-testid": "input-file-input", name: name })),
             React__default.createElement(InputFileContentContext.Provider, { value: contentContext }, children || defaultContent)),
         React__default.createElement(InputFileValidationErrors, { validationErrors: validationErrors })));
     function handleDrop(acceptedFiles) {
+        const remainingCapacity = maxFiles > 0 ? Math.max(0, maxFiles - numberOfCurrentFiles) : Infinity;
+        const capacity = allowMultiple
+            ? remainingCapacity
+            : Math.min(1, remainingCapacity);
+        if (acceptedFiles.length > capacity) {
+            const maximum = allowMultiple || remainingCapacity === 0 ? maxFiles : 1;
+            setLimitError({
+                code: "too-many-files",
+                message: plural("fileLimit", maximum),
+            });
+            return;
+        }
+        setLimitError(undefined);
         acceptedFiles.forEach(file => {
             uploadFile(file);
         });
@@ -1681,6 +1480,9 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
         });
     }
 }
+function mimeTypesToAccept(mimeTypes) {
+    return Object.fromEntries(mimeTypes.map(mimeType => [mimeType, []]));
+}
 function createAxiosConfig({ url, httpMethod = "POST", fields = {}, file, handleUploadProgress, }) {
     let data;
     let headers;