@jobber/components 9.16.7-update-inp-2e263d0.2 → 9.16.7

package/dist/InputFile-cjs.js

@@ -3,1220 +3,1441 @@
 var tslib_es6 = require('./tslib.es6-cjs.js');
 var React = require('react');
 var classnames = require('classnames');
-var jsxRuntime = require('react/jsx-runtime');
+var index = require('./index-cjs.js');
 var axios = require('axios');
 var Text = require('./Text-cjs.js');
 var Button = require('./Button-cjs.js');
 var InputValidation = require('./InputValidation-cjs.js');
 var Content = require('./Content-cjs.js');
 
-//#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"]
+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/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;
-}
-/**
-* 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
-	});
+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;
 }
-//#endregion
-//#region src/file-selector.ts
-const FILES_TO_IGNORE = [".DS_Store", "Thumbs.db"];
+
+var FILES_TO_IGNORE = [
+    // Thumbnail cache files for macOS and Windows
+    '.DS_Store',
+    'Thumbs.db' // Windows
+];
 /**
-* 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 [];
+ * 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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+        return tslib_es6.__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*/, []];
+        });
+    });
 }
 function isDataTransfer(value) {
-	return isObject(value);
-}
-function isClipboardEvt(value) {
-	return isObject(value) && isDataTransfer(value.clipboardData);
+    return isObject(value.dataTransfer);
 }
 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((file) => 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))));
+    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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+        var files;
+        return tslib_es6.__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); })];
+            }
+        });
+    });
 }
-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 getDataTransferFiles(dt, type) {
+    return tslib_es6.__awaiter(this, void 0, void 0, function () {
+        var items, files;
+        return tslib_es6.__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); }))];
+            }
+        });
+    });
 }
 function noIgnoredFiles(files) {
-	return files.filter((file) => FILES_TO_IGNORE.indexOf(file.name) === -1);
+    return files.filter(function (file) { return 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 [];
-	return Array.from(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;
 }
-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);
+// 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);
 }
 function flatten(items) {
-	const result = [];
-	for (const item of items) if (Array.isArray(item)) result.push(...flatten(item));
-	else result.push(item);
-	return result;
+    return items.reduce(function (acc, files) { return tslib_es6.__spread(acc, (Array.isArray(files) ? flatten(files) : [files])); }, []);
 }
-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);
+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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+        return tslib_es6.__generator(this, function (_a) {
+            return [2 /*return*/, entry.isDirectory ? fromDirEntry(entry) : fromFileEntry(entry)];
+        });
+    });
 }
+// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryEntry
 function fromDirEntry(entry) {
-	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();
-	});
+    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 tslib_es6.__awaiter(_this, void 0, void 0, function () {
+                var files, err_1, items;
+                return tslib_es6.__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();
+    });
 }
-async function fromFileEntry(entry) {
-	return new Promise((resolve, reject) => {
-		entry.file((file) => {
-			resolve(toFileWithPath(file, entry.fullPath));
-		}, (err) => {
-			reject(err);
-		});
-	});
+// https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileEntry
+function fromFileEntry(entry) {
+    return tslib_es6.__awaiter(this, void 0, void 0, function () {
+        return tslib_es6.__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);
+                    });
+                })];
+        });
+    });
 }
 
-//#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 _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();
 
-//#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"
+      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;
 };
