@dreamtree-org/twreact-ui 1.3.0 → 1.3.2

package/dist/components/rich-text/RichTextToolbar.d.ts

@@ -0,0 +1,219 @@
+/** Toolbar state derived from the editor on every transaction (via useEditorState). */
+export function selectToolbarState(editor: any): {
+    isEmpty: any;
+    bold: any;
+    italic: any;
+    strike: any;
+    code: any;
+    heading1: any;
+    heading2: any;
+    heading3: any;
+    bulletList: any;
+    orderedList: any;
+    blockquote: any;
+    codeBlock: any;
+    link: any;
+    undo: any;
+    redo: any;
+} | null;
+/** Normalises a typed URL; returns null for schemes we refuse (javascript:, data:, …). */
+export function normalizeUrl(raw: any): string | null;
+/**
+ * A WAI-ARIA toolbar: one tab stop, arrow keys / Home / End move between the
+ * buttons (roving tabindex), toggles report `aria-pressed`.
+ */
+export function RichTextToolbar({ editor, state, items, disabled, controlsId, label }: {
+    editor: any;
+    state: any;
+    items: any;
+    disabled: any;
+    controlsId: any;
+    label?: string | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export namespace TOOLBAR_ITEMS {
+    namespace bold {
+        export let label: string;
+        export { Bold as icon };
+        export let group: string;
+        export let shortcut: string;
+        export let toggle: boolean;
+        export function run(c: any): any;
+    }
+    namespace italic {
+        let label_1: string;
+        export { label_1 as label };
+        export { Italic as icon };
+        let group_1: string;
+        export { group_1 as group };
+        let shortcut_1: string;
+        export { shortcut_1 as shortcut };
+        let toggle_1: boolean;
+        export { toggle_1 as toggle };
+        export function run_1(c: any): any;
+        export { run_1 as run };
+    }
+    namespace strike {
+        let label_2: string;
+        export { label_2 as label };
+        export { Strikethrough as icon };
+        let group_2: string;
+        export { group_2 as group };
+        let shortcut_2: string;
+        export { shortcut_2 as shortcut };
+        let toggle_2: boolean;
+        export { toggle_2 as toggle };
+        export function run_2(c: any): any;
+        export { run_2 as run };
+    }
+    namespace code {
+        let label_3: string;
+        export { label_3 as label };
+        export { Code as icon };
+        let group_3: string;
+        export { group_3 as group };
+        let shortcut_3: string;
+        export { shortcut_3 as shortcut };
+        let toggle_3: boolean;
+        export { toggle_3 as toggle };
+        export function run_3(c: any): any;
+        export { run_3 as run };
+    }
+    namespace heading1 {
+        let label_4: string;
+        export { label_4 as label };
+        export { Heading1 as icon };
+        let group_4: string;
+        export { group_4 as group };
+        let shortcut_4: string;
+        export { shortcut_4 as shortcut };
+        let toggle_4: boolean;
+        export { toggle_4 as toggle };
+        export function run_4(c: any): any;
+        export { run_4 as run };
+    }
+    namespace heading2 {
+        let label_5: string;
+        export { label_5 as label };
+        export { Heading2 as icon };
+        let group_5: string;
+        export { group_5 as group };
+        let shortcut_5: string;
+        export { shortcut_5 as shortcut };
+        let toggle_5: boolean;
+        export { toggle_5 as toggle };
+        export function run_5(c: any): any;
+        export { run_5 as run };
+    }
+    namespace heading3 {
+        let label_6: string;
+        export { label_6 as label };
+        export { Heading3 as icon };
+        let group_6: string;
+        export { group_6 as group };
+        let shortcut_6: string;
+        export { shortcut_6 as shortcut };
+        let toggle_6: boolean;
+        export { toggle_6 as toggle };
+        export function run_6(c: any): any;
+        export { run_6 as run };
+    }
+    namespace bulletList {
+        let label_7: string;
+        export { label_7 as label };
+        export { List as icon };
+        let group_7: string;
+        export { group_7 as group };
+        let shortcut_7: string;
+        export { shortcut_7 as shortcut };
+        let toggle_7: boolean;
+        export { toggle_7 as toggle };
+        export function run_7(c: any): any;
+        export { run_7 as run };
+    }
+    namespace orderedList {
+        let label_8: string;
+        export { label_8 as label };
+        export { ListOrdered as icon };
+        let group_8: string;
+        export { group_8 as group };
+        let shortcut_8: string;
+        export { shortcut_8 as shortcut };
+        let toggle_8: boolean;
+        export { toggle_8 as toggle };
+        export function run_8(c: any): any;
+        export { run_8 as run };
+    }
+    namespace blockquote {
+        let label_9: string;
+        export { label_9 as label };
+        export { Quote as icon };
+        let group_9: string;
+        export { group_9 as group };
+        let shortcut_9: string;
+        export { shortcut_9 as shortcut };
+        let toggle_9: boolean;
+        export { toggle_9 as toggle };
+        export function run_9(c: any): any;
+        export { run_9 as run };
+    }
+    namespace codeBlock {
+        let label_10: string;
+        export { label_10 as label };
+        export { SquareCode as icon };
+        let group_10: string;
+        export { group_10 as group };
+        let shortcut_10: string;
+        export { shortcut_10 as shortcut };
+        let toggle_10: boolean;
+        export { toggle_10 as toggle };
+        export function run_10(c: any): any;
+        export { run_10 as run };
+    }
+    namespace link {
+        let label_11: string;
+        export { label_11 as label };
+        export { LinkIcon as icon };
+        let group_11: string;
+        export { group_11 as group };
+        let toggle_11: boolean;
+        export { toggle_11 as toggle };
+    }
+    namespace undo {
+        let label_12: string;
+        export { label_12 as label };
+        export { Undo as icon };
+        let group_12: string;
+        export { group_12 as group };
+        let shortcut_11: string;
+        export { shortcut_11 as shortcut };
+        export function run_11(c: any): any;
+        export { run_11 as run };
+    }
+    namespace redo {
+        let label_13: string;
+        export { label_13 as label };
+        export { Redo as icon };
+        let group_13: string;
+        export { group_13 as group };
+        let shortcut_12: string;
+        export { shortcut_12 as shortcut };
+        export function run_12(c: any): any;
+        export { run_12 as run };
+    }
+}
+export const DEFAULT_TOOLBAR: string[];
+import { Bold } from "lucide-react";
+import { Italic } from "lucide-react";
+import { Strikethrough } from "lucide-react";
+import { Code } from "lucide-react";
+import { Heading1 } from "lucide-react";
+import { Heading2 } from "lucide-react";
+import { Heading3 } from "lucide-react";
+import { List } from "lucide-react";
+import { ListOrdered } from "lucide-react";
+import { Quote } from "lucide-react";
+import { SquareCode } from "lucide-react";
+import { Link as LinkIcon } from "lucide-react";
+import { Undo } from "lucide-react";
+import { Redo } from "lucide-react";
+//# sourceMappingURL=RichTextToolbar.d.ts.map

package/dist/components/rich-text/RichTextToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichTextToolbar.d.ts","sourceRoot":"","sources":["../../../src/components/rich-text/RichTextToolbar.jsx"],"names":[],"mappings":"AAuDA,uFAAuF;AACvF;;;;;;;;;;;;;;;;SAmBC;AAKD,0FAA0F;AAC1F,sDAMC;AAsFD;;;GAGG;AACH;;;;;;;4CAkFC;;;;;;;;QA3O0F,iCAAqB;;;;;;;;;;;;QACf,mCAAuB;;;;;;;;;;;;;QACH,mCAAuB;;;;;;;;;;;;;QAC1C,mCAAqB;;;;;;;;;;;;;QACV,mCAAoC;;;;;;;;;;;;;QACpC,mCAAoC;;;;;;;;;;;;;QACpC,mCAAoC;;;;;;;;;;;;;QAChC,mCAA2B;;;;;;;;;;;;;QACnB,mCAA4B;;;;;;;;;;;;;QAC3C,mCAA2B;;;;;;;;;;;;;QACpB,oCAA0B;;;;;;;;;;;;;;;;;;;;QAE5D,oCAAe;;;;;;;;;;;QACT,oCAAe;;;;AAGpG,uCAaE;qBArCK,cAAc;uBAAd,cAAc;8BAAd,cAAc;qBAAd,cAAc;yBAAd,cAAc;yBAAd,cAAc;yBAAd,cAAc;qBAAd,cAAc;4BAAd,cAAc;sBAAd,cAAc;2BAAd,cAAc;iCAAd,cAAc;qBAAd,cAAc;qBAAd,cAAc"}

package/dist/components/utility/Badge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Badge.d.ts","sourceRoot":"","sources":["../../../src/components/utility/Badge.jsx"],"names":[],"mappings":";AAGA,+EA0CG;kBA7Ce,OAAO"}
+{"version":3,"file":"Badge.d.ts","sourceRoot":"","sources":["../../../src/components/utility/Badge.jsx"],"names":[],"mappings":";AAGA,+EA6CG;kBAhDe,OAAO"}

package/dist/components/utility/FileUpload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileUpload.d.ts","sourceRoot":"","sources":["../../../src/components/utility/FileUpload.jsx"],"names":[],"mappings":";AAIA,oFAiLG;kBArLkD,OAAO"}
+{"version":3,"file":"FileUpload.d.ts","sourceRoot":"","sources":["../../../src/components/utility/FileUpload.jsx"],"names":[],"mappings":";AAYA,oFAyKG;kBArLkD,OAAO"}

package/dist/components/utility/Sortable.d.ts

@@ -0,0 +1,4 @@
+export default Sortable;
+declare const Sortable: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+import React from "react";
+//# sourceMappingURL=Sortable.d.ts.map

package/dist/components/utility/Sortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sortable.d.ts","sourceRoot":"","sources":["../../../src/components/utility/Sortable.jsx"],"names":[],"mappings":";AAqBA,kFAoHG;kBAzI0G,OAAO"}

package/dist/esm/_vendor/object-assign/index.js

@@ -0,0 +1,99 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = 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;
+	};
+	return objectAssign;
+}
+
+export { requireObjectAssign as __require };

