@vincentgraul/react-components 1.0.2 → 1.0.4

package/build/cjs/node_modules/react-dom/client.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./index.js');
+var index = require('../../_virtual/index4.js');
+
+exports.hydrateRoot = void 0;
+exports.createRoot = void 0;
+
+var m = index.reactDom.exports;
+if (process.env.NODE_ENV === 'production') {
+  exports.createRoot = m.createRoot;
+  exports.hydrateRoot = m.hydrateRoot;
+} else {
+  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+  exports.createRoot = function(c, o) {
+    i.usingClientEntryPoint = true;
+    try {
+      return m.createRoot(c, o);
+    } finally {
+      i.usingClientEntryPoint = false;
+    }
+  };
+  exports.hydrateRoot = function(c, h, o) {
+    i.usingClientEntryPoint = true;
+    try {
+      return m.hydrateRoot(c, h, o);
+    } finally {
+      i.usingClientEntryPoint = false;
+    }
+  };
+}

package/build/cjs/node_modules/react-dom/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var _commonjsHelpers = require('../../_virtual/_commonjsHelpers.js');
+var index = require('../../_virtual/index4.js');
+var reactDom_production_min = require('./cjs/react-dom.production.min.js');
+var reactDom_development = require('./cjs/react-dom.development.js');
+
+(function (module) {
+
+	function checkDCE() {
+	  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	  if (
+	    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||
+	    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
+	  ) {
+	    return;
+	  }
+	  if (process.env.NODE_ENV !== 'production') {
+	    // This branch is unreachable because this function is only called
+	    // in production, but the condition is true only in development.
+	    // Therefore if the branch is still here, dead code elimination wasn't
+	    // properly applied.
+	    // Don't change the message. React DevTools relies on it. Also make sure
+	    // this message doesn't occur elsewhere in this function, or it will cause
+	    // a false positive.
+	    throw new Error('^_^');
+	  }
+	  try {
+	    // Verify that the code above has been dead code eliminated (DCE'd).
+	    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
+	  } catch (err) {
+	    // DevTools shouldn't crash React, no matter what.
+	    // We should still report in case we break this code.
+	    console.error(err);
+	  }
+	}
+
+	if (process.env.NODE_ENV === 'production') {
+	  // DCE check should happen before ReactDOM bundle executes so that
+	  // DevTools can report bad minification during injection.
+	  checkDCE();
+	  module.exports = reactDom_production_min.__require();
+	} else {
+	  module.exports = reactDom_development.__require();
+	}
+} (index.reactDom));
+
+var ReactDOM = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(index.reactDom.exports);
+
+module.exports = ReactDOM;

package/build/cjs/node_modules/react-dom/test-utils.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var testUtils = require('../../_virtual/test-utils.js');
+var reactDomTestUtils_production_min = require('./cjs/react-dom-test-utils.production.min.js');
+var reactDomTestUtils_development = require('./cjs/react-dom-test-utils.development.js');
+
+(function (module) {
+
+	if (process.env.NODE_ENV === 'production') {
+	  module.exports = reactDomTestUtils_production_min.__require();
+	} else {
+	  module.exports = reactDomTestUtils_development.__require();
+	}
+} (testUtils.testUtils));

package/build/cjs/node_modules/react-is/cjs/react-is.development.js

