@keboola/design 11.0.0 → 11.2.0

package/dist/FileUpload-BRv0TaZk.js

@@ -0,0 +1,2527 @@
+import { __commonJSMin, __toESM } from "./rolldown-runtime-Bdc48AWt.js";
+import { cn } from "./classNames-BzrkDnOD.js";
+import { File, FileSpreadsheet, FileText, Upload, X } from "./icons-Cek151jC.js";
+import { Button } from "./Button-6xBX0nNl.js";
+import React, { Fragment, createContext, forwardRef, use, useCallback, useEffect, useImperativeHandle, useMemo, useReducer, useRef } from "react";
+import { cva } from "class-variance-authority";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/FileUpload/context.ts
+const FileUploadContext = createContext(null);
+const FileUploadProvider = FileUploadContext.Provider;
+const useFileUploadContext = () => {
+	const ctx = use(FileUploadContext);
+	if (ctx === null) throw new Error("FileUpload subcomponents and hooks must be used inside <FileUpload>.");
+	return ctx;
+};
+/**
+* Rejections from the most recent drop, read from the enclosing `FileUpload`. Use it to render
+* your own "why was this refused" copy next to the drop zone — `FileUpload` ships none, because
+* the wording is product copy. Replaced on every drop, so it never goes stale.
+*/
+const useFileUploadRejections = () => useFileUploadContext().dropTarget.rejections;
+//#endregion
+//#region src/components/FileUpload/styles.ts
+const dropZoneVariants = cva([
+	"tw:flex",
+	"tw:flex-col",
+	"tw:items-center",
+	"tw:justify-center",
+	"tw:gap-2",
+	"tw:px-6",
+	"tw:py-10",
+	"tw:text-center",
+	"tw:rounded-lg",
+	"tw:border-2",
+	"tw:border-dashed",
+	"tw:border-input",
+	"tw:bg-background",
+	"tw:text-foreground",
+	"tw:transition-colors",
+	"tw:cursor-pointer",
+	"tw:select-none",
+	"tw:!outline-hidden",
+	"tw:focus-visible:ring-2",
+	"tw:focus-visible:ring-ring/50",
+	"tw:focus-visible:border-primary"
+], {
+	defaultVariants: { state: "idle" },
+	variants: { state: {
+		idle: ["tw:hover:bg-accent", "tw:hover:border-primary"],
+		dragging: ["tw:bg-accent", "tw:border-primary"],
+		disabled: ["tw:opacity-50", "tw:cursor-not-allowed"],
+		error: ["tw:border-destructive", "tw:bg-destructive/5"]
+	} }
+});
+const fileItemVariants = cva([
+	"tw:flex",
+	"tw:items-center",
+	"tw:gap-3",
+	"tw:rounded-md",
+	"tw:border",
+	"tw:border-solid",
+	"tw:px-3",
+	"tw:py-2",
+	"tw:text-sm",
+	"tw:text-foreground"
+], {
+	defaultVariants: { invalid: false },
+	variants: { invalid: {
+		false: ["tw:border-border", "tw:bg-background"],
+		true: ["tw:border-destructive", "tw:bg-destructive/5"]
+	} }
+});
+//#endregion
+//#region src/components/FileUpload/FileUploadDropZone.tsx
+/**
+* Drop-zone target. Defaults to "Drag files here or click to browse" + Upload icon.
+* Pass `children` to fully replace the inner block.
+*/
+const FileUploadDropZone = ({ children, inputId, className, ...rest }) => {
+	const { dropTarget, forcedState, disabled } = useFileUploadContext();
+	const { getRootProps, getInputProps, isDragActive, rejections } = dropTarget;
+	const state = disabled ? "disabled" : forcedState ?? (rejections.length > 0 ? "error" : isDragActive ? "dragging" : "idle");
+	const rootProps = getRootProps({
+		role: "button",
+		...rest
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		...rootProps,
+		"data-slot": "file-upload-dropzone",
+		className: cn(dropZoneVariants({ state }), className),
+		children: [/* @__PURE__ */ jsx("input", { ...getInputProps({ id: inputId }) }), children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Upload, { className: "tw:size-8 tw:text-muted-foreground" }), /* @__PURE__ */ jsx("p", {
+			className: "tw:m-0 tw:text-sm tw:font-medium",
+			children: "Drag files here or click to browse"
+		})] })]
+	});
+};
+//#endregion
+//#region src/components/FileUpload/FileUploadFileList.tsx
+const formatBytes = (bytes) => {
+	if (bytes === 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	const exponent = Math.min(Math.floor(Math.log10(bytes) / 3), units.length - 1);
+	const value = bytes / 1e3 ** exponent;
+	return `${value.toFixed(value >= 10 || exponent === 0 ? 0 : 1)} ${units[exponent]}`;
+};
+const iconForFile = (file) => {
+	if (file.type.startsWith("text/csv") || file.name.endsWith(".csv")) return FileSpreadsheet;
+	if (file.type.startsWith("text/")) return FileText;
+	return File;
+};
+/**
+* Selected-files list. Caller owns the `files` array — pass it back into the list and handle
+* removal via `onRemove`.
+*/
+const FileUploadFileList = ({ files, onRemove, invalid, className, ...rest }) => {
+	if (files.length === 0) return null;
+	const itemClassName = fileItemVariants({ invalid });
+	return /* @__PURE__ */ jsx("ul", {
+		className: cn("tw:m-0 tw:flex tw:list-none tw:flex-col tw:gap-2 tw:p-0", className),
+		...rest,
+		children: files.map((file, index) => {
+			const Icon = iconForFile(file);
+			return /* @__PURE__ */ jsxs("li", {
+				className: itemClassName,
+				children: [
+					/* @__PURE__ */ jsx(Icon, { className: "tw:size-5 tw:shrink-0 tw:text-muted-foreground" }),
+					/* @__PURE__ */ jsxs("div", {
+						className: "tw:flex tw:min-w-0 tw:flex-1 tw:flex-col",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "tw:truncate tw:font-medium",
+							children: file.name
+						}), /* @__PURE__ */ jsx("span", {
+							className: "tw:text-xs tw:text-muted-foreground",
+							children: formatBytes(file.size)
+						})]
+					}),
+					onRemove && /* @__PURE__ */ jsx(Button, {
+						variant: "invisible",
+						size: "icon-sm",
+						"aria-label": `Remove ${file.name}`,
+						onClick: () => onRemove(file, index),
+						children: /* @__PURE__ */ jsx(X, {})
+					})
+				]
+			}, `${file.name}-${index}`);
+		})
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.development.js
+/** @license React v16.13.1
+* react-is.development.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_is_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	(function() {
+		"use strict";
+		var hasSymbol = typeof Symbol === "function" && Symbol.for;
+		var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
+		var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
+		var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
+		var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
+		var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
+		var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
+		var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
+		var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
+		var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
+		var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
+		var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
+		var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
+		var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
+		var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
+		var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
+		var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
+		var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
+		var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
+		function isValidElementType(type) {
+			return typeof type === "string" || typeof type === "function" || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+		}
+		function typeOf(object) {
+			if (typeof object === "object" && object !== null) {
+				var $$typeof = object.$$typeof;
+				switch ($$typeof) {
+					case REACT_ELEMENT_TYPE:
+						var type = object.type;
+						switch (type) {
+							case REACT_ASYNC_MODE_TYPE:
+							case REACT_CONCURRENT_MODE_TYPE:
+							case REACT_FRAGMENT_TYPE:
+							case REACT_PROFILER_TYPE:
+							case REACT_STRICT_MODE_TYPE:
+							case REACT_SUSPENSE_TYPE: return type;
+							default:
+								var $$typeofType = type && type.$$typeof;
+								switch ($$typeofType) {
+									case REACT_CONTEXT_TYPE:
+									case REACT_FORWARD_REF_TYPE:
+									case REACT_LAZY_TYPE:
+									case REACT_MEMO_TYPE:
+									case REACT_PROVIDER_TYPE: return $$typeofType;
+									default: return $$typeof;
+								}
+						}
+					case REACT_PORTAL_TYPE: return $$typeof;
+				}
+			}
+		}
+		var AsyncMode = REACT_ASYNC_MODE_TYPE;
+		var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+		var ContextConsumer = REACT_CONTEXT_TYPE;
+		var ContextProvider = REACT_PROVIDER_TYPE;
+		var Element = REACT_ELEMENT_TYPE;
+		var ForwardRef = REACT_FORWARD_REF_TYPE;
+		var Fragment = REACT_FRAGMENT_TYPE;
+		var Lazy = REACT_LAZY_TYPE;
+		var Memo = REACT_MEMO_TYPE;
+		var Portal = REACT_PORTAL_TYPE;
+		var Profiler = REACT_PROFILER_TYPE;
+		var StrictMode = REACT_STRICT_MODE_TYPE;
+		var Suspense = REACT_SUSPENSE_TYPE;
+		var hasWarnedAboutDeprecatedIsAsyncMode = false;
+		function isAsyncMode(object) {
+			if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+				hasWarnedAboutDeprecatedIsAsyncMode = true;
+				console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+			}
+			return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+		}
+		function isConcurrentMode(object) {
+			return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+		}
+		function isContextConsumer(object) {
+			return typeOf(object) === REACT_CONTEXT_TYPE;
+		}
+		function isContextProvider(object) {
+			return typeOf(object) === REACT_PROVIDER_TYPE;
+		}
+		function isElement(object) {
+			return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		function isForwardRef(object) {
+			return typeOf(object) === REACT_FORWARD_REF_TYPE;
+		}
+		function isFragment(object) {
+			return typeOf(object) === REACT_FRAGMENT_TYPE;
+		}
+		function isLazy(object) {
+			return typeOf(object) === REACT_LAZY_TYPE;
+		}
+		function isMemo(object) {
+			return typeOf(object) === REACT_MEMO_TYPE;
+		}
+		function isPortal(object) {
+			return typeOf(object) === REACT_PORTAL_TYPE;
+		}
+		function isProfiler(object) {
+			return typeOf(object) === REACT_PROFILER_TYPE;
+		}
+		function isStrictMode(object) {
+			return typeOf(object) === REACT_STRICT_MODE_TYPE;
+		}
+		function isSuspense(object) {
+			return typeOf(object) === REACT_SUSPENSE_TYPE;
+		}
+		exports.AsyncMode = AsyncMode;
+		exports.ConcurrentMode = ConcurrentMode;
+		exports.ContextConsumer = ContextConsumer;
+		exports.ContextProvider = ContextProvider;
+		exports.Element = Element;
+		exports.ForwardRef = ForwardRef;
+		exports.Fragment = Fragment;
+		exports.Lazy = Lazy;
+		exports.Memo = Memo;
+		exports.Portal = Portal;
+		exports.Profiler = Profiler;
+		exports.StrictMode = StrictMode;
+		exports.Suspense = Suspense;
+		exports.isAsyncMode = isAsyncMode;
+		exports.isConcurrentMode = isConcurrentMode;
+		exports.isContextConsumer = isContextConsumer;
+		exports.isContextProvider = isContextProvider;
+		exports.isElement = isElement;
+		exports.isForwardRef = isForwardRef;
+		exports.isFragment = isFragment;
+		exports.isLazy = isLazy;
+		exports.isMemo = isMemo;
+		exports.isPortal = isPortal;
+		exports.isProfiler = isProfiler;
+		exports.isStrictMode = isStrictMode;
+		exports.isSuspense = isSuspense;
+		exports.isValidElementType = isValidElementType;
+		exports.typeOf = typeOf;
+	})();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/index.js
+var require_react_is = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_react_is_development();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var require_object_assign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+	function toObject(val) {
+		if (val === null || val === void 0) throw new TypeError("Object.assign cannot be called with null or undefined");
+		return Object(val);
+	}
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) return false;
+			var test1 = /* @__PURE__ */ new String("abc");
+			test1[5] = "de";
+			if (Object.getOwnPropertyNames(test1)[0] === "5") return false;
+			var test2 = {};
+			for (var i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
+			if (Object.getOwnPropertyNames(test2).map(function(n) {
+				return test2[n];
+			}).join("") !== "0123456789") return false;
+			var test3 = {};
+			"abcdefghijklmnopqrst".split("").forEach(function(letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") return false;
+			return true;
+		} catch (err) {
+			return false;
+		}
+	}
+	module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+			for (var key in from) if (hasOwnProperty.call(from, key)) to[key] = from[key];
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) if (propIsEnumerable.call(from, symbols[i])) to[symbols[i]] = from[symbols[i]];
+			}
+		}
+		return to;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/ReactPropTypesSecret.js
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_ReactPropTypesSecret = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/has.js
+var require_has = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.js
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_checkPropTypes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var printWarning = function() {};
+	var ReactPropTypesSecret = require_ReactPropTypesSecret();
+	var loggedTypeFailures = {};
+	var has = require_has();
+	printWarning = function(text) {
+		var message = "Warning: " + text;
+		if (typeof console !== "undefined") console.error(message);
+		try {
+			throw new Error(message);
+		} catch (x) {}
+	};
+	/**
+	* Assert that the values match with the type specs.
+	* Error messages are memorized and will only be shown once.
+	*
+	* @param {object} typeSpecs Map of name to a ReactPropType
+	* @param {object} values Runtime values that need to be type-checked
+	* @param {string} location e.g. "prop", "context", "child context"
+	* @param {string} componentName Name of the component for error messages.
+	* @param {?Function} getStack Returns the component stack.
+	* @private
+	*/
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+		for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
+			var error;
+			try {
+				if (typeof typeSpecs[typeSpecName] !== "function") {
+					var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+					err.name = "Invariant Violation";
+					throw err;
+				}
+				error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+			} catch (ex) {
+				error = ex;
+			}
+			if (error && !(error instanceof Error)) printWarning((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).");
+			if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+				loggedTypeFailures[error.message] = true;
+				var stack = getStack ? getStack() : "";
+				printWarning("Failed " + location + " type: " + error.message + (stack != null ? stack : ""));
+			}
+		}
+	}
+	/**
+	* Resets warning cache when testing.
+	*
+	* @private
+	*/
+	checkPropTypes.resetWarningCache = function() {
+		loggedTypeFailures = {};
+	};
+	module.exports = checkPropTypes;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithTypeCheckers.js
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_factoryWithTypeCheckers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ReactIs = require_react_is();
+	var assign = require_object_assign();
+	var ReactPropTypesSecret = require_ReactPropTypesSecret();
+	var has = require_has();
+	var checkPropTypes = require_checkPropTypes();
+	var printWarning = function() {};
+	printWarning = function(text) {
+		var message = "Warning: " + text;
+		if (typeof console !== "undefined") console.error(message);
+		try {
+			throw new Error(message);
+		} catch (x) {}
+	};
+	function emptyFunctionThatReturnsNull() {
+		return null;
+	}
+	module.exports = function(isValidElement, throwOnDirectAccess) {
+		var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+		var FAUX_ITERATOR_SYMBOL = "@@iterator";
+		/**
+		* Returns the iterator method function contained on the iterable object.
+		*
+		* Be sure to invoke the function with the iterable as context:
+		*
+		*     var iteratorFn = getIteratorFn(myIterable);
+		*     if (iteratorFn) {
+		*       var iterator = iteratorFn.call(myIterable);
+		*       ...
+		*     }
+		*
+		* @param {?object} maybeIterable
+		* @return {?function}
+		*/
+		function getIteratorFn(maybeIterable) {
+			var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+			if (typeof iteratorFn === "function") return iteratorFn;
+		}
+		/**
+		* Collection of methods that allow declaration and validation of props that are
+		* supplied to React components. Example usage:
+		*
+		*   var Props = require('ReactPropTypes');
+		*   var MyArticle = React.createClass({
+		*     propTypes: {
+		*       // An optional string prop named "description".
+		*       description: Props.string,
+		*
+		*       // A required enum prop named "category".
+		*       category: Props.oneOf(['News','Photos']).isRequired,
+		*
+		*       // A prop named "dialog" that requires an instance of Dialog.
+		*       dialog: Props.instanceOf(Dialog).isRequired
+		*     },
+		*     render: function() { ... }
+		*   });
+		*
+		* A more formal specification of how these methods are used:
+		*
+		*   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+		*   decl := ReactPropTypes.{type}(.isRequired)?
+		*
+		* Each and every declaration produces a function with the same signature. This
+		* allows the creation of custom validation functions. For example:
+		*
+		*  var MyLink = React.createClass({
+		*    propTypes: {
+		*      // An optional string or URI prop named "href".
+		*      href: function(props, propName, componentName) {
+		*        var propValue = props[propName];
+		*        if (propValue != null && typeof propValue !== 'string' &&
+		*            !(propValue instanceof URI)) {
+		*          return new Error(
+		*            'Expected a string or an URI for ' + propName + ' in ' +
+		*            componentName
+		*          );
+		*        }
+		*      }
+		*    },
+		*    render: function() {...}
+		*  });
+		*
+		* @internal
+		*/
+		var ANONYMOUS = "<<anonymous>>";
+		var ReactPropTypes = {
+			array: createPrimitiveTypeChecker("array"),
+			bigint: createPrimitiveTypeChecker("bigint"),
+			bool: createPrimitiveTypeChecker("boolean"),
+			func: createPrimitiveTypeChecker("function"),
+			number: createPrimitiveTypeChecker("number"),
+			object: createPrimitiveTypeChecker("object"),
+			string: createPrimitiveTypeChecker("string"),
+			symbol: createPrimitiveTypeChecker("symbol"),
+			any: createAnyTypeChecker(),
+			arrayOf: createArrayOfTypeChecker,
+			element: createElementTypeChecker(),
+			elementType: createElementTypeTypeChecker(),
+			instanceOf: createInstanceTypeChecker,
+			node: createNodeChecker(),
+			objectOf: createObjectOfTypeChecker,
+			oneOf: createEnumTypeChecker,
+			oneOfType: createUnionTypeChecker,
+			shape: createShapeTypeChecker,
+			exact: createStrictShapeTypeChecker
+		};
+		/**
+		* inlined Object.is polyfill to avoid requiring consumers ship their own
+		* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+		*/
+		function is(x, y) {
+			if (x === y) return x !== 0 || 1 / x === 1 / y;
+			else return x !== x && y !== y;
+		}
+		/**
+		* We use an Error-like object for backward compatibility as people may call
+		* PropTypes directly and inspect their output. However, we don't use real
+		* Errors anymore. We don't inspect their stack anyway, and creating them
+		* is prohibitively expensive if they are created too often, such as what
+		* happens in oneOfType() for any type before the one that matched.
+		*/
+		function PropTypeError(message, data) {
+			this.message = message;
+			this.data = data && typeof data === "object" ? data : {};
+			this.stack = "";
+		}
+		PropTypeError.prototype = Error.prototype;
+		function createChainableTypeChecker(validate) {
+			var manualPropTypeCallCache = {};
+			var manualPropTypeWarningCount = 0;
+			function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+				componentName = componentName || ANONYMOUS;
+				propFullName = propFullName || propName;
+				if (secret !== ReactPropTypesSecret) {
+					if (throwOnDirectAccess) {
+						var err = /* @__PURE__ */ new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types");
+						err.name = "Invariant Violation";
+						throw err;
+					} else if (typeof console !== "undefined") {
+						var cacheKey = componentName + ":" + propName;
+						if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
+							printWarning("You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details.");
+							manualPropTypeCallCache[cacheKey] = true;
+							manualPropTypeWarningCount++;
+						}
+					}
+				}
+				if (props[propName] == null) {
+					if (isRequired) {
+						if (props[propName] === null) return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
+						return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
+					}
+					return null;
+				} else return validate(props, propName, componentName, location, propFullName);
+			}
+			var chainedCheckType = checkType.bind(null, false);
+			chainedCheckType.isRequired = checkType.bind(null, true);
+			return chainedCheckType;
+		}
+		function createPrimitiveTypeChecker(expectedType) {
+			function validate(props, propName, componentName, location, propFullName, secret) {
+				var propValue = props[propName];
+				if (getPropType(propValue) !== expectedType) {
+					var preciseType = getPreciseType(propValue);
+					return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."), { expectedType });
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createAnyTypeChecker() {
+			return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+		}
+		function createArrayOfTypeChecker(typeChecker) {
+			function validate(props, propName, componentName, location, propFullName) {
+				if (typeof typeChecker !== "function") return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
+				var propValue = props[propName];
+				if (!Array.isArray(propValue)) {
+					var propType = getPropType(propValue);
+					return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
+				}
+				for (var i = 0; i < propValue.length; i++) {
+					var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
+					if (error instanceof Error) return error;
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createElementTypeChecker() {
+			function validate(props, propName, componentName, location, propFullName) {
+				var propValue = props[propName];
+				if (!isValidElement(propValue)) {
+					var propType = getPropType(propValue);
+					return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createElementTypeTypeChecker() {
+			function validate(props, propName, componentName, location, propFullName) {
+				var propValue = props[propName];
+				if (!ReactIs.isValidElementType(propValue)) {
+					var propType = getPropType(propValue);
+					return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createInstanceTypeChecker(expectedClass) {
+			function validate(props, propName, componentName, location, propFullName) {
+				if (!(props[propName] instanceof expectedClass)) {
+					var expectedClassName = expectedClass.name || ANONYMOUS;
+					var actualClassName = getClassName(props[propName]);
+					return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createEnumTypeChecker(expectedValues) {
+			if (!Array.isArray(expectedValues)) {
+				if (arguments.length > 1) printWarning("Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).");
+				else printWarning("Invalid argument supplied to oneOf, expected an array.");
+				return emptyFunctionThatReturnsNull;
+			}
+			function validate(props, propName, componentName, location, propFullName) {
+				var propValue = props[propName];
+				for (var i = 0; i < expectedValues.length; i++) if (is(propValue, expectedValues[i])) return null;
+				var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+					if (getPreciseType(value) === "symbol") return String(value);
+					return value;
+				});
+				return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createObjectOfTypeChecker(typeChecker) {
+			function validate(props, propName, componentName, location, propFullName) {
+				if (typeof typeChecker !== "function") return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
+				var propValue = props[propName];
+				var propType = getPropType(propValue);
+				if (propType !== "object") return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
+				for (var key in propValue) if (has(propValue, key)) {
+					var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+					if (error instanceof Error) return error;
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createUnionTypeChecker(arrayOfTypeCheckers) {
+			if (!Array.isArray(arrayOfTypeCheckers)) {
+				printWarning("Invalid argument supplied to oneOfType, expected an instance of array.");
+				return emptyFunctionThatReturnsNull;
+			}
+			for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+				var checker = arrayOfTypeCheckers[i];
+				if (typeof checker !== "function") {
+					printWarning("Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + ".");
+					return emptyFunctionThatReturnsNull;
+				}
+			}
+			function validate(props, propName, componentName, location, propFullName) {
+				var expectedTypes = [];
+				for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+					var checker = arrayOfTypeCheckers[i];
+					var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+					if (checkerResult == null) return null;
+					if (checkerResult.data && has(checkerResult.data, "expectedType")) expectedTypes.push(checkerResult.data.expectedType);
+				}
+				var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
+				return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createNodeChecker() {
+			function validate(props, propName, componentName, location, propFullName) {
+				if (!isNode(props[propName])) return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function invalidValidatorError(componentName, location, propFullName, key, type) {
+			return new PropTypeError((componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`.");
+		}
+		function createShapeTypeChecker(shapeTypes) {
+			function validate(props, propName, componentName, location, propFullName) {
+				var propValue = props[propName];
+				var propType = getPropType(propValue);
+				if (propType !== "object") return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+				for (var key in shapeTypes) {
+					var checker = shapeTypes[key];
+					if (typeof checker !== "function") return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+					var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+					if (error) return error;
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function createStrictShapeTypeChecker(shapeTypes) {
+			function validate(props, propName, componentName, location, propFullName) {
+				var propValue = props[propName];
+				var propType = getPropType(propValue);
+				if (propType !== "object") return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+				for (var key in assign({}, props[propName], shapeTypes)) {
+					var checker = shapeTypes[key];
+					if (has(shapeTypes, key) && typeof checker !== "function") return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+					if (!checker) return new PropTypeError("Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  "));
+					var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+					if (error) return error;
+				}
+				return null;
+			}
+			return createChainableTypeChecker(validate);
+		}
+		function isNode(propValue) {
+			switch (typeof propValue) {
+				case "number":
+				case "string":
+				case "undefined": return true;
+				case "boolean": return !propValue;
+				case "object":
+					if (Array.isArray(propValue)) return propValue.every(isNode);
+					if (propValue === null || isValidElement(propValue)) return true;
+					var iteratorFn = getIteratorFn(propValue);
+					if (iteratorFn) {
+						var iterator = iteratorFn.call(propValue);
+						var step;
+						if (iteratorFn !== propValue.entries) {
+							while (!(step = iterator.next()).done) if (!isNode(step.value)) return false;
+						} else while (!(step = iterator.next()).done) {
+							var entry = step.value;
+							if (entry) {
+								if (!isNode(entry[1])) return false;
+							}
+						}
+					} else return false;
+					return true;
+				default: return false;
+			}
+		}
+		function isSymbol(propType, propValue) {
+			if (propType === "symbol") return true;
+			if (!propValue) return false;
+			if (propValue["@@toStringTag"] === "Symbol") return true;
+			if (typeof Symbol === "function" && propValue instanceof Symbol) return true;
+			return false;
+		}
+		function getPropType(propValue) {
+			var propType = typeof propValue;
+			if (Array.isArray(propValue)) return "array";
+			if (propValue instanceof RegExp) return "object";
+			if (isSymbol(propType, propValue)) return "symbol";
+			return propType;
+		}
+		function getPreciseType(propValue) {
+			if (typeof propValue === "undefined" || propValue === null) return "" + propValue;
+			var propType = getPropType(propValue);
+			if (propType === "object") {
+				if (propValue instanceof Date) return "date";
+				else if (propValue instanceof RegExp) return "regexp";
+			}
+			return propType;
+		}
+		function getPostfixForTypeWarning(value) {
+			var type = getPreciseType(value);
+			switch (type) {
+				case "array":
+				case "object": return "an " + type;
+				case "boolean":
+				case "date":
+				case "regexp": return "a " + type;
+				default: return type;
+			}
+		}
+		function getClassName(propValue) {
+			if (!propValue.constructor || !propValue.constructor.name) return ANONYMOUS;
+			return propValue.constructor.name;
+		}
+		ReactPropTypes.checkPropTypes = checkPropTypes;
+		ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+		ReactPropTypes.PropTypes = ReactPropTypes;
+		return ReactPropTypes;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/index.js
+var require_prop_types = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ReactIs = require_react_is();
+	module.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, true);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+function __awaiter(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+}
+function __generator(thisArg, body) {
+	var _ = {
+		label: 0,
+		sent: function() {
+			if (t[0] & 1) throw t[1];
+			return t[1];
+		},
+		trys: [],
+		ops: []
+	}, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+	return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+		return this;
+	}), g;
+	function verb(n) {
+		return function(v) {
+			return step([n, v]);
+		};
+	}
+	function step(op) {
+		if (f) throw new TypeError("Generator is already executing.");
+		while (g && (g = 0, op[0] && (_ = 0)), _) try {
+			if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+			if (y = 0, t) op = [op[0] & 2, t.value];
+			switch (op[0]) {
+				case 0:
+				case 1:
+					t = op;
+					break;
+				case 4:
+					_.label++;
+					return {
+						value: op[1],
+						done: false
+					};
+				case 5:
+					_.label++;
+					y = op[1];
+					op = [0];
+					continue;
+				case 7:
+					op = _.ops.pop();
+					_.trys.pop();
+					continue;
+				default:
+					if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+						_ = 0;
+						continue;
+					}
+					if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+						_.label = op[1];
+						break;
+					}
+					if (op[0] === 6 && _.label < t[1]) {
+						_.label = t[1];
+						t = op;
+						break;
+					}
+					if (t && _.label < t[2]) {
+						_.label = t[2];
+						_.ops.push(op);
+						break;
+					}
+					if (t[2]) _.ops.pop();
+					_.trys.pop();
+					continue;
+			}
+			op = body.call(thisArg, _);
+		} catch (e) {
+			op = [6, e];
+			y = 0;
+		} finally {
+			f = t = 0;
+		}
+		if (op[0] & 5) throw op[1];
+		return {
+			value: op[0] ? op[1] : void 0,
+			done: true
+		};
+	}
+}
+function __read(o, n) {
+	var m = typeof Symbol === "function" && o[Symbol.iterator];
+	if (!m) return o;
+	var i = m.call(o), r, ar = [], e;
+	try {
+		while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+	} catch (error) {
+		e = { error };
+	} finally {
+		try {
+			if (r && !r.done && (m = i["return"])) m.call(i);
+		} finally {
+			if (e) throw e.error;
+		}
+	}
+	return ar;
+}
+function __spreadArray(to, from, pack) {
+	if (pack || arguments.length === 2) {
+		for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
+			if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+			ar[i] = from[i];
+		}
+	}
+	return to.concat(ar || Array.prototype.slice.call(from));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/file-selector@0.6.0/node_modules/file-selector/dist/es5/file.js
+var COMMON_MIME_TYPES = /* @__PURE__ */ new Map([
+	["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"],
+	["heic", "image/heic"],
+	["heif", "image/heif"],
+	["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"],
+	["mkv", "video/x-matroska"],
+	["mov", "video/quicktime"],
+	["msg", "application/vnd.ms-outlook"]
+]);
+function toFileWithPath(file, path) {
+	var f = withMimeType(file);
+	if (typeof f.path !== "string") {
+		var webkitRelativePath = file.webkitRelativePath;
+		Object.defineProperty(f, "path", {
+			value: typeof path === "string" ? path : typeof webkitRelativePath === "string" && webkitRelativePath.length > 0 ? webkitRelativePath : file.name,
+			writable: false,
+			configurable: false,
+			enumerable: true
+		});
+	}
+	return f;
+}
+function withMimeType(file) {
+	var name = file.name;
+	if (name && name.lastIndexOf(".") !== -1 && !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 ../../node_modules/.pnpm/file-selector@0.6.0/node_modules/file-selector/dist/es5/file-selector.js
+var FILES_TO_IGNORE = [".DS_Store", "Thumbs.db"];
+/**
+* Convert a DragEvent's DataTrasfer object to a list of File objects
+* NOTE: If some of the items are folders,
+* everything will be flattened and placed in the same list but the paths will be kept as a {path} property.
+*
+* EXPERIMENTAL: A list of https://developer.mozilla.org/en-US/docs/Web/API/FileSystemHandle objects can also be passed as an arg
+* and a list of File objects will be returned.
+*
+* @param evt
+*/
+function fromEvent(evt) {
+	return __awaiter(this, void 0, void 0, function() {
+		return __generator(this, function(_a) {
+			if (isObject(evt) && isDataTransfer(evt.dataTransfer)) return [2, getDataTransferFiles(evt.dataTransfer, evt.type)];
+			else if (isChangeEvt(evt)) return [2, getInputFiles(evt)];
+			else if (Array.isArray(evt) && evt.every(function(item) {
+				return "getFile" in item && typeof item.getFile === "function";
+			})) return [2, getFsHandleFiles(evt)];
+			return [2, []];
+		});
+	});
+}
+function isDataTransfer(value) {
+	return isObject(value);
+}
+function isChangeEvt(value) {
+	return isObject(value) && isObject(value.target);
+}
+function isObject(v) {
+	return typeof v === "object" && v !== null;
+}
+function getInputFiles(evt) {
+	return fromList(evt.target.files).map(function(file) {
+		return toFileWithPath(file);
+	});
+}
+function getFsHandleFiles(handles) {
+	return __awaiter(this, void 0, void 0, function() {
+		var files;
+		return __generator(this, function(_a) {
+			switch (_a.label) {
+				case 0: return [4, Promise.all(handles.map(function(h) {
+					return h.getFile();
+				}))];
+				case 1:
+					files = _a.sent();
+					return [2, files.map(function(file) {
+						return toFileWithPath(file);
+					})];
+			}
+		});
+	});
+}
+function getDataTransferFiles(dt, type) {
+	return __awaiter(this, void 0, void 0, function() {
+		var items, files;
+		return __generator(this, function(_a) {
+			switch (_a.label) {
+				case 0:
+					if (!dt.items) return [3, 2];
+					items = fromList(dt.items).filter(function(item) {
+						return item.kind === "file";
+					});
+					if (type !== "drop") return [2, items];
+					return [4, Promise.all(items.map(toFilePromises))];
+				case 1:
+					files = _a.sent();
+					return [2, noIgnoredFiles(flatten(files))];
+				case 2: return [2, noIgnoredFiles(fromList(dt.files).map(function(file) {
+					return toFileWithPath(file);
+				}))];
+			}
+		});
+	});
+}
+function noIgnoredFiles(files) {
+	return files.filter(function(file) {
+		return FILES_TO_IGNORE.indexOf(file.name) === -1;
+	});
+}
+function fromList(items) {
+	if (items === null) return [];
+	var files = [];
+	for (var i = 0; i < items.length; i++) {
+		var file = items[i];
+		files.push(file);
+	}
+	return files;
+}
+function toFilePromises(item) {
+	if (typeof item.webkitGetAsEntry !== "function") return fromDataTransferItem(item);
+	var entry = item.webkitGetAsEntry();
+	if (entry && entry.isDirectory) return fromDirEntry(entry);
+	return fromDataTransferItem(item);
+}
+function flatten(items) {
+	return items.reduce(function(acc, files) {
+		return __spreadArray(__spreadArray([], __read(acc), false), __read(Array.isArray(files) ? flatten(files) : [files]), false);
+	}, []);
+}
+function fromDataTransferItem(item) {
+	var file = item.getAsFile();
+	if (!file) return Promise.reject("".concat(item, " is not a File"));
+	var fwp = toFileWithPath(file);
+	return Promise.resolve(fwp);
+}
+function fromEntry(entry) {
+	return __awaiter(this, void 0, void 0, function() {
+		return __generator(this, function(_a) {
+			return [2, entry.isDirectory ? fromDirEntry(entry) : fromFileEntry(entry)];
+		});
+	});
+}
+function fromDirEntry(entry) {
+	var reader = entry.createReader();
+	return new Promise(function(resolve, reject) {
+		var entries = [];
+		function readEntries() {
+			var _this = this;
+			reader.readEntries(function(batch) {
+				return __awaiter(_this, void 0, void 0, function() {
+					var files, err_1, items;
+					return __generator(this, function(_a) {
+						switch (_a.label) {
+							case 0:
+								if (!!batch.length) return [3, 5];
+								_a.label = 1;
+							case 1:
+								_a.trys.push([
+									1,
+									3,
+									,
+									4
+								]);
+								return [4, Promise.all(entries)];
+							case 2:
+								files = _a.sent();
+								resolve(files);
+								return [3, 4];
+							case 3:
+								err_1 = _a.sent();
+								reject(err_1);
+								return [3, 4];
+							case 4: return [3, 6];
+							case 5:
+								items = Promise.all(batch.map(fromEntry));
+								entries.push(items);
+								readEntries();
+								_a.label = 6;
+							case 6: return [2];
+						}
+					});
+				});
+			}, function(err) {
+				reject(err);
+			});
+		}
+		readEntries();
+	});
+}
+function fromFileEntry(entry) {
+	return __awaiter(this, void 0, void 0, function() {
+		return __generator(this, function(_a) {
+			return [2, new Promise(function(resolve, reject) {
+				entry.file(function(file) {
+					resolve(toFileWithPath(file, entry.fullPath));
+				}, function(err) {
+					reject(err);
+				});
+			})];
+		});
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/attr-accept@2.2.2/node_modules/attr-accept/dist/es/index.js
+var require_es = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.default = function(file, acceptedFiles) {
+		if (file && acceptedFiles) {
+			var acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(",");
+			var fileName = file.name || "";
+			var mimeType = (file.type || "").toLowerCase();
+			var baseMimeType = mimeType.replace(/\/.*$/, "");
+			return acceptedFilesArray.some(function(type) {
+				var validType = type.trim().toLowerCase();
+				if (validType.charAt(0) === ".") return fileName.toLowerCase().endsWith(validType);
+				else if (validType.endsWith("/*")) return baseMimeType === validType.replace(/\/.*$/, "");
+				return mimeType === validType;
+			});
+		}
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/react-dropzone@14.2.3_react@19.2.7/node_modules/react-dropzone/dist/es/utils/index.js
+var import_prop_types = /* @__PURE__ */ __toESM(require_prop_types());
+var import_es = /* @__PURE__ */ __toESM(require_es());
+function _toConsumableArray$1(arr) {
+	return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1();
+}
+function _nonIterableSpread$1() {
+	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$1(iter) {
+	if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _arrayWithoutHoles$1(arr) {
+	if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
+}
+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), !0).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,
+		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"
+};
+function fileAccepted(file, accept) {
+	var isAcceptable = file.type === "application/x-moz-file" || (0, import_es.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];
+}
+function isDefined(value) {
+	return value !== void 0 && value !== null;
+}
+/**
+*
+* @param {object} options
+* @param {File[]} options.files
+* @param {string|string[]} [options.accept]
+* @param {number} [options.minSize]
+* @param {number} [options.maxSize]
+* @param {boolean} [options.multiple]
+* @param {number} [options.maxFiles]
+* @param {(f: File) => FileError|FileError[]|null} [options.validator]
+* @returns
+*/
+function allFilesAccepted(_ref) {
+	var files = _ref.files, accept = _ref.accept, minSize = _ref.minSize, maxSize = _ref.maxSize, multiple = _ref.multiple, maxFiles = _ref.maxFiles, validator = _ref.validator;
+	if (!multiple && files.length > 1 || multiple && maxFiles >= 1 && files.length > maxFiles) return false;
+	return files.every(function(file) {
+		var accepted = _slicedToArray$1(fileAccepted(file, accept), 1)[0];
+		var sizeMatch = _slicedToArray$1(fileMatchSize(file, minSize, maxSize), 1)[0];
+		var customErrors = validator ? validator(file) : null;
+		return accepted && sizeMatch && !customErrors;
+	});
+}
+function isPropagationStopped(event) {
+	if (typeof event.isPropagationStopped === "function") return event.isPropagationStopped();
+	else if (typeof event.cancelBubble !== "undefined") return event.cancelBubble;
+	return false;
+}
+function isEvtWithFiles(event) {
+	if (!event.dataTransfer) return !!event.target && !!event.target.files;
+	return Array.prototype.some.call(event.dataTransfer.types, function(type) {
+		return type === "Files" || type === "application/x-moz-file";
+	});
+}
+function onDocumentDragOver(event) {
+	event.preventDefault();
+}
+function isIe(userAgent) {
+	return userAgent.indexOf("MSIE") !== -1 || userAgent.indexOf("Trident/") !== -1;
+}
+function isEdge(userAgent) {
+	return userAgent.indexOf("Edge/") !== -1;
+}
+function isIeOrEdge() {
+	var userAgent = arguments.length > 0 && arguments[0] !== void 0 ? 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.
+*
+* @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](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;
+}
+/**
+* Convert the `{accept}` dropzone prop to the
+* `{types}` option for https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker
+*
+* @param {AcceptProp} accept
+* @returns {{accept: string[]}[]}
+*/
+function pickerOptionsFromAccept(accept) {
+	if (isDefined(accept)) return [{
+		description: "Files",
+		accept: Object.entries(accept).filter(function(_ref2) {
+			var _ref3 = _slicedToArray$1(_ref2, 2), mimeType = _ref3[0], ext = _ref3[1];
+			var ok = true;
+			if (!isMIMEType(mimeType)) {
+				console.warn("Skipped \"".concat(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) || !ext.every(isExt)) {
+				console.warn("Skipped \"".concat(mimeType, "\" because an invalid file extension was provided."));
+				ok = false;
+			}
+			return ok;
+		}).reduce(function(agg, _ref4) {
+			var _ref5 = _slicedToArray$1(_ref4, 2), mimeType = _ref5[0], ext = _ref5[1];
+			return _objectSpread$1(_objectSpread$1({}, agg), {}, _defineProperty$1({}, mimeType, ext));
+		}, {})
+	}];
+	return accept;
+}
+/**
+* Convert the `{accept}` dropzone prop to an array of MIME types/extensions.
+* @param {AcceptProp} accept
+* @returns {string}
+*/
+function acceptPropAsAcceptAttr(accept) {
+	if (isDefined(accept)) return Object.entries(accept).reduce(function(a, _ref6) {
+		var _ref7 = _slicedToArray$1(_ref6, 2), mimeType = _ref7[0], ext = _ref7[1];
+		return [].concat(_toConsumableArray$1(a), [mimeType], _toConsumableArray$1(ext));
+	}, []).filter(function(v) {
+		return isMIMEType(v) || isExt(v);
+	}).join(",");
+}
+/**
+* Check if v is an exception caused by aborting a request (e.g window.showOpenFilePicker()).
+*
+* See https://developer.mozilla.org/en-US/docs/Web/API/DOMException.
+* @param {any} v
+* @returns {boolean} True if v is an abort exception.
+*/
+function isAbort(v) {
+	return v instanceof DOMException && (v.name === "AbortError" || v.code === v.ABORT_ERR);
+}
+/**
+* Check if v is a security error.
+*
+* See https://developer.mozilla.org/en-US/docs/Web/API/DOMException.
+* @param {any} v
+* @returns {boolean} True if v is a security error.
+*/
+function isSecurityError(v) {
+	return v instanceof DOMException && (v.name === "SecurityError" || v.code === v.SECURITY_ERR);
+}
+/**
+* Check if v is a MIME type string.
+*
+* See accepted format: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#unique_file_type_specifiers.
+*
+* @param {string} v
+*/
+function isMIMEType(v) {
+	return v === "audio/*" || v === "video/*" || v === "image/*" || v === "text/*" || /\w+\/[-+.\w]+/g.test(v);
+}
+/**
+* Check if v is a file extension.
+* @param {string} v
+*/
+function isExt(v) {
+	return /^.*\.[\w]+$/.test(v);
+}
+/**
+* @typedef {Object.<string, string[]>} AcceptProp
+*/
+/**
+* @typedef {object} FileError
+* @property {string} message
+* @property {ErrorCode|string} code
+*/
+/**
+* @typedef {"file-invalid-type"|"file-too-large"|"file-too-small"|"too-many-files"} ErrorCode
+*/
+//#endregion
+//#region ../../node_modules/.pnpm/react-dropzone@14.2.3_react@19.2.7/node_modules/react-dropzone/dist/es/index.js
+var _excluded = ["children"];
+var _excluded2 = ["open"];
+var _excluded3 = [
+	"refKey",
+	"role",
+	"onKeyDown",
+	"onFocus",
+	"onBlur",
+	"onClick",
+	"onDragEnter",
+	"onDragOver",
+	"onDragLeave",
+	"onDrop"
+];
+var _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), !0).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,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+function _objectWithoutProperties(source, excluded) {
+	if (source == null) return {};
+	var target = _objectWithoutPropertiesLoose(source, excluded);
+	var key, i;
+	if (Object.getOwnPropertySymbols) {
+		var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+		for (i = 0; i < sourceSymbolKeys.length; i++) {
+			key = sourceSymbolKeys[i];
+			if (excluded.indexOf(key) >= 0) continue;
+			if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+			target[key] = source[key];
+		}
+	}
+	return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+	if (source == null) return {};
+	var target = {};
+	var sourceKeys = Object.keys(source);
+	var key, i;
+	for (i = 0; i < sourceKeys.length; i++) {
+		key = sourceKeys[i];
+		if (excluded.indexOf(key) >= 0) continue;
+		target[key] = source[key];
+	}
+	return target;
+}
+/**
+* Convenience wrapper component for the `useDropzone` hook
+*
+* ```jsx
+* <Dropzone>
+*   {({getRootProps, getInputProps}) => (
+*     <div {...getRootProps()}>
+*       <input {...getInputProps()} />
+*       <p>Drag 'n' drop some files here, or click to select files</p>
+*     </div>
+*   )}
+* </Dropzone>
+* ```
+*/
+var Dropzone = /*#__PURE__*/ forwardRef(function(_ref, ref) {
+	var children = _ref.children;
+	var _useDropzone = useDropzone(_objectWithoutProperties(_ref, _excluded)), open = _useDropzone.open, props = _objectWithoutProperties(_useDropzone, _excluded2);
+	useImperativeHandle(ref, function() {
+		return { open };
+	}, [open]);
+	return /*#__PURE__*/ React.createElement(Fragment, null, children(_objectSpread(_objectSpread({}, props), {}, { open })));
+});
+Dropzone.displayName = "Dropzone";
+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: true,
+	autoFocus: 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.acceptedFiles Accepted files
+	* @param {FileRejection[]} params.fileRejections Rejected files and why they were rejected
+	*/
+	children: import_prop_types.default.func,
+	/**
+	* Set accepted file types.
+	* Checkout https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker types option 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 (https://github.com/react-dropzone/react-dropzone/issues/276).
+	*/
+	accept: import_prop_types.default.objectOf(import_prop_types.default.arrayOf(import_prop_types.default.string)),
+	/**
+	* Allow drag 'n' drop (or selection from the file dialog) of multiple files
+	*/
+	multiple: import_prop_types.default.bool,
+	/**
+	* If false, allow dropped items to take over the current browser window
+	*/
+	preventDropOnDocument: import_prop_types.default.bool,
+	/**
+	* If true, disables click to open the native file selection dialog
+	*/
+	noClick: import_prop_types.default.bool,
+	/**
+	* If true, disables SPACE/ENTER to open the native file selection dialog.
+	* Note that it also stops tracking the focus state.
+	*/
+	noKeyboard: import_prop_types.default.bool,
+	/**
+	* If true, disables drag 'n' drop
+	*/
+	noDrag: import_prop_types.default.bool,
+	/**
+	* If true, stops drag event propagation to parents
+	*/
+	noDragEventsBubbling: import_prop_types.default.bool,
+	/**
+	* Minimum file size (in bytes)
+	*/
+	minSize: import_prop_types.default.number,
+	/**
+	* Maximum file size (in bytes)
+	*/
+	maxSize: import_prop_types.default.number,
+	/**
+	* Maximum accepted number of files
+	* The default value is 0 which means there is no limitation to how many files are accepted.
+	*/
+	maxFiles: import_prop_types.default.number,
+	/**
+	* Enable/disable the dropzone
+	*/
+	disabled: import_prop_types.default.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: import_prop_types.default.func,
+	/**
+	* Cb for when closing the file dialog with no selection
+	*/
+	onFileDialogCancel: import_prop_types.default.func,
+	/**
+	* Cb for when opening the file dialog
+	*/
+	onFileDialogOpen: import_prop_types.default.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: import_prop_types.default.bool,
+	/**
+	* Set to true to focus the root element on render
+	*/
+	autoFocus: import_prop_types.default.bool,
+	/**
+	* Cb for when the `dragenter` event occurs.
+	*
+	* @param {DragEvent} event
+	*/
+	onDragEnter: import_prop_types.default.func,
+	/**
+	* Cb for when the `dragleave` event occurs
+	*
+	* @param {DragEvent} event
+	*/
+	onDragLeave: import_prop_types.default.func,
+	/**
+	* Cb for when the `dragover` event occurs
+	*
+	* @param {DragEvent} event
+	*/
+	onDragOver: import_prop_types.default.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: import_prop_types.default.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: import_prop_types.default.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: import_prop_types.default.func,
+	/**
+	* Cb for when there's some error from any of the promises.
+	*
+	* @param {Error} error
+	*/
+	onError: import_prop_types.default.func,
+	/**
+	* Custom validation function. It must return null if there's no errors.
+	* @param {File} file
+	* @returns {FileError|FileError[]|null}
+	*/
+	validator: import_prop_types.default.func
+};
+/**
+* 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
+*/
+/**
+* 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)
+*/
+/**
+* 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)
+*/
+/**
+* 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)
+*/
+/**
+* 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[]>)}
+*/
+/**
+* An object with the current dropzone state.
+*
+* @typedef {object} DropzoneState
+* @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[]} acceptedFiles Accepted files
+* @property {FileRejection[]} fileRejections Rejected files and why they were rejected
+*/
+/**
+* An object with the dropzone methods.
+*
+* @typedef {object} DropzoneMethods
+* @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
+*/
+var initialState = {
+	isFocused: false,
+	isFileDialogActive: false,
+	isDragActive: false,
+	isDragAccept: false,
+	isDragReject: false,
+	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
+*
+* @param {object} props
+* @param {import("./utils").AcceptProp} [props.accept] Set accepted file types.
+* Checkout https://developer.mozilla.org/en-US/docs/Web/API/window/showOpenFilePicker types option 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 (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 {boolean} autoFocus Set to true to auto focus the root element.
+* @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 an object with keys as 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) and the value an array of file extensions (optional).
+* 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]
+* @param {(error: Error) => void} [props.onError]
+*
+* @returns {DropzoneState & DropzoneMethods}
+*/
+function useDropzone() {
+	var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+	var _defaultProps$props = _objectSpread(_objectSpread({}, defaultProps), props), accept = _defaultProps$props.accept, disabled = _defaultProps$props.disabled, getFilesFromEvent = _defaultProps$props.getFilesFromEvent, maxSize = _defaultProps$props.maxSize, minSize = _defaultProps$props.minSize, multiple = _defaultProps$props.multiple, maxFiles = _defaultProps$props.maxFiles, onDragEnter = _defaultProps$props.onDragEnter, onDragLeave = _defaultProps$props.onDragLeave, onDragOver = _defaultProps$props.onDragOver, onDrop = _defaultProps$props.onDrop, onDropAccepted = _defaultProps$props.onDropAccepted, onDropRejected = _defaultProps$props.onDropRejected, onFileDialogCancel = _defaultProps$props.onFileDialogCancel, onFileDialogOpen = _defaultProps$props.onFileDialogOpen, useFsAccessApi = _defaultProps$props.useFsAccessApi, autoFocus = _defaultProps$props.autoFocus, preventDropOnDocument = _defaultProps$props.preventDropOnDocument, noClick = _defaultProps$props.noClick, noKeyboard = _defaultProps$props.noKeyboard, noDrag = _defaultProps$props.noDrag, noDragEventsBubbling = _defaultProps$props.noDragEventsBubbling, onError = _defaultProps$props.onError, validator = _defaultProps$props.validator;
+	var acceptAttr = useMemo(function() {
+		return acceptPropAsAcceptAttr(accept);
+	}, [accept]);
+	var pickerTypes = useMemo(function() {
+		return pickerOptionsFromAccept(accept);
+	}, [accept]);
+	var onFileDialogOpenCb = useMemo(function() {
+		return typeof onFileDialogOpen === "function" ? onFileDialogOpen : noop;
+	}, [onFileDialogOpen]);
+	var onFileDialogCancelCb = useMemo(function() {
+		return typeof onFileDialogCancel === "function" ? onFileDialogCancel : noop;
+	}, [onFileDialogCancel]);
+	/**
+	* @constant
+	* @type {React.MutableRefObject<HTMLElement>}
+	*/
+	var rootRef = useRef(null);
+	var inputRef = useRef(null);
+	var _useReducer2 = _slicedToArray(useReducer(reducer, initialState), 2), state = _useReducer2[0], dispatch = _useReducer2[1];
+	var isFocused = state.isFocused, isFileDialogActive = state.isFileDialogActive;
+	var fsAccessApiWorksRef = useRef(typeof window !== "undefined" && window.isSecureContext && useFsAccessApi && canUseFileSystemAccessAPI());
+	var onWindowFocus = function onWindowFocus() {
+		if (!fsAccessApiWorksRef.current && isFileDialogActive) setTimeout(function() {
+			if (inputRef.current) {
+				if (!inputRef.current.files.length) {
+					dispatch({ type: "closeDialog" });
+					onFileDialogCancelCb();
+				}
+			}
+		}, 300);
+	};
+	useEffect(function() {
+		window.addEventListener("focus", onWindowFocus, false);
+		return function() {
+			window.removeEventListener("focus", onWindowFocus, false);
+		};
+	}, [
+		inputRef,
+		isFileDialogActive,
+		onFileDialogCancelCb,
+		fsAccessApiWorksRef
+	]);
+	var dragTargetsRef = useRef([]);
+	var onDocumentDrop = function onDocumentDrop(event) {
+		if (rootRef.current && rootRef.current.contains(event.target)) return;
+		event.preventDefault();
+		dragTargetsRef.current = [];
+	};
+	useEffect(function() {
+		if (preventDropOnDocument) {
+			document.addEventListener("dragover", onDocumentDragOver, false);
+			document.addEventListener("drop", onDocumentDrop, false);
+		}
+		return function() {
+			if (preventDropOnDocument) {
+				document.removeEventListener("dragover", onDocumentDragOver);
+				document.removeEventListener("drop", onDocumentDrop);
+			}
+		};
+	}, [rootRef, preventDropOnDocument]);
+	useEffect(function() {
+		if (!disabled && autoFocus && rootRef.current) rootRef.current.focus();
+		return function() {};
+	}, [
+		rootRef,
+		autoFocus,
+		disabled
+	]);
+	var onErrCb = useCallback(function(e) {
+		if (onError) onError(e);
+		else console.error(e);
+	}, [onError]);
+	var onDragEnterCb = useCallback(function(event) {
+		event.preventDefault();
+		event.persist();
+		stopPropagation(event);
+		dragTargetsRef.current = [].concat(_toConsumableArray(dragTargetsRef.current), [event.target]);
+		if (isEvtWithFiles(event)) Promise.resolve(getFilesFromEvent(event)).then(function(files) {
+			if (isPropagationStopped(event) && !noDragEventsBubbling) return;
+			var fileCount = files.length;
+			var isDragAccept = fileCount > 0 && allFilesAccepted({
+				files,
+				accept: acceptAttr,
+				minSize,
+				maxSize,
+				multiple,
+				maxFiles,
+				validator
+			});
+			dispatch({
+				isDragAccept,
+				isDragReject: fileCount > 0 && !isDragAccept,
+				isDragActive: true,
+				type: "setDraggedFiles"
+			});
+			if (onDragEnter) onDragEnter(event);
+		}).catch(function(e) {
+			return onErrCb(e);
+		});
+	}, [
+		getFilesFromEvent,
+		onDragEnter,
+		onErrCb,
+		noDragEventsBubbling,
+		acceptAttr,
+		minSize,
+		maxSize,
+		multiple,
+		maxFiles,
+		validator
+	]);
+	var onDragOverCb = useCallback(function(event) {
+		event.preventDefault();
+		event.persist();
+		stopPropagation(event);
+		var hasFiles = isEvtWithFiles(event);
+		if (hasFiles && event.dataTransfer) try {
+			event.dataTransfer.dropEffect = "copy";
+		} catch (_unused) {}
+		if (hasFiles && onDragOver) onDragOver(event);
+		return false;
+	}, [onDragOver, noDragEventsBubbling]);
+	var onDragLeaveCb = useCallback(function(event) {
+		event.preventDefault();
+		event.persist();
+		stopPropagation(event);
+		var targets = dragTargetsRef.current.filter(function(target) {
+			return rootRef.current && rootRef.current.contains(target);
+		});
+		var 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
+		});
+		if (isEvtWithFiles(event) && onDragLeave) onDragLeave(event);
+	}, [
+		rootRef,
+		onDragLeave,
+		noDragEventsBubbling
+	]);
+	var setFiles = useCallback(function(files, event) {
+		var acceptedFiles = [];
+		var fileRejections = [];
+		files.forEach(function(file) {
+			var _fileAccepted2 = _slicedToArray(fileAccepted(file, acceptAttr), 2), accepted = _fileAccepted2[0], acceptError = _fileAccepted2[1];
+			var _fileMatchSize2 = _slicedToArray(fileMatchSize(file, minSize, maxSize), 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,
+					errors: errors.filter(function(e) {
+						return e;
+					})
+				});
+			}
+		});
+		if (!multiple && acceptedFiles.length > 1 || multiple && maxFiles >= 1 && acceptedFiles.length > maxFiles) {
+			acceptedFiles.forEach(function(file) {
+				fileRejections.push({
+					file,
+					errors: [TOO_MANY_FILES_REJECTION]
+				});
+			});
+			acceptedFiles.splice(0);
+		}
+		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);
+	}, [
+		dispatch,
+		multiple,
+		acceptAttr,
+		minSize,
+		maxSize,
+		maxFiles,
+		onDrop,
+		onDropAccepted,
+		onDropRejected,
+		validator
+	]);
+	var onDropCb = useCallback(function(event) {
+		event.preventDefault();
+		event.persist();
+		stopPropagation(event);
+		dragTargetsRef.current = [];
+		if (isEvtWithFiles(event)) Promise.resolve(getFilesFromEvent(event)).then(function(files) {
+			if (isPropagationStopped(event) && !noDragEventsBubbling) return;
+			setFiles(files, event);
+		}).catch(function(e) {
+			return onErrCb(e);
+		});
+		dispatch({ type: "reset" });
+	}, [
+		getFilesFromEvent,
+		setFiles,
+		onErrCb,
+		noDragEventsBubbling
+	]);
+	var openFileDialog = useCallback(function() {
+		if (fsAccessApiWorksRef.current) {
+			dispatch({ type: "openDialog" });
+			onFileDialogOpenCb();
+			var opts = {
+				multiple,
+				types: pickerTypes
+			};
+			window.showOpenFilePicker(opts).then(function(handles) {
+				return getFilesFromEvent(handles);
+			}).then(function(files) {
+				setFiles(files, null);
+				dispatch({ type: "closeDialog" });
+			}).catch(function(e) {
+				if (isAbort(e)) {
+					onFileDialogCancelCb(e);
+					dispatch({ type: "closeDialog" });
+				} else if (isSecurityError(e)) {
+					fsAccessApiWorksRef.current = false;
+					if (inputRef.current) {
+						inputRef.current.value = null;
+						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 = null;
+			inputRef.current.click();
+		}
+	}, [
+		dispatch,
+		onFileDialogOpenCb,
+		onFileDialogCancelCb,
+		useFsAccessApi,
+		setFiles,
+		onErrCb,
+		pickerTypes,
+		multiple
+	]);
+	var onKeyDownCb = useCallback(function(event) {
+		if (!rootRef.current || !rootRef.current.isEqualNode(event.target)) return;
+		if (event.key === " " || event.key === "Enter" || event.keyCode === 32 || event.keyCode === 13) {
+			event.preventDefault();
+			openFileDialog();
+		}
+	}, [rootRef, openFileDialog]);
+	var onFocusCb = useCallback(function() {
+		dispatch({ type: "focus" });
+	}, []);
+	var onBlurCb = useCallback(function() {
+		dispatch({ type: "blur" });
+	}, []);
+	var onClickCb = useCallback(function() {
+		if (noClick) return;
+		if (isIeOrEdge()) setTimeout(openFileDialog, 0);
+		else openFileDialog();
+	}, [noClick, openFileDialog]);
+	var composeHandler = function composeHandler(fn) {
+		return disabled ? null : fn;
+	};
+	var composeKeyboardHandler = function composeKeyboardHandler(fn) {
+		return noKeyboard ? null : composeHandler(fn);
+	};
+	var composeDragHandler = function composeDragHandler(fn) {
+		return noDrag ? null : composeHandler(fn);
+	};
+	var stopPropagation = function stopPropagation(event) {
+		if (noDragEventsBubbling) event.stopPropagation();
+	};
+	var getRootProps = useMemo(function() {
+		return function() {
+			var _ref2 = arguments.length > 0 && arguments[0] !== void 0 ? 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 : "presentation"
+			}, refKey, rootRef), !disabled && !noKeyboard ? { tabIndex: 0 } : {}), rest);
+		};
+	}, [
+		rootRef,
+		onKeyDownCb,
+		onFocusCb,
+		onBlurCb,
+		onClickCb,
+		onDragEnterCb,
+		onDragOverCb,
+		onDragLeaveCb,
+		onDropCb,
+		noKeyboard,
+		noDrag,
+		disabled
+	]);
+	var onInputElementClick = useCallback(function(event) {
+		event.stopPropagation();
+	}, []);
+	var getInputProps = useMemo(function() {
+		return function() {
+			var _ref3 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref3$refKey = _ref3.refKey, refKey = _ref3$refKey === void 0 ? "ref" : _ref3$refKey, onChange = _ref3.onChange, onClick = _ref3.onClick, rest = _objectWithoutProperties(_ref3, _excluded4);
+			return _objectSpread(_objectSpread({}, _defineProperty({
+				accept: acceptAttr,
+				multiple,
+				type: "file",
+				style: { display: "none" },
+				onChange: composeHandler(composeEventHandlers(onChange, onDropCb)),
+				onClick: composeHandler(composeEventHandlers(onClick, onInputElementClick)),
+				tabIndex: -1
+			}, refKey, inputRef)), rest);
+		};
+	}, [
+		inputRef,
+		accept,
+		multiple,
+		onDropCb,
+		disabled
+	]);
+	return _objectSpread(_objectSpread({}, state), {}, {
+		isFocused: isFocused && !disabled,
+		getRootProps,
+		getInputProps,
+		rootRef,
+		inputRef,
+		open: composeHandler(openFileDialog)
+	});
+}
+/**
+* @param {DropzoneState} state
+* @param {{type: string} & DropzoneState} action
+* @returns {DropzoneState}
+*/
+function reducer(state, action) {
+	/* istanbul ignore next */
+	switch (action.type) {
+		case "focus": return _objectSpread(_objectSpread({}, state), {}, { isFocused: true });
+		case "blur": return _objectSpread(_objectSpread({}, state), {}, { isFocused: false });
+		case "openDialog": return _objectSpread(_objectSpread({}, initialState), {}, { isFileDialogActive: true });
+		case "closeDialog": return _objectSpread(_objectSpread({}, state), {}, { isFileDialogActive: false });
+		case "setDraggedFiles": return _objectSpread(_objectSpread({}, state), {}, {
+			isDragActive: action.isDragActive,
+			isDragAccept: action.isDragAccept,
+			isDragReject: action.isDragReject
+		});
+		case "setFiles": return _objectSpread(_objectSpread({}, state), {}, {
+			acceptedFiles: action.acceptedFiles,
+			fileRejections: action.fileRejections
+		});
+		case "reset": return _objectSpread({}, initialState);
+		default: return state;
+	}
+}
+function noop() {}
+//#endregion
+//#region src/components/FileUpload/useFileDropTarget.ts
+/**
+* Headless drop target — turns any element into one via `getRootProps()`.
+*
+* **When to use:** the drop affordance is an existing subtree you style yourself (a message
+* composer, a card, a whole panel). Pair with `noClick` / `noKeyboard` when that subtree is
+* already interactive, so clicking or typing inside it doesn't open the file dialog.
+* **When NOT to use:** a standalone drop box — compose `FileUpload` + `FileUpload.DropZone`,
+* which own the dashed-border chrome and the drag / error visual states.
+*/
+const useFileDropTarget = ({ accept, maxSize, maxFiles, multiple = true, disabled = false, noClick, noKeyboard, onFilesChange, onFilesRejected } = {}) => {
+	const { getRootProps, getInputProps, isDragActive, fileRejections } = useDropzone({
+		accept,
+		maxSize,
+		maxFiles,
+		multiple,
+		disabled,
+		noClick,
+		noKeyboard,
+		onDropAccepted: (files) => onFilesChange?.(files),
+		onDropRejected: (rejections) => onFilesRejected?.(rejections)
+	});
+	return {
+		getRootProps,
+		getInputProps,
+		isDragActive,
+		rejections: fileRejections
+	};
+};
+//#endregion
+//#region src/components/FileUpload/FileUpload.tsx
+/**
+* Drop-zone primitive — caller owns the file array; the component signals drops.
+*
+* Brand-neutral: the chrome is semantic tokens, so it follows whichever brand is active (there is
+* no argo-only runtime gate) and renders under legacy chrome too.
+*
+* **When to use:** any in-page file-picker flow (Card body, Modal, page content).
+* **When NOT to use:** for upload progress or pipeline orchestration, build app-level state on top of
+* `onFilesChange`; this primitive does not own the upload lifecycle. When the drop affordance is an
+* existing subtree you style yourself, reach for `useFileDropTarget` instead.
+* **Composition:** wrap `<FileUpload.DropZone />` for the drop target and `<FileUpload.FileList />`
+* for the selected-files list. The caller stores the `File[]` and renders it back into `FileList`.
+* Rejection copy is the caller's — read it with `useFileUploadRejections()`.
+*/
+const FileUploadInner = ({ accept, maxSize, maxFiles, multiple, disabled = false, onFilesChange, onFilesRejected, forcedState, children, className, ...rest }) => {
+	const dropTarget = useFileDropTarget({
+		accept,
+		maxSize,
+		maxFiles,
+		multiple,
+		disabled,
+		onFilesChange,
+		onFilesRejected
+	});
+	return /* @__PURE__ */ jsx(FileUploadProvider, {
+		value: {
+			dropTarget,
+			forcedState,
+			disabled
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			className: cn("tw:flex tw:flex-col tw:gap-3", className),
+			...rest,
+			children
+		})
+	});
+};
+const FileUpload = Object.assign(FileUploadInner, {
+	DropZone: FileUploadDropZone,
+	FileList: FileUploadFileList
+});
+//#endregion
+export { FileUpload, useFileDropTarget, useFileUploadRejections };
+
+//# sourceMappingURL=FileUpload-BRv0TaZk.js.map