package/dist/esm/_vendor/prop-types/_vendor/react-is/cjs/react-is.development.js

@@ -0,0 +1,190 @@
+import { __exports as reactIs_development } from '../../../../../_virtual/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 hasRequiredReactIs_development;
+
+function requireReactIs_development () {
+	if (hasRequiredReactIs_development) return reactIs_development;
+	hasRequiredReactIs_development = 1;
+
+
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+	// nor polyfill, then a plain number is used for performance.
+	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+	// (unstable) APIs that have been removed. Can we remove the symbols?
+
+	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+	var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+	var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+	var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+	var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+	var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+	function isValidElementType(type) {
+	  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+	  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;
+	    }
+	  }
+
+	  return undefined;
+	} // AsyncMode is deprecated along with isAsyncMode
+
+	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; // AsyncMode should be deprecated
+
+	function isAsyncMode(object) {
+	  {
+	    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+	      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+	      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;
+	}
+
+	reactIs_development.AsyncMode = AsyncMode;
+	reactIs_development.ConcurrentMode = ConcurrentMode;
+	reactIs_development.ContextConsumer = ContextConsumer;
+	reactIs_development.ContextProvider = ContextProvider;
+	reactIs_development.Element = Element;
+	reactIs_development.ForwardRef = ForwardRef;
+	reactIs_development.Fragment = Fragment;
+	reactIs_development.Lazy = Lazy;
+	reactIs_development.Memo = Memo;
+	reactIs_development.Portal = Portal;
+	reactIs_development.Profiler = Profiler;
+	reactIs_development.StrictMode = StrictMode;
+	reactIs_development.Suspense = Suspense;
+	reactIs_development.isAsyncMode = isAsyncMode;
+	reactIs_development.isConcurrentMode = isConcurrentMode;
+	reactIs_development.isContextConsumer = isContextConsumer;
+	reactIs_development.isContextProvider = isContextProvider;
+	reactIs_development.isElement = isElement;
+	reactIs_development.isForwardRef = isForwardRef;
+	reactIs_development.isFragment = isFragment;
+	reactIs_development.isLazy = isLazy;
+	reactIs_development.isMemo = isMemo;
+	reactIs_development.isPortal = isPortal;
+	reactIs_development.isProfiler = isProfiler;
+	reactIs_development.isStrictMode = isStrictMode;
+	reactIs_development.isSuspense = isSuspense;
+	reactIs_development.isValidElementType = isValidElementType;
+	reactIs_development.typeOf = typeOf;
+	  })();
+	}
+	return reactIs_development;
+}
+
+export { requireReactIs_development as __require };