@@ -0,0 +1,234 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactIs_development = require('../../../_virtual/react-is.development.js');
+
+/**
+ * @license React
+ * 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.__exports;
+	hasRequiredReactIs_development = 1;
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	// ATTENTION
+	// When adding new symbols to this file,
+	// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+	// The Symbol used to tag the ReactElement-like types.
+	var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+	var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+	var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+	var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+	var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+	var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+	var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+	var REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+	var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+	var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+	var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+	var REACT_MEMO_TYPE = Symbol.for('react.memo');
+	var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+	var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+
+	// -----------------------------------------------------------------------------
+
+	var enableScopeAPI = false; // Experimental Create Event Handle API.
+	var enableCacheElement = false;
+	var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+	var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+	// stuff. Intended to enable React core members to more easily debug scheduling
+	// issues in DEV builds.
+
+	var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+	var REACT_MODULE_REFERENCE;
+
+	{
+	  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+	}
+
+	function isValidElementType(type) {
+	  if (typeof type === 'string' || typeof type === 'function') {
+	    return true;
+	  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+	  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+	    return true;
+	  }
+
+	  if (typeof type === 'object' && type !== null) {
+	    if (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 || // This needs to include all possible module reference object
+	    // types supported by any Flight configuration anywhere since
+	    // we don't know which Flight build this will end up being used
+	    // with.
+	    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+	      return true;
+	    }
+	  }
+
+	  return false;
+	}
+
+	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_FRAGMENT_TYPE:
+	          case REACT_PROFILER_TYPE:
+	          case REACT_STRICT_MODE_TYPE:
+	          case REACT_SUSPENSE_TYPE:
+	          case REACT_SUSPENSE_LIST_TYPE:
+	            return type;
+
+	          default:
+	            var $$typeofType = type && type.$$typeof;
+
+	            switch ($$typeofType) {
+	              case REACT_SERVER_CONTEXT_TYPE:
+	              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;
+	}
+	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 SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+	var hasWarnedAboutDeprecatedIsAsyncMode = false;
+	var hasWarnedAboutDeprecatedIsConcurrentMode = 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 18+.');
+	    }
+	  }
+
+	  return false;
+	}
+	function isConcurrentMode(object) {
+	  {
+	    if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+	      hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
+
+	      console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+	    }
+	  }
+
+	  return false;
+	}
+	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;
+	}
+	function isSuspenseList(object) {
+	  return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+	}
+
+	reactIs_development.__exports.ContextConsumer = ContextConsumer;
+	reactIs_development.__exports.ContextProvider = ContextProvider;
+	reactIs_development.__exports.Element = Element;
+	reactIs_development.__exports.ForwardRef = ForwardRef;
+	reactIs_development.__exports.Fragment = Fragment;
+	reactIs_development.__exports.Lazy = Lazy;
+	reactIs_development.__exports.Memo = Memo;
+	reactIs_development.__exports.Portal = Portal;
+	reactIs_development.__exports.Profiler = Profiler;
+	reactIs_development.__exports.StrictMode = StrictMode;
+	reactIs_development.__exports.Suspense = Suspense;
+	reactIs_development.__exports.SuspenseList = SuspenseList;
+	reactIs_development.__exports.isAsyncMode = isAsyncMode;
+	reactIs_development.__exports.isConcurrentMode = isConcurrentMode;
+	reactIs_development.__exports.isContextConsumer = isContextConsumer;
+	reactIs_development.__exports.isContextProvider = isContextProvider;
+	reactIs_development.__exports.isElement = isElement;
+	reactIs_development.__exports.isForwardRef = isForwardRef;
+	reactIs_development.__exports.isFragment = isFragment;
+	reactIs_development.__exports.isLazy = isLazy;
+	reactIs_development.__exports.isMemo = isMemo;
+	reactIs_development.__exports.isPortal = isPortal;
+	reactIs_development.__exports.isProfiler = isProfiler;
+	reactIs_development.__exports.isStrictMode = isStrictMode;
+	reactIs_development.__exports.isSuspense = isSuspense;
+	reactIs_development.__exports.isSuspenseList = isSuspenseList;
+	reactIs_development.__exports.isValidElementType = isValidElementType;
+	reactIs_development.__exports.typeOf = typeOf;
+	  })();
+	}
+	return reactIs_development.__exports;
+}
+
+exports.__require = requireReactIs_development;

package/build/cjs/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactIs_production_min = require('../../../_virtual/react-is.production.min.js');
+
+/**
+ * @license React
+ * 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.__exports;
+	hasRequiredReactIs_production_min = 1;
+var b=Symbol.for("react.element"),c=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),e=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.for("react.provider"),h=Symbol.for("react.context"),k=Symbol.for("react.server_context"),l=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),n=Symbol.for("react.suspense_list"),p=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),t=Symbol.for("react.offscreen"),u;u=Symbol.for("react.module.reference");
+	function v(a){if("object"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}reactIs_production_min.__exports.ContextConsumer=h;reactIs_production_min.__exports.ContextProvider=g;reactIs_production_min.__exports.Element=b;reactIs_production_min.__exports.ForwardRef=l;reactIs_production_min.__exports.Fragment=d;reactIs_production_min.__exports.Lazy=q;reactIs_production_min.__exports.Memo=p;reactIs_production_min.__exports.Portal=c;reactIs_production_min.__exports.Profiler=f;reactIs_production_min.__exports.StrictMode=e;reactIs_production_min.__exports.Suspense=m;
+	reactIs_production_min.__exports.SuspenseList=n;reactIs_production_min.__exports.isAsyncMode=function(){return !1};reactIs_production_min.__exports.isConcurrentMode=function(){return !1};reactIs_production_min.__exports.isContextConsumer=function(a){return v(a)===h};reactIs_production_min.__exports.isContextProvider=function(a){return v(a)===g};reactIs_production_min.__exports.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===b};reactIs_production_min.__exports.isForwardRef=function(a){return v(a)===l};reactIs_production_min.__exports.isFragment=function(a){return v(a)===d};reactIs_production_min.__exports.isLazy=function(a){return v(a)===q};reactIs_production_min.__exports.isMemo=function(a){return v(a)===p};
+	reactIs_production_min.__exports.isPortal=function(a){return v(a)===c};reactIs_production_min.__exports.isProfiler=function(a){return v(a)===f};reactIs_production_min.__exports.isStrictMode=function(a){return v(a)===e};reactIs_production_min.__exports.isSuspense=function(a){return v(a)===m};reactIs_production_min.__exports.isSuspenseList=function(a){return v(a)===n};
+	reactIs_production_min.__exports.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||"object"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};reactIs_production_min.__exports.typeOf=v;
+	return reactIs_production_min.__exports;
+}
+
+exports.__require = requireReactIs_production_min;

package/build/cjs/node_modules/react-is/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var index = require('../../_virtual/index2.js');
+var reactIs_production_min = require('./cjs/react-is.production.min.js');
+var reactIs_development = require('./cjs/react-is.development.js');
+
+(function (module) {
+
+	if (process.env.NODE_ENV === 'production') {
+	  module.exports = reactIs_production_min.__require();
+	} else {
+	  module.exports = reactIs_development.__require();
+	}
+} (index.reactIs));

package/build/cjs/node_modules/regexp.prototype.flags/implementation.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var implementation = require('../../_virtual/implementation.js');
+var index = require('../functions-have-names/index.js');
+
+(function (module) {
+
+	var functionsHaveConfigurableNames = index.functionsHaveConfigurableNames();
+
+	var $Object = Object;
+	var $TypeError = TypeError;
+
+	module.exports = function flags() {
+		if (this != null && this !== $Object(this)) {
+			throw new $TypeError('RegExp.prototype.flags getter called on non-object');
+		}
+		var result = '';
+		if (this.hasIndices) {
+			result += 'd';
+		}
+		if (this.global) {
+			result += 'g';
+		}
+		if (this.ignoreCase) {
+			result += 'i';
+		}
+		if (this.multiline) {
+			result += 'm';
+		}
+		if (this.dotAll) {
+			result += 's';
+		}
+		if (this.unicode) {
+			result += 'u';
+		}
+		if (this.sticky) {
+			result += 'y';
+		}
+		return result;
+	};
+
+	if (functionsHaveConfigurableNames && Object.defineProperty) {
+		Object.defineProperty(module.exports, 'name', { value: 'get flags' });
+	}
+} (implementation.implementation));

package/build/cjs/node_modules/regexp.prototype.flags/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var index = require('../define-properties/index.js');
+require('../call-bind/index.js');
+require('./implementation.js');
+var polyfill = require('./polyfill.js');
+var shim$1 = require('./shim.js');
+var index$1 = require('../../_virtual/index8.js');
+var implementation$1 = require('../../_virtual/implementation.js');
+
+var define = index;
+var callBind = index$1.callBind.exports;
+
+var implementation = implementation$1.implementation.exports;
+var getPolyfill = polyfill;
+var shim = shim$1;
+
+var flagsBound = callBind(getPolyfill());
+
+define(flagsBound, {
+	getPolyfill: getPolyfill,
+	implementation: implementation,
+	shim: shim
+});
+
+var regexp_prototype_flags = flagsBound;
+
+module.exports = regexp_prototype_flags;

package/build/cjs/node_modules/regexp.prototype.flags/polyfill.js

@@ -0,0 +1,42 @@
+'use strict';
+
+require('./implementation.js');
+var index = require('../define-properties/index.js');
+var implementation$1 = require('../../_virtual/implementation.js');
+
+var implementation = implementation$1.implementation.exports;
+
+var supportsDescriptors = index.supportsDescriptors;
+var $gOPD = Object.getOwnPropertyDescriptor;
+
+var polyfill = function getPolyfill() {
+	if (supportsDescriptors && (/a/mig).flags === 'gim') {
+		var descriptor = $gOPD(RegExp.prototype, 'flags');
+		if (
+			descriptor
+			&& typeof descriptor.get === 'function'
+			&& typeof RegExp.prototype.dotAll === 'boolean'
+			&& typeof RegExp.prototype.hasIndices === 'boolean'
+		) {
+			/* eslint getter-return: 0 */
+			var calls = '';
+			var o = {};
+			Object.defineProperty(o, 'hasIndices', {
+				get: function () {
+					calls += 'd';
+				}
+			});
+			Object.defineProperty(o, 'sticky', {
+				get: function () {
+					calls += 'y';
+				}
+			});
+			if (calls === 'dy') {
+				return descriptor.get;
+			}
+		}
+	}
+	return implementation;
+};
+
+module.exports = polyfill;

package/build/cjs/node_modules/regexp.prototype.flags/shim.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var index = require('../define-properties/index.js');
+var polyfill = require('./polyfill.js');
+
+var supportsDescriptors = index.supportsDescriptors;
+var getPolyfill = polyfill;
+var gOPD = Object.getOwnPropertyDescriptor;
+var defineProperty = Object.defineProperty;
+var TypeErr = TypeError;
+var getProto = Object.getPrototypeOf;
+var regex = /a/;
+
+var shim = function shimFlags() {
+	if (!supportsDescriptors || !getProto) {
+		throw new TypeErr('RegExp.prototype.flags requires a true ES5 environment that supports property descriptors');
+	}
+	var polyfill = getPolyfill();
+	var proto = getProto(regex);
+	var descriptor = gOPD(proto, 'flags');
+	if (!descriptor || descriptor.get !== polyfill) {
+		defineProperty(proto, 'flags', {
+			configurable: true,
+			enumerable: false,
+			get: polyfill
+		});
+	}
+	return polyfill;
+};
+
+module.exports = shim;