stream-engine-widgets 0.3.14 → 0.3.16

package/dist/{index-DRXk8TB6.js → index-BkAInKCv.js}

@@ -549,11 +549,11 @@ function S(r, a, s, i = {}) {
   }), c;
 }
 
-var propTypes = {exports: {}};
+var propTypes$1 = {exports: {}};
 
-var reactIs$2 = {exports: {}};
+var reactIs$3 = {exports: {}};
 
-var reactIs_development$1 = {};
+var reactIs_development$2 = {};
 
 /** @license React v16.13.1
  * react-is.development.js
@@ -680,42 +680,42 @@ var reactIs_development$1 = {};
     function isSuspense(object) {
       return typeOf(object) === REACT_SUSPENSE_TYPE;
     }
-    reactIs_development$1.AsyncMode = AsyncMode;
-    reactIs_development$1.ConcurrentMode = ConcurrentMode;
-    reactIs_development$1.ContextConsumer = ContextConsumer;
-    reactIs_development$1.ContextProvider = ContextProvider;
-    reactIs_development$1.Element = Element;
-    reactIs_development$1.ForwardRef = ForwardRef;
-    reactIs_development$1.Fragment = Fragment;
-    reactIs_development$1.Lazy = Lazy;
-    reactIs_development$1.Memo = Memo;
-    reactIs_development$1.Portal = Portal;
-    reactIs_development$1.Profiler = Profiler;
-    reactIs_development$1.StrictMode = StrictMode;
-    reactIs_development$1.Suspense = Suspense;
-    reactIs_development$1.isAsyncMode = isAsyncMode;
-    reactIs_development$1.isConcurrentMode = isConcurrentMode;
-    reactIs_development$1.isContextConsumer = isContextConsumer;
-    reactIs_development$1.isContextProvider = isContextProvider;
-    reactIs_development$1.isElement = isElement;
-    reactIs_development$1.isForwardRef = isForwardRef;
-    reactIs_development$1.isFragment = isFragment;
-    reactIs_development$1.isLazy = isLazy;
-    reactIs_development$1.isMemo = isMemo;
-    reactIs_development$1.isPortal = isPortal;
-    reactIs_development$1.isProfiler = isProfiler;
-    reactIs_development$1.isStrictMode = isStrictMode;
-    reactIs_development$1.isSuspense = isSuspense;
-    reactIs_development$1.isValidElementType = isValidElementType;
-    reactIs_development$1.typeOf = typeOf;
+    reactIs_development$2.AsyncMode = AsyncMode;
+    reactIs_development$2.ConcurrentMode = ConcurrentMode;
+    reactIs_development$2.ContextConsumer = ContextConsumer;
+    reactIs_development$2.ContextProvider = ContextProvider;
+    reactIs_development$2.Element = Element;
+    reactIs_development$2.ForwardRef = ForwardRef;
+    reactIs_development$2.Fragment = Fragment;
+    reactIs_development$2.Lazy = Lazy;
+    reactIs_development$2.Memo = Memo;
+    reactIs_development$2.Portal = Portal;
+    reactIs_development$2.Profiler = Profiler;
+    reactIs_development$2.StrictMode = StrictMode;
+    reactIs_development$2.Suspense = Suspense;
+    reactIs_development$2.isAsyncMode = isAsyncMode;
+    reactIs_development$2.isConcurrentMode = isConcurrentMode;
+    reactIs_development$2.isContextConsumer = isContextConsumer;
+    reactIs_development$2.isContextProvider = isContextProvider;
+    reactIs_development$2.isElement = isElement;
+    reactIs_development$2.isForwardRef = isForwardRef;
+    reactIs_development$2.isFragment = isFragment;
+    reactIs_development$2.isLazy = isLazy;
+    reactIs_development$2.isMemo = isMemo;
+    reactIs_development$2.isPortal = isPortal;
+    reactIs_development$2.isProfiler = isProfiler;
+    reactIs_development$2.isStrictMode = isStrictMode;
+    reactIs_development$2.isSuspense = isSuspense;
+    reactIs_development$2.isValidElementType = isValidElementType;
+    reactIs_development$2.typeOf = typeOf;
   })();
 }
 
 {
-  reactIs$2.exports = reactIs_development$1;
+  reactIs$3.exports = reactIs_development$2;
 }
 
-var reactIsExports$1 = reactIs$2.exports;
+var reactIsExports$2 = reactIs$3.exports;
 
 /*
 object-assign
@@ -723,11 +723,11 @@ object-assign
 @license MIT
 */
 /* eslint-disable no-unused-vars */
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+var getOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var propIsEnumerable$1 = Object.prototype.propertyIsEnumerable;
 