package/dist/esm/_vendor/prop-types/_vendor/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,26 @@
+import { __exports as reactIs_production_min } from '../../../../../_virtual/react-is.production.min.js';
+
+/** @license React v16.13.1
+ * react-is.production.min.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 hasRequiredReactIs_production_min;
+
+function requireReactIs_production_min () {
+	if (hasRequiredReactIs_production_min) return reactIs_production_min;
+	hasRequiredReactIs_production_min = 1;
+var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+	Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+	function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
+	reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
+	reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
+	reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
+	return reactIs_production_min;
+}
+
+export { requireReactIs_production_min as __require };

package/dist/esm/_vendor/prop-types/_vendor/react-is/index.js

@@ -0,0 +1,19 @@
+import { __module as reactIs } from '../../../../_virtual/index2.js';
+import { __require as requireReactIs_production_min } from './cjs/react-is.production.min.js';
+import { __require as requireReactIs_development } from './cjs/react-is.development.js';
+
+var hasRequiredReactIs;
+
+function requireReactIs () {
+	if (hasRequiredReactIs) return reactIs.exports;
+	hasRequiredReactIs = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  reactIs.exports = requireReactIs_production_min();
+	} else {
+	  reactIs.exports = requireReactIs_development();
+	}
+	return reactIs.exports;
+}
+
+export { requireReactIs as __require };