-/**
-* 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 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';
+
+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')
+  };
+};
+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
+
 function fileAccepted(file, accept) {
-	const isAcceptable = file.type === "application/x-moz-file" || accepts(file, accept ?? "") || isDataTransferItemWithEmptyType(file);
-	return [isAcceptable, isAcceptable ? null : getInvalidTypeRejectionErr(accept)];
+  var isAcceptable = file.type === 'application/x-moz-file' || _default(file, accept);
+  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 !== 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
-	};
+  return value !== undefined && value !== null;
 }
+
+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) {
-	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";
+  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';
+  });
 }
+
 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(userAgent = window.navigator.userAgent) {
-	return isIe(userAgent) || isEdge(userAgent);
+
+function isIeOrEdge() {
+  var userAgent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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.
-*/
-function composeEventHandlers(...fns) {
-	return (event, ...args) => fns.some((fn) => {
-		if (!isPropagationStopped(event) && fn) fn(event, ...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.
+ *
+ * @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);
+    });
+  };
 }
 /**
-* canUseFileSystemAccessAPI checks if the File System Access API is supported by the browser.
-*/
+ * 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}
+ */
+
 function canUseFileSystemAccessAPI() {
-	return "showOpenFilePicker" in window;
-}
-/**
-* 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 [];
+  return 'showOpenFilePicker' in window;
 }
 /**
-* 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 }];
-}
-/**
-* 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";
-}
-/**
-* 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;
-}
-/**
-* 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;
-}
-/**
-* 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(",");
+ * 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, []));
+    }, {}) : {}
+  }];
 }
+
+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; }
 /**
-* 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);
-}
+ * 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__*/React.forwardRef(function (_ref, ref) {
+  var children = _ref.children,
+      params = _objectWithoutProperties(_ref, _excluded);
+
+  var _useDropzone = useDropzone(params),
+      open = _useDropzone.open,
+      props = _objectWithoutProperties(_useDropzone, _excluded2);
+
+  React.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.createElement(React.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: index.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: index.PropTypes.oneOfType([index.PropTypes.string, index.PropTypes.arrayOf(index.PropTypes.string)]),
+
+  /**
+   * Allow drag 'n' drop (or selection from the file dialog) of multiple files
+   */
+  multiple: index.PropTypes.bool,
+
+  /**
+   * If false, allow dropped items to take over the current browser window
+   */
+  preventDropOnDocument: index.PropTypes.bool,
+
+  /**
+   * If true, disables click to open the native file selection dialog
+   */
+  noClick: index.PropTypes.bool,
+
+  /**
+   * If true, disables SPACE/ENTER to open the native file selection dialog.
+   * Note that it also stops tracking the focus state.
+   */
+  noKeyboard: index.PropTypes.bool,
+
+  /**
+   * If true, disables drag 'n' drop
+   */
+  noDrag: index.PropTypes.bool,
+
+  /**
+   * If true, stops drag event propagation to parents
+   */
+  noDragEventsBubbling: index.PropTypes.bool,
+
+  /**
+   * Minimum file size (in bytes)
+   */
+  minSize: index.PropTypes.number,
+
+  /**
+   * Maximum file size (in bytes)
+   */
+  maxSize: index.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: index.PropTypes.number,
+
+  /**
+   * Enable/disable the dropzone
+   */
+  disabled: index.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: index.PropTypes.func,
+
+  /**
+   * Cb for when closing the file dialog with no selection
+   */
+  onFileDialogCancel: index.PropTypes.func,
+
+  /**
+   * Cb for when opening the file dialog
+   */
+  onFileDialogOpen: index.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: index.PropTypes.bool,
+
+  /**
+   * Cb for when the `dragenter` event occurs.
+   *
+   * @param {DragEvent} event
+   */
+  onDragEnter: index.PropTypes.func,
+
+  /**
+   * Cb for when the `dragleave` event occurs
+   *
+   * @param {DragEvent} event
+   */
+  onDragLeave: index.PropTypes.func,
+
+  /**
+   * Cb for when the `dragover` event occurs
+   *
+   * @param {DragEvent} event
+   */
+  onDragOver: index.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: index.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: index.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: index.PropTypes.func,
+
+  /**
+   * Custom validation function
+   * @param {File} file
+   * @returns {FileError|FileError[]}
+   */
+  validator: index.PropTypes.func
+};
 /**
-* Check if v is a security error.
-*/
-function isSecurityError(v) {
-	return v instanceof DOMException && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
-}
+ * 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
+ */
+
 /**
-* 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";
-}
+ * 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)
+ */
+
 /**
-* 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);
-}
+ * 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)
+ */
+
 /**
-* Check if v is a wildcard MIME type (e.g. `image/*`).
-*/
-function isMIMETypeWildcard(v) {
-	return v.endsWith("/*");
-}
+ * 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)
+ */
+
 /**
-* Check if v is a file extension.
-*/
-function isExt(v) {
-	return /^.*\.[\w]+$/.test(v);
-}
-//#endregion
-//#region src/index.tsx
+ * 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[]>)}
+ */
+
 /**
-* 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 = React.forwardRef(({ children, ...params }, ref) => {
-	const { open, ...props } = useDropzone(params);
-	React.useImperativeHandle(ref, () => ({ open }), [open]);
-	return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.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: []
+ * 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: []
 };
 /**
-* 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 = React.useMemo(() => flattenAccept(accept), [accept]);
-	const acceptAttr = React.useMemo(() => acceptPropAsAcceptAttr(flatAccept), [flatAccept]);
-	const inputAcceptAttr = React.useMemo(() => acceptPropAsAcceptAttr(flatAccept, { omitWildcardMimeTypesWithExtensions: true }), [flatAccept]);
-	const pickerTypes = React.useMemo(() => pickerOptionsFromAccept(accept), [accept]);
-	const onFileDialogOpenCb = React.useMemo(() => typeof onFileDialogOpen === "function" ? onFileDialogOpen : noop, [onFileDialogOpen]);
-	const onFileDialogCancelCb = React.useMemo(() => typeof onFileDialogCancel === "function" ? onFileDialogCancel : noop, [onFileDialogCancel]);
-	const rootRef = React.useRef(null);
-	const inputRef = React.useRef(null);
-	const [state, dispatch] = React.useReducer(reducer, initialState);
-	const { isFocused, isFileDialogActive } = state;
-	const isFileDialogActiveRef = React.useRef(isFileDialogActive);
-	isFileDialogActiveRef.current = isFileDialogActive;
-	const processingAbortRef = React.useRef(null);
-	const beginProcessing = React.useCallback(() => {
-		processingAbortRef.current?.abort();
-		const controller = new AbortController();
-		processingAbortRef.current = controller;
-		dispatch({
-			type: "setProcessing",
-			isProcessing: true
-		});
-		return controller.signal;
-	}, []);
-	const endProcessing = React.useCallback((signal) => {
-		if (!signal.aborted) dispatch({
-			type: "setProcessing",
-			isProcessing: false
-		});
-	}, []);
-	const fsAccessApiWorksRef = React.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);
-	};
-	React.useEffect(() => {
-		window.addEventListener("focus", onWindowFocus, false);
-		return () => {
-			window.removeEventListener("focus", onWindowFocus, false);
-		};
-	}, [
-		inputRef,
-		isFileDialogActive,
-		onFileDialogCancelCb,
-		fsAccessApiWorksRef
-	]);
-	const dragTargetsRef = React.useRef([]);
-	const globalDragTargetsRef = React.useRef([]);
-	const onDocumentDrop = (event) => {
-		if (rootRef.current && event.target && rootRef.current.contains(event.target) && event.defaultPrevented) return;
-		event.preventDefault();
-		dragTargetsRef.current = [];
-	};
-	React.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]);
-	React.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]);
-	React.useEffect(() => {
-		if (!disabled && autoFocus && rootRef.current) rootRef.current.focus();
-		return () => {};
-	}, [
-		rootRef,
-		autoFocus,
-		disabled
-	]);
-	const onErrCb = React.useCallback((e) => {
-		if (onError) onError(e);
-		else console.error(e);
-	}, [onError]);
-	const onDragEnterCb = React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.useCallback(() => {
-		dispatch({ type: "focus" });
-	}, []);
-	const onBlurCb = React.useCallback(() => {
-		dispatch({ type: "blur" });
-	}, []);
-	const onClickCb = React.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 = React.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 = React.useCallback((event) => {
-		event.stopPropagation();
-	}, []);
-	const getInputProps = React.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)
-	};
+ * 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 = React.useMemo(function () {
+    return typeof onFileDialogOpen === 'function' ? onFileDialogOpen : noop;
+  }, [onFileDialogOpen]);
+  var onFileDialogCancelCb = React.useMemo(function () {
+    return typeof onFileDialogCancel === 'function' ? onFileDialogCancel : noop;
+  }, [onFileDialogCancel]);
+  var rootRef = React.useRef(null);
+  var inputRef = React.useRef(null);
+
+  var _useReducer = React.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);
+    }
+  };
+
+  React.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 = React.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 = [];
+  };
+
+  React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.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 = React.useCallback(function () {
+    dispatch({
+      type: 'focus'
+    });
+  }, []);
+  var onBlurCb = React.useCallback(function () {
+    dispatch({
+      type: 'blur'
+    });
+  }, []); // Cb to open the file dialog when click occurs on the dropzone
+
+  var onClickCb = React.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 = React.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 = React.useCallback(function (event) {
+    event.stopPropagation();
+  }, []);
+  var getInputProps = React.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)
+  });
 }
+
 function reducer(state, action) {
-	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;
-	}
+  /* 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;
+  }
 }
+
 function noop() {}
 
 var styles = {"dropZoneBase":"fSDkYM-382I-","dropZone":"yT6m1v71VK8-","active":"fCb0O1wAjR0-","error":"Cm5wIem0XQI-","validationErrors":"wyjYhAlF1qA-","dropzoneContent":"sAxF04DcAi4-"};
@@ -1338,13 +1559,13 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
         validator: handleValidation,
     };
     if (allowedTypes === "images") {
-        options.accept = { "image/*": [] };
+        options.accept = "image/*";
     }
     else if (allowedTypes === "basicImages") {
-        options.accept = mimeTypesToAccept(convertToMimeTypes(BASIC_IMAGE_TYPES));
+        options.accept = convertToMimeTypes(BASIC_IMAGE_TYPES).join(",");
     }
     else if (Array.isArray(allowedTypes)) {
-        options.accept = mimeTypesToAccept(convertToMimeTypes(allowedTypes));
+        options.accept = convertToMimeTypes(allowedTypes).join(",");
     }
     const { getRootProps, getInputProps, isDragActive, fileRejections } = useDropzone(options);
     const allowedTypesString = Array.isArray(allowedTypes)
@@ -1417,9 +1638,7 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
             React.createElement("input", Object.assign({}, getInputProps(), { "data-testid": "input-file-input", name: name })),
             React.createElement(InputFileContentContext.Provider, { value: contentContext }, children || defaultContent)),
         React.createElement(InputFileValidationErrors, { validationErrors: validationErrors })));
-    function handleDrop(acceptedFiles, rejectedFiles) {
-        if (rejectedFiles.some(hasTooManyFilesError))
-            return;
+    function handleDrop(acceptedFiles) {
         acceptedFiles.forEach(file => {
             uploadFile(file);
         });
@@ -1464,12 +1683,6 @@ function InputFile({ variation = "dropzone", size = "base", name, buttonLabel: p
         });
     }
 }
-function mimeTypesToAccept(mimeTypes) {
-    return Object.fromEntries(mimeTypes.map(mimeType => [mimeType, []]));
-}
-function hasTooManyFilesError({ errors }) {
-    return errors.some(error => error.code === "too-many-files");
-}
 function createAxiosConfig({ url, httpMethod = "POST", fields = {}, file, handleUploadProgress, }) {
     let data;
     let headers;