-function toObject(val) {
+function toObject$1(val) {
 	if (val === null || val === undefined) {
 		throw new TypeError('Object.assign cannot be called with null or undefined');
 	}
@@ -735,7 +735,7 @@ function toObject(val) {
 	return Object(val);
 }
 
-function shouldUseNative() {
+function shouldUseNative$1() {
 	try {
 		if (!Object.assign) {
 			return false;
@@ -779,24 +779,24 @@ function shouldUseNative() {
 	}
 }
 
-var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+var objectAssign$1 = shouldUseNative$1() ? Object.assign : function (target, source) {
 	var from;
-	var to = toObject(target);
+	var to = toObject$1(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)) {
+			if (hasOwnProperty$1.call(from, key)) {
 				to[key] = from[key];
 			}
 		}
 
-		if (getOwnPropertySymbols) {
-			symbols = getOwnPropertySymbols(from);
+		if (getOwnPropertySymbols$1) {
+			symbols = getOwnPropertySymbols$1(from);
 			for (var i = 0; i < symbols.length; i++) {
-				if (propIsEnumerable.call(from, symbols[i])) {
+				if (propIsEnumerable$1.call(from, symbols[i])) {
 					to[symbols[i]] = from[symbols[i]];
 				}
 			}
@@ -813,19 +813,19 @@ var objectAssign = shouldUseNative() ? Object.assign : function (target, source)
  * LICENSE file in the root directory of this source tree.
  */
 
-var ReactPropTypesSecret$2 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+var ReactPropTypesSecret$5 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
 
-var ReactPropTypesSecret_1 = ReactPropTypesSecret$2;
+var ReactPropTypesSecret_1$1 = ReactPropTypesSecret$5;
 
-var has$2 = Function.call.bind(Object.prototype.hasOwnProperty);
+var has$5 = Function.call.bind(Object.prototype.hasOwnProperty);
 
-var printWarning$1 = function() {
+var printWarning$3 = function() {
 };
 {
-  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
-  var loggedTypeFailures = {};
-  var has$1 = has$2;
-  printWarning$1 = function(text) {
+  var ReactPropTypesSecret$4 = ReactPropTypesSecret_1$1;
+  var loggedTypeFailures$1 = {};
+  var has$4 = has$5;
+  printWarning$3 = function(text) {
     var message = "Warning: " + text;
     if (typeof console !== "undefined") {
       console.error(message);
@@ -836,10 +836,10 @@ var printWarning$1 = function() {
     }
   };
 }
-function checkPropTypes$1(typeSpecs, values, location, componentName, getStack) {
+function checkPropTypes$3(typeSpecs, values, location, componentName, getStack) {
   {
     for (var typeSpecName in typeSpecs) {
-      if (has$1(typeSpecs, typeSpecName)) {
+      if (has$4(typeSpecs, typeSpecName)) {
         var error;
         try {
           if (typeof typeSpecs[typeSpecName] !== "function") {
@@ -849,19 +849,19 @@ function checkPropTypes$1(typeSpecs, values, location, componentName, getStack)
             err.name = "Invariant Violation";
             throw err;
           }
-          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
+          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$4);
         } catch (ex) {
           error = ex;
         }
         if (error && !(error instanceof Error)) {
-          printWarning$1(
+          printWarning$3(
             (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;
+        if (error instanceof Error && !(error.message in loggedTypeFailures$1)) {
+          loggedTypeFailures$1[error.message] = true;
           var stack = getStack ? getStack() : "";
-          printWarning$1(
+          printWarning$3(
             "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
           );
         }
@@ -869,22 +869,22 @@ function checkPropTypes$1(typeSpecs, values, location, componentName, getStack)
     }
   }
 }
-checkPropTypes$1.resetWarningCache = function() {
+checkPropTypes$3.resetWarningCache = function() {
   {
-    loggedTypeFailures = {};
+    loggedTypeFailures$1 = {};
   }
 };
-var checkPropTypes_1 = checkPropTypes$1;
+var checkPropTypes_1$1 = checkPropTypes$3;
 
-var ReactIs$1 = reactIsExports$1;
-var assign$1 = objectAssign;
-var ReactPropTypesSecret = ReactPropTypesSecret_1;
-var has = has$2;
-var checkPropTypes = checkPropTypes_1;
-var printWarning = function() {
+var ReactIs$3 = reactIsExports$2;
+var assign$2 = objectAssign$1;
+var ReactPropTypesSecret$3 = ReactPropTypesSecret_1$1;
+var has$3 = has$5;
+var checkPropTypes$2 = checkPropTypes_1$1;
+var printWarning$2 = function() {
 };
 {
-  printWarning = function(text) {
+  printWarning$2 = function(text) {
     var message = "Warning: " + text;
     if (typeof console !== "undefined") {
       console.error(message);
@@ -895,10 +895,10 @@ var printWarning = function() {
     }
   };
 }
-function emptyFunctionThatReturnsNull() {
+function emptyFunctionThatReturnsNull$1() {
   return null;
 }
-var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+var factoryWithTypeCheckers$1 = function(isValidElement, throwOnDirectAccess) {
   var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
   var FAUX_ITERATOR_SYMBOL = "@@iterator";
   function getIteratorFn(maybeIterable) {
@@ -950,7 +950,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
     function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
       componentName = componentName || ANONYMOUS;
       propFullName = propFullName || propName;
-      if (secret !== ReactPropTypesSecret) {
+      if (secret !== ReactPropTypesSecret$3) {
         if (throwOnDirectAccess) {
           var err = 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"
@@ -961,7 +961,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
           var cacheKey = componentName + ":" + propName;
           if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
           manualPropTypeWarningCount < 3) {
-            printWarning(
+            printWarning$2(
               "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;
@@ -1001,7 +1001,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
     return createChainableTypeChecker(validate);
   }
   function createAnyTypeChecker() {
-    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+    return createChainableTypeChecker(emptyFunctionThatReturnsNull$1);
   }
   function createArrayOfTypeChecker(typeChecker) {
     function validate(props, propName, componentName, location, propFullName) {
@@ -1014,7 +1014,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
         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);
+        var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret$3);
         if (error instanceof Error) {
           return error;
         }
@@ -1037,7 +1037,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
   function createElementTypeTypeChecker() {
     function validate(props, propName, componentName, location, propFullName) {
       var propValue = props[propName];
-      if (!ReactIs$1.isValidElementType(propValue)) {
+      if (!ReactIs$3.isValidElementType(propValue)) {
         var propType = getPropType(propValue);
         return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
       }
@@ -1060,14 +1060,14 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
     if (!Array.isArray(expectedValues)) {
       {
         if (arguments.length > 1) {
-          printWarning(
+          printWarning$2(
             "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.");
+          printWarning$2("Invalid argument supplied to oneOf, expected an array.");
         }
       }
-      return emptyFunctionThatReturnsNull;
+      return emptyFunctionThatReturnsNull$1;
     }
     function validate(props, propName, componentName, location, propFullName) {
       var propValue = props[propName];
@@ -1098,8 +1098,8 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
         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 (has$3(propValue, key)) {
+          var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret$3);
           if (error instanceof Error) {
             return error;
           }
@@ -1111,27 +1111,27 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
   }
   function createUnionTypeChecker(arrayOfTypeCheckers) {
     if (!Array.isArray(arrayOfTypeCheckers)) {
-      printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") ;
-      return emptyFunctionThatReturnsNull;
+      printWarning$2("Invalid argument supplied to oneOfType, expected an instance of array.") ;
+      return emptyFunctionThatReturnsNull$1;
     }
     for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
       var checker = arrayOfTypeCheckers[i];
       if (typeof checker !== "function") {
-        printWarning(
+        printWarning$2(
           "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
         );
-        return emptyFunctionThatReturnsNull;
+        return emptyFunctionThatReturnsNull$1;
       }
     }
     function validate(props, propName, componentName, location, propFullName) {
       var expectedTypes = [];
       for (var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
         var checker2 = arrayOfTypeCheckers[i2];
-        var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+        var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret$3);
         if (checkerResult == null) {
           return null;
         }
-        if (checkerResult.data && has(checkerResult.data, "expectedType")) {
+        if (checkerResult.data && has$3(checkerResult.data, "expectedType")) {
           expectedTypes.push(checkerResult.data.expectedType);
         }
       }
@@ -1166,7 +1166,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
         if (typeof checker !== "function") {
           return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
         }
-        var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+        var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret$3);
         if (error) {
           return error;
         }
@@ -1182,10 +1182,10 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
       if (propType !== "object") {
         return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
       }
-      var allKeys = assign$1({}, props[propName], shapeTypes);
+      var allKeys = assign$2({}, props[propName], shapeTypes);
       for (var key in allKeys) {
         var checker = shapeTypes[key];
-        if (has(shapeTypes, key) && typeof checker !== "function") {
+        if (has$3(shapeTypes, key) && typeof checker !== "function") {
           return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
         }
         if (!checker) {
@@ -1193,7 +1193,7 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
             "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);
+        var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret$3);
         if (error) {
           return error;
         }
@@ -1307,20 +1307,20 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
     }
     return propValue.constructor.name;
   }
-  ReactPropTypes.checkPropTypes = checkPropTypes;
-  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+  ReactPropTypes.checkPropTypes = checkPropTypes$2;
+  ReactPropTypes.resetWarningCache = checkPropTypes$2.resetWarningCache;
   ReactPropTypes.PropTypes = ReactPropTypes;
   return ReactPropTypes;
 };
 
 {
-  var ReactIs = reactIsExports$1;
-  var throwOnDirectAccess = true;
-  propTypes.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
+  var ReactIs$2 = reactIsExports$2;
+  var throwOnDirectAccess$1 = true;
+  propTypes$1.exports = factoryWithTypeCheckers$1(ReactIs$2.isElement, throwOnDirectAccess$1);
 }
 
-var propTypesExports = propTypes.exports;
-const PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
+var propTypesExports$1 = propTypes$1.exports;
+const PropTypes$1 = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports$1);
 
 const remotesMap = {
 'VFCMF':{url:'https://www.vfchannel.io/_next/static/chunks/remoteEntry.js',format:'var',from:'webpack'}
@@ -2376,6 +2376,779 @@ const deepmerge = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
   isPlainObject
 }, Symbol.toStringTag, { value: 'Module' }));
 
+var propTypes = {exports: {}};
+
+var reactIs$2 = {exports: {}};
+
+var reactIs_development$1 = {};
+
+/** @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.
+ */
+{
+  (function() {
+    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" || // 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 void 0;
+    }
+    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;
+    }
+    reactIs_development$1.AsyncMode = AsyncMode;
+    reactIs_development$1.ConcurrentMode = ConcurrentMode;
+    reactIs_development$1.ContextConsumer = ContextConsumer;
+    reactIs_development$1.ContextProvider = ContextProvider;
+    reactIs_development$1.Element = Element;
+    reactIs_development$1.ForwardRef = ForwardRef;
+    reactIs_development$1.Fragment = Fragment;
+    reactIs_development$1.Lazy = Lazy;
+    reactIs_development$1.Memo = Memo;
+    reactIs_development$1.Portal = Portal;
+    reactIs_development$1.Profiler = Profiler;
+    reactIs_development$1.StrictMode = StrictMode;
+    reactIs_development$1.Suspense = Suspense;
+    reactIs_development$1.isAsyncMode = isAsyncMode;
+    reactIs_development$1.isConcurrentMode = isConcurrentMode;
+    reactIs_development$1.isContextConsumer = isContextConsumer;
+    reactIs_development$1.isContextProvider = isContextProvider;
+    reactIs_development$1.isElement = isElement;
+    reactIs_development$1.isForwardRef = isForwardRef;
+    reactIs_development$1.isFragment = isFragment;
+    reactIs_development$1.isLazy = isLazy;
+    reactIs_development$1.isMemo = isMemo;
+    reactIs_development$1.isPortal = isPortal;
+    reactIs_development$1.isProfiler = isProfiler;
+    reactIs_development$1.isStrictMode = isStrictMode;
+    reactIs_development$1.isSuspense = isSuspense;
+    reactIs_development$1.isValidElementType = isValidElementType;
+    reactIs_development$1.typeOf = typeOf;
+  })();
+}
+
+{
+  reactIs$2.exports = reactIs_development$1;
+}
+
+var reactIsExports$1 = reactIs$2.exports;
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/* 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;
+	}
+}
+
+var 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;
+};
+
+/**
+ * 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 ReactPropTypesSecret$2 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$2;
+
+var has$2 = Function.call.bind(Object.prototype.hasOwnProperty);
+
+var printWarning$1 = function() {
+};
+{
+  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
+  var loggedTypeFailures = {};
+  var has$1 = has$2;
+  printWarning$1 = function(text) {
+    var message = "Warning: " + text;
+    if (typeof console !== "undefined") {
+      console.error(message);
+    }
+    try {
+      throw new Error(message);
+    } catch (x) {
+    }
+  };
+}
+function checkPropTypes$1(typeSpecs, values, location, componentName, getStack) {
+  {
+    for (var typeSpecName in typeSpecs) {
+      if (has$1(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$1);
+        } catch (ex) {
+          error = ex;
+        }
+        if (error && !(error instanceof Error)) {
+          printWarning$1(
+            (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$1(
+            "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
+          );
+        }
+      }
+    }
+  }
+}
+checkPropTypes$1.resetWarningCache = function() {
+  {
+    loggedTypeFailures = {};
+  }
+};
+var checkPropTypes_1 = checkPropTypes$1;
+
+var ReactIs$1 = reactIsExports$1;
+var assign$1 = objectAssign;
+var ReactPropTypesSecret = ReactPropTypesSecret_1;
+var has = has$2;
+var checkPropTypes = checkPropTypes_1;
+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;
+}
+var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+  var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+  var FAUX_ITERATOR_SYMBOL = "@@iterator";
+  function getIteratorFn(maybeIterable) {
+    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+    if (typeof iteratorFn === "function") {
+      return iteratorFn;
+    }
+  }
+  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
+  };
+  function is(x, y) {
+    if (x === y) {
+      return x !== 0 || 1 / x === 1 / y;
+    } else {
+      return x !== x && y !== y;
+    }
+  }
+  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 = 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] && // Avoid spamming the console because they are often not actionable except for lib authors
+          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];
+      var propType = getPropType(propValue);
+      if (propType !== 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$1.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) {
+        var type = getPreciseType(value);
+        if (type === "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 i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
+        var checker2 = arrayOfTypeCheckers[i2];
+        var checkerResult = checker2(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`."));
+      }
+      var allKeys = assign$1({}, props[propName], shapeTypes);
+      for (var key in allKeys) {
+        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;
+};
+
+{
+  var ReactIs = reactIsExports$1;
+  var throwOnDirectAccess = true;
+  propTypes.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
+}
+
+var propTypesExports = propTypes.exports;
+const PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
+
 /**
  * WARNING: Don't import this directly.
  * Use `MuiError` from `@mui/internal-babel-macros/MuiError.macro` instead.
@@ -69715,7 +70488,7 @@ function Player({ item, widgetToken, onClose, apiUrl }) {
       const { id: itemId } = item;
       try {
         const { data: result } = await axios$1.get(
-          `${apiUrl || "https://apiv3.videoflow.io"}/widgets/${widgetToken}?filter_by=${itemId}`
+          `${apiUrl || undefined                            }/widgets/${widgetToken}?filter_by=${itemId}`
         );
         const { name } = result;
         const input = result?.content[0];
@@ -69839,7 +70612,7 @@ function Player({ item, widgetToken, onClose, apiUrl }) {
   ] }) });
 }
 
-const {Suspense: Suspense$1,lazy: lazy$1,useEffect: useEffect$1,useState: useState$1,useRef} = await importShared('react');
+const {Suspense: Suspense$1,lazy: lazy$1,useEffect: useEffect$1,useState: useState$1} = await importShared('react');
 
 const __federation_var_VFCMFSectionGrid = await __federation_method_getRemote("VFCMF" , "./SectionGrid");
  let SectionGrid = __federation_method_unwrapDefault(__federation_var_VFCMFSectionGrid); 
@@ -69858,8 +70631,7 @@ const SECTION_COMPONENTS = {
   default: SectionGrid
 };
 const LoadingSpinner = () => /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "w-full h-full flex justify-center items-center py-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "bg-black/90 p-2 rounded-md", children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-white animate-pulse", children: "Loading..." }) }) });
-const Widget = ({ token, apiurl, viewerCountry }) => {
-  const widgetRef = useRef(null);
+const Widget = ({ token, apiurl }) => {
   const [widgetState, setWidgetState] = useState$1({
     data: {},
     untransformedData: {},
@@ -69872,30 +70644,13 @@ const Widget = ({ token, apiurl, viewerCountry }) => {
     isOpen: false,
     currentItem: null
   });
-  const dispatchWidgetEvent = (eventType, eventData) => {
-    if (widgetRef.current) {
-      const customEvent = new CustomEvent(`widget-${eventType}`, {
-        detail: {
-          ...eventData,
-          widgetToken: token,
-          timestamp: Date.now()
-        },
-        bubbles: true,
-        cancelable: true
-      });
-      widgetRef.current.dispatchEvent(customEvent);
-    }
-  };
-  const blazeEventHandlers = {
-    onDataLoadCompleted: (eventData) => dispatchWidgetEvent("data-loaded", eventData)
-  };
   const handleClosePlayer = () => {
     setPlayerState({
       isOpen: false,
       currentItem: null
     });
   };
-  const apiUrl = apiurl || "https://apiv3.videoflow.io";
+  const apiUrl = apiurl || undefined                            ;
   const widgetDataToSectionData = (data2) => {
     if (data2.type === VIDEO_SECTION_TYPE) {
       return {
@@ -69939,15 +70694,6 @@ const Widget = ({ token, apiurl, viewerCountry }) => {
         */
       };
     }
-    if (data2.type === BLAZE_WIDGET_TYPE) {
-      return {
-        data: data2,
-        // Pass the blaze data directly
-        apiUrl,
-        eventHandlers: blazeEventHandlers
-        // Pass event handlers to Blaze widget
-      };
-    }
     return {
       data: data2,
       apiUrl
@@ -69966,9 +70712,9 @@ const Widget = ({ token, apiurl, viewerCountry }) => {
       return SECTION_COMPONENTS[layout] || SECTION_COMPONENTS.default;
     }
     if (type2 === BLAZE_WIDGET_TYPE) {
-      return lazy$1(() => import('./blaze-widget-COvQjzxN.js'));
+      return lazy$1(() => import('./blaze-BOFmpQ80.js'));
     }
-    return lazy$1(() => __variableDynamicImportRuntimeHelper((/* #__PURE__ */ Object.assign({"./widgets/gallery/gallery.jsx": () => import('./gallery-Bj7HaEKS.js'),"./widgets/matches/matches.jsx": () => import('./matches-BYGBQOdB.js'),"./widgets/matchesStandalone/matchesStandalone.jsx": () => import('./matchesStandalone-fkyfgYtI.js'),"./widgets/player/player.jsx": () => import('./player-BpFZSk7h.js'),"./widgets/poster/poster.jsx": () => import('./poster-gBj_BEdS.js'),"./widgets/poster/posterItem.jsx": () => import('./posterItem-COVgC8zh.js'),"./widgets/scroll/scroll.jsx": () => import('./scroll-DcdnfMG4.js'),"./widgets/story/story.jsx": () => import('./story-CH4qV2PF.js')})), `./widgets/${type2}/${type2}.jsx`, 4));
+    return lazy$1(() => __variableDynamicImportRuntimeHelper((/* #__PURE__ */ Object.assign({"./widgets/gallery/gallery.jsx": () => import('./gallery-GRnjldyr.js'),"./widgets/matches/matches.jsx": () => import('./matches-CCFg5Xd1.js'),"./widgets/matchesStandalone/matchesStandalone.jsx": () => import('./matchesStandalone-K-T-YXDH.js'),"./widgets/player/player.jsx": () => import('./player-BkFsXlEi.js'),"./widgets/poster/poster.jsx": () => import('./poster-BFthK88T.js'),"./widgets/poster/posterItem.jsx": () => import('./posterItem-BojAdnBI.js'),"./widgets/scroll/scroll.jsx": () => import('./scroll-Cm_Q9RJ9.js'),"./widgets/story/story.jsx": () => import('./story-BbKazkAh.js')})), `./widgets/${type2}/${type2}.jsx`, 4));
   };
   useEffect$1(() => {
     const fetchData = async () => {
@@ -70004,7 +70750,7 @@ const Widget = ({ token, apiurl, viewerCountry }) => {
   const { data, loading, error, Component, type } = widgetState;
   if (loading) return /* @__PURE__ */ jsxRuntimeExports.jsx(LoadingSpinner, {});
   if (error) return null;
-  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { ref: widgetRef, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Suspense$1, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx(LoadingSpinner, {}), children: Component && (type === VIDEO_SECTION_TYPE ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Suspense$1, { fallback: /* @__PURE__ */ jsxRuntimeExports.jsx(LoadingSpinner, {}), children: Component && (type === VIDEO_SECTION_TYPE ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
     /* @__PURE__ */ jsxRuntimeExports.jsx(Component, { ...data }),
     playerState.isOpen && playerState.currentItem && /* @__PURE__ */ jsxRuntimeExports.jsx(
       Player,
@@ -70016,15 +70762,7 @@ const Widget = ({ token, apiurl, viewerCountry }) => {
         apiUrl
       }
     )
-  ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx(
-    Component,
-    {
-      data: data.data,
-      apiUrl: data.apiUrl,
-      viewerCountry,
-      eventHandlers: data.eventHandlers
-    }
-  )) }) });
+  ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx(Component, { data: data.data, apiUrl: data.apiUrl })) });
 };
 
 const {useState,useEffect,lazy,Suspense} = await importShared('react');
@@ -70035,7 +70773,7 @@ const ChannelWidget = ({ token, type }) => {
   const [Component, setComponent] = useState();
   const getData = async () => {
     console.log(`Pulling data from: ${token}`);
-    const res = await fetch(`${"https://apiv3.videoflow.io"}/widgets/channel/${token}`);
+    const res = await fetch(`${undefined                            }/widgets/channel/${token}`);
     if (res.ok) {
       const resData = await res.json();
       console.log(resData);
@@ -70059,19 +70797,19 @@ const ChannelWidget = ({ token, type }) => {
 };
 
 const React = await importShared('react');
-{
-  Widget.propTypes = {
-    token: PropTypes.string,
-    apiurl: PropTypes.string,
-    viewerCountry: PropTypes.string
-  };
-  ChannelWidget.propTypes = {
-    token: PropTypes.string,
-    type: PropTypes.string
-  };
-  customElements.define("vf-widget", S(Widget, React, ReactDOM));
-  customElements.define("vfc-widget", S(ChannelWidget, React, ReactDOM));
-}
+
+Widget.propTypes = {
+  token   : PropTypes$1.string,
+  apiurl  : PropTypes$1.string
+};
+
+ChannelWidget.propTypes = {
+  token : PropTypes$1.string,
+  type  : PropTypes$1.string
+};
+
+customElements.define("vf-widget", S(Widget, React, ReactDOM));
+customElements.define("vfc-widget", S(ChannelWidget, React, ReactDOM));
 
 export { CloseRounded as C, Player as P, SpinLoader as S, Thumbnail as T, _extendsExports as _, axios$1 as a, _extends$1 as b, createSvgIcon as c, importShared as i, jsxRuntimeExports as j };
-//# sourceMappingURL=index-DRXk8TB6.js.map
+//# sourceMappingURL=index-BkAInKCv.js.map