@pixui-dev/pxw 0.1.16

package/lib/assets/preact.js

@@ -0,0 +1,4354 @@
+/******/ var __webpack_modules__ = {
+	/***/ './compat/src/Children.js':
+	/*!********************************!*\
+  !*** ./compat/src/Children.js ***!
+  \********************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ Children: () => /* binding */ Children,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+
+		var mapFn = function mapFn(children, fn) {
+			if (children == null) return null;
+			return (0, preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(
+				(0, preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(children).map(
+					fn
+				)
+			);
+		};
+
+		// This API is completely unnecessary for Preact, so it's basically passthrough.
+		var Children = {
+			map: mapFn,
+			forEach: mapFn,
+			count: function count(children) {
+				return children
+					? (0, preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(children)
+						.length
+					: 0;
+			},
+			only: function only(children) {
+				var normalized = (0,
+				preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(children);
+				if (normalized.length !== 1) throw 'Children.only';
+				return normalized[0];
+			},
+			toArray: preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray,
+		};
+
+		/***/
+	},
+
+	/***/ './compat/src/PureComponent.js':
+	/*!*************************************!*\
+  !*** ./compat/src/PureComponent.js ***!
+  \*************************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ PureComponent: () => /* binding */ PureComponent,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./util */ './compat/src/util.js');
+
+		/**
+       * Component class with a predefined `shouldComponentUpdate` implementation
+       */
+		function PureComponent(p) {
+			this.props = p;
+		}
+		PureComponent.prototype =
+        new preact__WEBPACK_IMPORTED_MODULE_0__.Component();
+		// Some third-party libraries check if this property is present
+		PureComponent.prototype.isPureReactComponent = true;
+		PureComponent.prototype.shouldComponentUpdate = function (props, state) {
+			return (
+				(0, _util__WEBPACK_IMPORTED_MODULE_1__.shallowDiffers)(
+					this.props,
+					props
+				) ||
+          (0, _util__WEBPACK_IMPORTED_MODULE_1__.shallowDiffers)(
+          	this.state,
+          	state
+          )
+			);
+		};
+
+		/***/
+	},
+
+	/***/ './compat/src/forwardRef.js':
+	/*!**********************************!*\
+  !*** ./compat/src/forwardRef.js ***!
+  \**********************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ REACT_FORWARD_SYMBOL: () =>
+			/* binding */ REACT_FORWARD_SYMBOL,
+			/* harmony export */ forwardRef: () => /* binding */ forwardRef,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./util */ './compat/src/util.js');
+
+		var oldDiffHook = preact__WEBPACK_IMPORTED_MODULE_0__.options.__b;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__b = function (vnode) {
+			if (vnode.type && vnode.type.__f && vnode.ref) {
+				vnode.props.ref = vnode.ref;
+				vnode.ref = null;
+			}
+			if (oldDiffHook) oldDiffHook(vnode);
+		};
+		var REACT_FORWARD_SYMBOL =
+        (typeof Symbol != 'undefined' &&
+          Symbol.for &&
+          Symbol.for('react.forward_ref')) ||
+        0xf47;
+
+		/**
+       * Pass ref down to a child. This is mainly used in libraries with HOCs that
+       * wrap components. Using `forwardRef` there is an easy way to get a reference
+       * of the wrapped component instead of one of the wrapper itself.
+       * @param {import('./index').ForwardFn} fn
+       * @returns {import('./internal').FunctionComponent}
+       */
+		function forwardRef(fn) {
+			function Forwarded(props) {
+				var clone = (0, _util__WEBPACK_IMPORTED_MODULE_1__.assign)({}, props);
+				delete clone.ref;
+				return fn(clone, props.ref || null);
+			}
+
+			// mobx-react checks for this being present
+			Forwarded.$$typeof = REACT_FORWARD_SYMBOL;
+			// mobx-react heavily relies on implementation details.
+			// It expects an object here with a `render` property,
+			// and prototype.render will fail. Without this
+			// mobx-react throws.
+			Forwarded.render = Forwarded;
+			Forwarded.prototype.isReactComponent = Forwarded.__f = true;
+			Forwarded.displayName =
+          'ForwardRef(' + (fn.displayName || fn.name) + ')';
+			return Forwarded;
+		}
+
+		/***/
+	},
+
+	/***/ './compat/src/memo.js':
+	/*!****************************!*\
+  !*** ./compat/src/memo.js ***!
+  \****************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ memo: () => /* binding */ memo,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./util */ './compat/src/util.js');
+
+		/**
+       * Memoize a component, so that it only updates when the props actually have
+       * changed. This was previously known as `React.pure`.
+       * @param {import('./internal').FunctionComponent} c functional component
+       * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function
+       * @returns {import('./internal').FunctionComponent}
+       */
+		function memo(c, comparer) {
+			function shouldUpdate(nextProps) {
+				var ref = this.props.ref;
+				var updateRef = ref == nextProps.ref;
+				if (!updateRef && ref) {
+					ref.call ? ref(null) : (ref.current = null);
+				}
+				if (!comparer) {
+					return (0, _util__WEBPACK_IMPORTED_MODULE_1__.shallowDiffers)(
+						this.props,
+						nextProps
+					);
+				}
+				return !comparer(this.props, nextProps) || !updateRef;
+			}
+			function Memoed(props) {
+				this.shouldComponentUpdate = shouldUpdate;
+				return (0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+					c,
+					props
+				);
+			}
+			Memoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';
+			Memoed.prototype.isReactComponent = true;
+			Memoed.__f = true;
+			return Memoed;
+		}
+
+		/***/
+	},
+
+	/***/ './compat/src/portals.js':
+	/*!*******************************!*\
+  !*** ./compat/src/portals.js ***!
+  \*******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ createPortal: () => /* binding */ createPortal,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+
+		/**
+       * @param {import('../../src/index').RenderableProps<{ context: any }>} props
+       */
+		function ContextProvider(props) {
+			this.getChildContext = function () {
+				return props.context;
+			};
+			return props.children;
+		}
+
+		/**
+       * Portal component
+       * @this {import('./internal').Component}
+       * @param {object | null | undefined} props
+       *
+       * TODO: use createRoot() instead of fake root
+       */
+		function Portal(props) {
+			var _this = this;
+			var container = props._container;
+			_this.componentWillUnmount = function () {
+				(0, preact__WEBPACK_IMPORTED_MODULE_0__.render)(null, _this._temp);
+				_this._temp = null;
+				_this._container = null;
+			};
+
+			// When we change container we should clear our old container and
+			// indicate a new mount.
+			if (_this._container && _this._container !== container) {
+				_this.componentWillUnmount();
+			}
+
+			// When props.vnode is undefined/false/null we are dealing with some kind of
+			// conditional vnode. This should not trigger a render.
+			if (props.__v) {
+				if (!_this._temp) {
+					_this._container = container;
+
+					// Create a fake DOM parent node that manages a subset of `container`'s children:
+					_this._temp = {
+						nodeType: 1,
+						parentNode: container,
+						childNodes: [],
+						appendChild: function appendChild(child) {
+							this.childNodes.push(child);
+							_this._container.appendChild(child);
+						},
+						insertBefore: function insertBefore(child, before) {
+							this.childNodes.push(child);
+							_this._container.appendChild(child);
+						},
+						removeChild: function removeChild(child) {
+							this.childNodes.splice(this.childNodes.indexOf(child) >>> 1, 1);
+							_this._container.removeChild(child);
+						},
+					};
+				}
+
+				// Render our wrapping element into temp.
+				(0, preact__WEBPACK_IMPORTED_MODULE_0__.render)(
+					(0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+						ContextProvider,
+						{
+							context: _this.context,
+						},
+						props.__v
+					),
+					_this._temp
+				);
+			}
+			// When we come from a conditional render, on a mounted
+			// portal we should clear the DOM.
+			else if (_this._temp) {
+				_this.componentWillUnmount();
+			}
+		}
+
+		/**
+       * Create a `Portal` to continue rendering the vnode tree at a different DOM node
+       * @param {import('./internal').VNode} vnode The vnode to render
+       * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.
+       */
+		function createPortal(vnode, container) {
+			var el = (0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+				Portal,
+				{
+					__v: vnode,
+					_container: container,
+				}
+			);
+			el.containerInfo = container;
+			return el;
+		}
+
+		/***/
+	},
+
+	/***/ './compat/src/render.js':
+	/*!******************************!*\
+  !*** ./compat/src/render.js ***!
+  \******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ REACT_ELEMENT_TYPE: () =>
+			/* binding */ REACT_ELEMENT_TYPE,
+			/* harmony export */ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:
+          () =>
+          /* binding */ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+			/* harmony export */ hydrate: () => /* binding */ hydrate,
+			/* harmony export */ render: () => /* binding */ render,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		function _typeof(obj) {
+			'@babel/helpers - typeof';
+			return (
+				(_typeof =
+            'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator
+            	? function (obj) {
+            		return typeof obj;
+            	}
+            	: function (obj) {
+            		return obj &&
+                    'function' == typeof Symbol &&
+                    obj.constructor === Symbol &&
+                    obj !== Symbol.prototype
+            			? 'symbol'
+            			: typeof obj;
+            	}),
+				_typeof(obj)
+			);
+		}
+
+		var REACT_ELEMENT_TYPE =
+        (typeof Symbol != 'undefined' &&
+          Symbol.for &&
+          Symbol.for('react.element')) ||
+        0xeac7;
+		var CAMEL_PROPS =
+        /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
+		var IS_DOM = typeof document !== 'undefined';
+
+		// Input types for which onchange should not be converted to oninput.
+		// type="file|checkbox|radio", plus "range" in IE11.
+		// (IE11 doesn't support Symbol, which we use here to turn `rad` into `ra` which matches "range")
+		var onChangeInputType = function onChangeInputType(type) {
+			return (
+				typeof Symbol != 'undefined' && _typeof(Symbol()) == 'symbol'
+					? /fil|che|rad/i
+					: /fil|che|ra/i
+			).test(type);
+		};
+
+		// Some libraries like `react-virtualized` explicitly check for this.
+		preact__WEBPACK_IMPORTED_MODULE_0__.Component.prototype.isReactComponent =
+        {};
+
+		// `UNSAFE_*` lifecycle hooks
+		// Preact only ever invokes the unprefixed methods.
+		// Here we provide a base "fallback" implementation that calls any defined UNSAFE_ prefixed method.
+		// - If a component defines its own `componentDidMount()` (including via defineProperty), use that.
+		// - If a component defines `UNSAFE_componentDidMount()`, `componentDidMount` is the alias getter/setter.
+		// - If anything assigns to an `UNSAFE_*` property, the assignment is forwarded to the unprefixed property.
+		// See https://github.com/preactjs/preact/issues/1941
+		[
+			'componentWillMount',
+			'componentWillReceiveProps',
+			'componentWillUpdate',
+		].forEach(function (key) {
+			Object.defineProperty(
+				preact__WEBPACK_IMPORTED_MODULE_0__.Component.prototype,
+				key,
+				{
+					configurable: true,
+					get: function get() {
+						return this['UNSAFE_' + key];
+					},
+					set: function set(v) {
+						Object.defineProperty(this, key, {
+							configurable: true,
+							writable: true,
+							value: v,
+						});
+					},
+				}
+			);
+		});
+
+		/**
+       * Proxy render() since React returns a Component reference.
+       * @param {import('./internal').VNode} vnode VNode tree to render
+       * @param {import('./internal').PreactElement} parent DOM node to render vnode tree into
+       * @param {() => void} [callback] Optional callback that will be called after rendering
+       * @returns {import('./internal').Component | null} The root component reference or null
+       */
+		function render(vnode, parent, callback) {
+			// React destroys any existing DOM nodes, see #1727
+			// ...but only on the first render, see #1828
+			if (parent.__k == null) {
+				parent.textContent = '';
+			}
+			(0, preact__WEBPACK_IMPORTED_MODULE_0__.render)(vnode, parent);
+			if (typeof callback == 'function') callback();
+			return vnode ? vnode.__c : null;
+		}
+		function hydrate(vnode, parent, callback) {
+			(0, preact__WEBPACK_IMPORTED_MODULE_0__.hydrate)(vnode, parent);
+			if (typeof callback == 'function') callback();
+			return vnode ? vnode.__c : null;
+		}
+		var oldEventHook = preact__WEBPACK_IMPORTED_MODULE_0__.options.event;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.event = function (e) {
+			if (oldEventHook) e = oldEventHook(e);
+			e.persist = empty;
+			e.isPropagationStopped = isPropagationStopped;
+			e.isDefaultPrevented = isDefaultPrevented;
+			return (e.nativeEvent = e);
+		};
+		function empty() {}
+		function isPropagationStopped() {
+			return this.cancelBubble;
+		}
+		function isDefaultPrevented() {
+			return this.defaultPrevented;
+		}
+		var classNameDescriptor = {
+			configurable: true,
+			get: function get() {
+				return this.class;
+			},
+		};
+		var oldVNodeHook = preact__WEBPACK_IMPORTED_MODULE_0__.options.vnode;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.vnode = function (vnode) {
+			var type = vnode.type;
+			var props = vnode.props;
+			var normalizedProps = props;
+
+			// only normalize props on Element nodes
+			if (typeof type === 'string') {
+				var nonCustomElement = type.indexOf('-') === -1;
+				normalizedProps = {};
+				for (var i in props) {
+					var value = props[i];
+					if (IS_DOM && i === 'children' && type === 'noscript') {
+						// Emulate React's behavior of not rendering the contents of noscript tags on the client.
+						continue;
+					}
+					else if (
+						i === 'value' &&
+              'defaultValue' in props &&
+              value == null
+					) {
+						// Skip applying value if it is null/undefined and we already set
+						// a default value
+						continue;
+					}
+					else if (
+						i === 'defaultValue' &&
+              'value' in props &&
+              props.value == null
+					) {
+						// `defaultValue` is treated as a fallback `value` when a value prop is present but null/undefined.
+						// `defaultValue` for Elements with no value prop is the same as the DOM defaultValue property.
+						i = 'value';
+					}
+					else if (i === 'download' && value === true) {
+						// Calling `setAttribute` with a truthy value will lead to it being
+						// passed as a stringified value, e.g. `download="true"`. React
+						// converts it to an empty string instead, otherwise the attribute
+						// value will be used as the file name and the file will be called
+						// "true" upon downloading it.
+						value = '';
+					}
+					else if (/ondoubleclick/i.test(i)) {
+						i = 'ondblclick';
+					}
+					else if (
+						/^onchange(textarea|input)/i.test(i + type) &&
+              !onChangeInputType(props.type)
+					) {
+						i = 'oninput';
+					}
+					else if (/^onfocus$/i.test(i)) {
+						i = 'onfocusin';
+					}
+					else if (/^onblur$/i.test(i)) {
+						i = 'onfocusout';
+					}
+					else if (/^on(Ani|Tra|Tou|BeforeInp|Compo)/.test(i)) {
+						i = i.toLowerCase();
+					}
+					else if (nonCustomElement && CAMEL_PROPS.test(i)) {
+						i = i.replace(/[A-Z0-9]/g, '-$&').toLowerCase();
+					}
+					else if (value === null) {
+						value = undefined;
+					}
+
+					// Add support for onInput and onChange, see #3561
+					// if we have an oninput prop already change it to oninputCapture
+					if (/^oninput$/i.test(i)) {
+						i = i.toLowerCase();
+						if (normalizedProps[i]) {
+							i = 'oninputCapture';
+						}
+					}
+					normalizedProps[i] = value;
+				}
+
+				// Add support for array select values: <select multiple value={[]} />
+				if (
+					type == 'select' &&
+            normalizedProps.multiple &&
+            Array.isArray(normalizedProps.value)
+				) {
+					// forEach() always returns undefined, which we abuse here to unset the value prop.
+					normalizedProps.value = (0,
+					preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(
+						props.children
+					).forEach(function (child) {
+						child.props.selected =
+                normalizedProps.value.indexOf(child.props.value) != -1;
+					});
+				}
+
+				// Adding support for defaultValue in select tag
+				if (type == 'select' && normalizedProps.defaultValue != null) {
+					normalizedProps.value = (0,
+					preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(
+						props.children
+					).forEach(function (child) {
+						if (normalizedProps.multiple) {
+							child.props.selected =
+                  normalizedProps.defaultValue.indexOf(child.props.value) != -1;
+						}
+						else {
+							child.props.selected =
+                  normalizedProps.defaultValue == child.props.value;
+						}
+					});
+				}
+				vnode.props = normalizedProps;
+				if (props.class != props.className) {
+					classNameDescriptor.enumerable = 'className' in props;
+					if (props.className != null)
+						normalizedProps.class = props.className;
+					Object.defineProperty(
+						normalizedProps,
+						'className',
+						classNameDescriptor
+					);
+				}
+			}
+			vnode.$$typeof = REACT_ELEMENT_TYPE;
+			if (oldVNodeHook) oldVNodeHook(vnode);
+		};
+
+		// Only needed for react-relay
+		var currentComponent;
+		var oldBeforeRender = preact__WEBPACK_IMPORTED_MODULE_0__.options.__r;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__r = function (vnode) {
+			if (oldBeforeRender) {
+				oldBeforeRender(vnode);
+			}
+			currentComponent = vnode.__c;
+		};
+
+		// This is a very very private internal function for React it
+		// is used to sort-of do runtime dependency injection. So far
+		// only `react-relay` makes use of it. It uses it to read the
+		// context value.
+		var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
+			ReactCurrentDispatcher: {
+				current: {
+					readContext: function readContext(context) {
+						return currentComponent.__n[context.__c].props.value;
+					},
+				},
+			},
+		};
+
+		/***/
+	},
+
+	/***/ './compat/src/suspense-list.js':
+	/*!*************************************!*\
+  !*** ./compat/src/suspense-list.js ***!
+  \*************************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ SuspenseList: () => /* binding */ SuspenseList,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		/* harmony import */ var _suspense_js__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./suspense.js */ './compat/src/suspense.js');
+
+		// Indexes to linked list nodes (nodes are stored as arrays to save bytes).
+		var SUSPENDED_COUNT = 0;
+		var RESOLVED_COUNT = 1;
+		var NEXT_NODE = 2;
+
+		// Having custom inheritance instead of a class here saves a lot of bytes.
+		function SuspenseList() {
+			this._next = null;
+			this._map = null;
+		}
+
+		// Mark one of child's earlier suspensions as resolved.
+		// Some pending callbacks may become callable due to this
+		// (e.g. the last suspended descendant gets resolved when
+		// revealOrder === 'together'). Process those callbacks as well.
+		var resolve = function resolve(list, child, node) {
+			if (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {
+				// The number a child (or any of its descendants) has been suspended
+				// matches the number of times it's been resolved. Therefore we
+				// mark the child as completely resolved by deleting it from ._map.
+				// This is used to figure out when *all* children have been completely
+				// resolved when revealOrder is 'together'.
+				list._map.delete(child);
+			}
+
+			// If revealOrder is falsy then we can do an early exit, as the
+			// callbacks won't get queued in the node anyway.
+			// If revealOrder is 'together' then also do an early exit
+			// if all suspended descendants have not yet been resolved.
+			if (
+				!list.props.revealOrder ||
+          (list.props.revealOrder[0] === 't' && list._map.size)
+			) {
+				return;
+			}
+
+			// Walk the currently suspended children in order, calling their
+			// stored callbacks on the way. Stop if we encounter a child that
+			// has not been completely resolved yet.
+			node = list._next;
+			while (node) {
+				while (node.length > 3) {
+					node.pop()();
+				}
+				if (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {
+					break;
+				}
+				list._next = node = node[NEXT_NODE];
+			}
+		};
+
+		// Things we do here to save some bytes but are not proper JS inheritance:
+		// - call `new Component()` as the prototype
+		// - do not set `Suspense.prototype.constructor` to `Suspense`
+		SuspenseList.prototype =
+        new preact__WEBPACK_IMPORTED_MODULE_0__.Component();
+		SuspenseList.prototype.__a = function (child) {
+			var list = this;
+			var delegated = (0,
+			_suspense_js__WEBPACK_IMPORTED_MODULE_1__.suspended)(list.__v);
+			var node = list._map.get(child);
+			node[SUSPENDED_COUNT]++;
+			return function (unsuspend) {
+				var wrappedUnsuspend = function wrappedUnsuspend() {
+					if (!list.props.revealOrder) {
+						// Special case the undefined (falsy) revealOrder, as there
+						// is no need to coordinate a specific order or unsuspends.
+						unsuspend();
+					}
+					else {
+						node.push(unsuspend);
+						resolve(list, child, node);
+					}
+				};
+				if (delegated) {
+					delegated(wrappedUnsuspend);
+				}
+				else {
+					wrappedUnsuspend();
+				}
+			};
+		};
+		SuspenseList.prototype.render = function (props) {
+			this._next = null;
+			this._map = new Map();
+			var children = (0, preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray)(
+				props.children
+			);
+			if (props.revealOrder && props.revealOrder[0] === 'b') {
+				// If order === 'backwards' (or, well, anything starting with a 'b')
+				// then flip the child list around so that the last child will be
+				// the first in the linked list.
+				children.reverse();
+			}
+			// Build the linked list. Iterate through the children in reverse order
+			// so that `_next` points to the first linked list node to be resolved.
+			for (var i = children.length; i--; ) {
+				// Create a new linked list node as an array of form:
+				// 	[suspended_count, resolved_count, next_node]
+				// where suspended_count and resolved_count are numeric counters for
+				// keeping track how many times a node has been suspended and resolved.
+				//
+				// Note that suspended_count starts from 1 instead of 0, so we can block
+				// processing callbacks until componentDidMount has been called. In a sense
+				// node is suspended at least until componentDidMount gets called!
+				//
+				// Pending callbacks are added to the end of the node:
+				// 	[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]
+				this._map.set(children[i], (this._next = [1, 0, this._next]));
+			}
+			return props.children;
+		};
+		SuspenseList.prototype.componentDidUpdate =
+        SuspenseList.prototype.componentDidMount = function () {
+        	var _this = this;
+        	// Iterate through all children after mounting for two reasons:
+        	// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases
+        	//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.
+        	//    The nodes can now be completely consumed from the linked list.
+        	// 2. Handle nodes that might have gotten resolved between render and
+        	//    componentDidMount.
+        	this._map.forEach(function (node, child) {
+        		resolve(_this, child, node);
+        	});
+        };
+
+		/***/
+	},
+
+	/***/ './compat/src/suspense.js':
+	/*!********************************!*\
+  !*** ./compat/src/suspense.js ***!
+  \********************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ Suspense: () => /* binding */ Suspense,
+			/* harmony export */ lazy: () => /* binding */ lazy,
+			/* harmony export */ suspended: () => /* binding */ suspended,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./util */ './compat/src/util.js');
+
+		var oldCatchError = preact__WEBPACK_IMPORTED_MODULE_0__.options.__e;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__e = function (
+			error,
+			newVNode,
+			oldVNode,
+			errorInfo
+		) {
+			if (error.then) {
+				/** @type {import('./internal').Component} */
+				var component;
+				var vnode = newVNode;
+				for (; (vnode = vnode.__); ) {
+					if ((component = vnode.__c) && component.__c) {
+						if (newVNode.__e == null) {
+							newVNode.__e = oldVNode.__e;
+							newVNode.__k = oldVNode.__k;
+						}
+						// Don't call oldCatchError if we found a Suspense
+						return component.__c(error, newVNode);
+					}
+				}
+			}
+			oldCatchError(error, newVNode, oldVNode, errorInfo);
+		};
+		var oldUnmount = preact__WEBPACK_IMPORTED_MODULE_0__.options.unmount;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.unmount = function (vnode) {
+			/** @type {import('./internal').Component} */
+			var component = vnode.__c;
+			if (component && component.__R) {
+				component.__R();
+			}
+
+			// if the component is still hydrating
+			// most likely it is because the component is suspended
+			// we set the vnode.type as `null` so that it is not a typeof function
+			// so the unmount will remove the vnode._dom
+			if (component && vnode.__h === true) {
+				vnode.type = null;
+			}
+			if (oldUnmount) oldUnmount(vnode);
+		};
+		function detachedClone(vnode, detachedParent, parentDom) {
+			if (vnode) {
+				if (vnode.__c && vnode.__c.__H) {
+					vnode.__c.__H.__.forEach(function (effect) {
+						if (typeof effect.__c == 'function') effect.__c();
+					});
+					vnode.__c.__H = null;
+				}
+				vnode = (0, _util__WEBPACK_IMPORTED_MODULE_1__.assign)({}, vnode);
+				if (vnode.__c != null) {
+					if (vnode.__c.__P === parentDom) {
+						vnode.__c.__P = detachedParent;
+					}
+					vnode.__c = null;
+				}
+				vnode.__k =
+            vnode.__k &&
+            vnode.__k.map(function (child) {
+            	return detachedClone(child, detachedParent, parentDom);
+            });
+			}
+			return vnode;
+		}
+		function removeOriginal(vnode, detachedParent, originalParent) {
+			if (vnode) {
+				vnode.__v = null;
+				vnode.__k =
+            vnode.__k &&
+            vnode.__k.map(function (child) {
+            	return removeOriginal(child, detachedParent, originalParent);
+            });
+				if (vnode.__c) {
+					if (vnode.__c.__P === detachedParent) {
+						if (vnode.__e) {
+							originalParent.insertBefore(vnode.__e, vnode.__d);
+						}
+						vnode.__c.__e = true;
+						vnode.__c.__P = originalParent;
+					}
+				}
+			}
+			return vnode;
+		}
+
+		// having custom inheritance instead of a class here saves a lot of bytes
+		function Suspense() {
+			// we do not call super here to golf some bytes...
+			this.__u = 0;
+			this._suspenders = null;
+			this.__b = null;
+		}
+
+		// Things we do here to save some bytes but are not proper JS inheritance:
+		// - call `new Component()` as the prototype
+		// - do not set `Suspense.prototype.constructor` to `Suspense`
+		Suspense.prototype = new preact__WEBPACK_IMPORTED_MODULE_0__.Component();
+
+		/**
+       * @this {import('./internal').SuspenseComponent}
+       * @param {Promise} promise The thrown promise
+       * @param {import('./internal').VNode<any, any>} suspendingVNode The suspending component
+       */
+		Suspense.prototype.__c = function (promise, suspendingVNode) {
+			var suspendingComponent = suspendingVNode.__c;
+
+			/** @type {import('./internal').SuspenseComponent} */
+			var c = this;
+			if (c._suspenders == null) {
+				c._suspenders = [];
+			}
+			c._suspenders.push(suspendingComponent);
+			var resolve = suspended(c.__v);
+			var resolved = false;
+			var onResolved = function onResolved() {
+				if (resolved) return;
+				resolved = true;
+				suspendingComponent.__R = null;
+				if (resolve) {
+					resolve(onSuspensionComplete);
+				}
+				else {
+					onSuspensionComplete();
+				}
+			};
+			suspendingComponent.__R = onResolved;
+			var onSuspensionComplete = function onSuspensionComplete() {
+				if (!--c.__u) {
+					// If the suspension was during hydration we don't need to restore the
+					// suspended children into the _children array
+					if (c.state.__a) {
+						var suspendedVNode = c.state.__a;
+						c.__v.__k[0] = removeOriginal(
+							suspendedVNode,
+							suspendedVNode.__c.__P,
+							suspendedVNode.__c.__O
+						);
+					}
+					c.setState({
+						__a: (c.__b = null),
+					});
+					var _suspended;
+					while ((_suspended = c._suspenders.pop())) {
+						_suspended.forceUpdate();
+					}
+				}
+			};
+
+			/**
+         * We do not set `suspended: true` during hydration because we want the actual markup
+         * to remain on screen and hydrate it when the suspense actually gets resolved.
+         * While in non-hydration cases the usual fallback -> component flow would occour.
+         */
+			var wasHydrating = suspendingVNode.__h === true;
+			if (!c.__u++ && !wasHydrating) {
+				c.setState({
+					__a: (c.__b = c.__v.__k[0]),
+				});
+			}
+			promise.then(onResolved, onResolved);
+		};
+		Suspense.prototype.componentWillUnmount = function () {
+			this._suspenders = [];
+		};
+
+		/**
+       * @this {import('./internal').SuspenseComponent}
+       * @param {import('./internal').SuspenseComponent["props"]} props
+       * @param {import('./internal').SuspenseState} state
+       */
+		Suspense.prototype.render = function (props, state) {
+			if (this.__b) {
+				// When the Suspense's _vnode was created by a call to createVNode
+				// (i.e. due to a setState further up in the tree)
+				// it's _children prop is null, in this case we "forget" about the parked vnodes to detach
+				if (this.__v.__k) {
+					var detachedParent = document.createElement('div');
+					var detachedComponent = this.__v.__k[0].__c;
+					this.__v.__k[0] = detachedClone(
+						this.__b,
+						detachedParent,
+						(detachedComponent.__O = detachedComponent.__P)
+					);
+				}
+				this.__b = null;
+			}
+
+			// Wrap fallback tree in a VNode that prevents itself from being marked as aborting mid-hydration:
+			/** @type {import('./internal').VNode} */
+			var fallback =
+          state.__a &&
+          (0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+          	preact__WEBPACK_IMPORTED_MODULE_0__.Fragment,
+          	null,
+          	props.fallback
+          );
+			if (fallback) fallback.__h = null;
+			return [
+				(0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+					preact__WEBPACK_IMPORTED_MODULE_0__.Fragment,
+					null,
+					state.__a ? null : props.children
+				),
+				fallback,
+			];
+		};
+
+		/**
+       * Checks and calls the parent component's _suspended method, passing in the
+       * suspended vnode. This is a way for a parent (e.g. SuspenseList) to get notified
+       * that one of its children/descendants suspended.
+       *
+       * The parent MAY return a callback. The callback will get called when the
+       * suspension resolves, notifying the parent of the fact.
+       * Moreover, the callback gets function `unsuspend` as a parameter. The resolved
+       * child descendant will not actually get unsuspended until `unsuspend` gets called.
+       * This is a way for the parent to delay unsuspending.
+       *
+       * If the parent does not return a callback then the resolved vnode
+       * gets unsuspended immediately when it resolves.
+       *
+       * @param {import('./internal').VNode} vnode
+       * @returns {((unsuspend: () => void) => void)?}
+       */
+		function suspended(vnode) {
+			/** @type {import('./internal').Component} */
+			var component = vnode.__.__c;
+			return component && component.__a && component.__a(vnode);
+		}
+		function lazy(loader) {
+			var prom;
+			var component;
+			var error;
+			function Lazy(props) {
+				if (!prom) {
+					prom = loader();
+					prom.then(
+						function (exports) {
+							component = exports.default || exports;
+						},
+						function (e) {
+							error = e;
+						}
+					);
+				}
+				if (error) {
+					throw error;
+				}
+				if (!component) {
+					throw prom;
+				}
+				return (0, preact__WEBPACK_IMPORTED_MODULE_0__.createElement)(
+					component,
+					props
+				);
+			}
+			Lazy.displayName = 'Lazy';
+			Lazy.__f = true;
+			return Lazy;
+		}
+
+		/***/
+	},
+
+	/***/ './compat/src/util.js':
+	/*!****************************!*\
+  !*** ./compat/src/util.js ***!
+  \****************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ assign: () => /* binding */ assign,
+			/* harmony export */ is: () => /* binding */ is,
+			/* harmony export */ removeNode: () => /* binding */ removeNode,
+			/* harmony export */ shallowDiffers: () => /* binding */ shallowDiffers,
+			/* harmony export */
+		});
+		/**
+       * Assign properties from `props` to `obj`
+       * @template O, P The obj and props types
+       * @param {O} obj The object to copy properties to
+       * @param {P} props The object to copy properties from
+       * @returns {O & P}
+       */
+		function assign(obj, props) {
+			for (var i in props) {
+				obj[i] = props[i];
+			}
+			return /** @type {O & P} */ obj;
+		}
+
+		/**
+       * Check if two objects have a different shape
+       * @param {object} a
+       * @param {object} b
+       * @returns {boolean}
+       */
+		function shallowDiffers(a, b) {
+			for (var i in a) {
+				if (i !== '__source' && !(i in b)) return true;
+			}
+			for (var _i in b) {
+				if (_i !== '__source' && a[_i] !== b[_i]) return true;
+			}
+			return false;
+		}
+		function removeNode(node) {
+			var parentNode = node.parentNode;
+			if (parentNode) parentNode.removeChild(node);
+		}
+
+		/**
+       * Check if two values are the same value
+       * @param {*} x
+       * @param {*} y
+       * @returns {boolean}
+       */
+		function is(x, y) {
+			return (
+				(x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y)
+			);
+		}
+
+		/***/
+	},
+
+	/***/ './hooks/src/index.js':
+	/*!****************************!*\
+  !*** ./hooks/src/index.js ***!
+  \****************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ useCallback: () => /* binding */ useCallback,
+			/* harmony export */ useContext: () => /* binding */ useContext,
+			/* harmony export */ useDebugValue: () => /* binding */ useDebugValue,
+			/* harmony export */ useEffect: () => /* binding */ useEffect,
+			/* harmony export */ useErrorBoundary: () =>
+			/* binding */ useErrorBoundary,
+			/* harmony export */ useId: () => /* binding */ useId,
+			/* harmony export */ useImperativeHandle: () =>
+			/* binding */ useImperativeHandle,
+			/* harmony export */ useLayoutEffect: () =>
+			/* binding */ useLayoutEffect,
+			/* harmony export */ useMemo: () => /* binding */ useMemo,
+			/* harmony export */ useReducer: () => /* binding */ useReducer,
+			/* harmony export */ useRef: () => /* binding */ useRef,
+			/* harmony export */ useState: () => /* binding */ useState,
+			/* harmony export */
+		});
+		/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! preact */ './src/index.js');
+
+		/** @type {number} */
+		var currentIndex;
+
+		/** @type {import('./internal').Component} */
+		var currentComponent;
+
+		/** @type {import('./internal').Component} */
+		var previousComponent;
+
+		/** @type {number} */
+		var currentHook = 0;
+
+		/** @type {Array<import('./internal').Component>} */
+		var afterPaintEffects = [];
+		var EMPTY = [];
+		var oldBeforeDiff = preact__WEBPACK_IMPORTED_MODULE_0__.options.__b;
+		var oldBeforeRender = preact__WEBPACK_IMPORTED_MODULE_0__.options.__r;
+		var oldAfterDiff = preact__WEBPACK_IMPORTED_MODULE_0__.options.diffed;
+		var oldCommit = preact__WEBPACK_IMPORTED_MODULE_0__.options.__c;
+		var oldBeforeUnmount =
+        preact__WEBPACK_IMPORTED_MODULE_0__.options.unmount;
+		var RAF_TIMEOUT = 100;
+		var prevRaf;
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__b = function (vnode) {
+			currentComponent = null;
+			if (oldBeforeDiff) oldBeforeDiff(vnode);
+		};
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__r = function (vnode) {
+			if (oldBeforeRender) oldBeforeRender(vnode);
+			currentComponent = vnode.__c;
+			currentIndex = 0;
+			var hooks = currentComponent.__H;
+			if (hooks) {
+				if (previousComponent === currentComponent) {
+					hooks.__h = [];
+					currentComponent.__h = [];
+					hooks.__.forEach(function (hookItem) {
+						if (hookItem.__N) {
+							hookItem.__ = hookItem.__N;
+						}
+						hookItem.__V = EMPTY;
+						hookItem.__N = hookItem._pendingArgs = undefined;
+					});
+				}
+				else {
+					hooks.__h.forEach(invokeCleanup);
+					hooks.__h.forEach(invokeEffect);
+					hooks.__h = [];
+				}
+			}
+			previousComponent = currentComponent;
+		};
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.diffed = function (vnode) {
+			if (oldAfterDiff) oldAfterDiff(vnode);
+			var c = vnode.__c;
+			if (c && c.__H) {
+				if (c.__H.__h.length) afterPaint(afterPaintEffects.push(c));
+				c.__H.__.forEach(function (hookItem) {
+					if (hookItem._pendingArgs) {
+						hookItem.__H = hookItem._pendingArgs;
+					}
+					if (hookItem.__V !== EMPTY) {
+						hookItem.__ = hookItem.__V;
+					}
+					hookItem._pendingArgs = undefined;
+					hookItem.__V = EMPTY;
+				});
+			}
+			previousComponent = currentComponent = null;
+		};
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.__c = function (
+			vnode,
+			commitQueue
+		) {
+			commitQueue.some(function (component) {
+				try {
+					component.__h.forEach(invokeCleanup);
+					component.__h = component.__h.filter(function (cb) {
+						return cb.__ ? invokeEffect(cb) : true;
+					});
+				}
+				catch (e) {
+					commitQueue.some(function (c) {
+						if (c.__h) c.__h = [];
+					});
+					commitQueue = [];
+					preact__WEBPACK_IMPORTED_MODULE_0__.options.__e(e, component.__v);
+				}
+			});
+			if (oldCommit) oldCommit(vnode, commitQueue);
+		};
+		preact__WEBPACK_IMPORTED_MODULE_0__.options.unmount = function (vnode) {
+			if (oldBeforeUnmount) oldBeforeUnmount(vnode);
+			var c = vnode.__c;
+			if (c && c.__H) {
+				var hasErrored;
+				c.__H.__.forEach(function (s) {
+					try {
+						invokeCleanup(s);
+					}
+					catch (e) {
+						hasErrored = e;
+					}
+				});
+				c.__H = undefined;
+				if (hasErrored)
+					preact__WEBPACK_IMPORTED_MODULE_0__.options.__e(hasErrored, c.__v);
+			}
+		};
+
+		/**
+       * Get a hook's state from the currentComponent
+       * @param {number} index The index of the hook to get
+       * @param {number} type The index of the hook to get
+       * @returns {any}
+       */
+		function getHookState(index, type) {
+			if (preact__WEBPACK_IMPORTED_MODULE_0__.options.__h) {
+				preact__WEBPACK_IMPORTED_MODULE_0__.options.__h(
+					currentComponent,
+					index,
+					currentHook || type
+				);
+			}
+			currentHook = 0;
+
+			// Largely inspired by:
+			// * https://github.com/michael-klein/funcy.js/blob/f6be73468e6ec46b0ff5aa3cc4c9baf72a29025a/src/hooks/core_hooks.mjs
+			// * https://github.com/michael-klein/funcy.js/blob/650beaa58c43c33a74820a3c98b3c7079cf2e333/src/renderer.mjs
+			// Other implementations to look at:
+			// * https://codesandbox.io/s/mnox05qp8
+			var hooks =
+          currentComponent.__H ||
+          (currentComponent.__H = {
+          	__: [],
+          	__h: [],
+          });
+			if (index >= hooks.__.length) {
+				hooks.__.push({
+					__V: EMPTY,
+				});
+			}
+			return hooks.__[index];
+		}
+
+		/**
+       * @param {import('./index').StateUpdater<any>} [initialState]
+       */
+		function useState(initialState) {
+			currentHook = 1;
+			return useReducer(invokeOrReturn, initialState);
+		}
+
+		/**
+       * @param {import('./index').Reducer<any, any>} reducer
+       * @param {import('./index').StateUpdater<any>} initialState
+       * @param {(initialState: any) => void} [init]
+       * @returns {[ any, (state: any) => void ]}
+       */
+		function useReducer(reducer, initialState, init) {
+			/** @type {import('./internal').ReducerHookState} */
+			var hookState = getHookState(currentIndex++, 2);
+			hookState._reducer = reducer;
+			if (!hookState.__c) {
+				hookState.__ = [
+					!init
+						? invokeOrReturn(undefined, initialState)
+						: init(initialState),
+					function (action) {
+						var currentValue = hookState.__N
+							? hookState.__N[0]
+							: hookState.__[0];
+						var nextValue = hookState._reducer(currentValue, action);
+						if (currentValue !== nextValue) {
+							hookState.__N = [nextValue, hookState.__[1]];
+							hookState.__c.setState({});
+						}
+					},
+				];
+				hookState.__c = currentComponent;
+				if (!currentComponent._hasScuFromHooks) {
+					currentComponent._hasScuFromHooks = true;
+					var prevScu = currentComponent.shouldComponentUpdate;
+
+					// This SCU has the purpose of bailing out after repeated updates
+					// to stateful hooks.
+					// we store the next value in _nextValue[0] and keep doing that for all
+					// state setters, if we have next states and
+					// all next states within a component end up being equal to their original state
+					// we are safe to bail out for this specific component.
+					currentComponent.shouldComponentUpdate = function (p, s, c) {
+						if (!hookState.__c.__H) return true;
+						var stateHooks = hookState.__c.__H.__.filter(function (x) {
+							return x.__c;
+						});
+						var allHooksEmpty = stateHooks.every(function (x) {
+							return !x.__N;
+						});
+						// When we have no updated hooks in the component we invoke the previous SCU or
+						// traverse the VDOM tree further.
+						if (allHooksEmpty) {
+							return prevScu ? prevScu.call(this, p, s, c) : true;
+						}
+
+						// We check whether we have components with a nextValue set that
+						// have values that aren't equal to one another this pushes
+						// us to update further down the tree
+						var shouldUpdate = false;
+						stateHooks.forEach(function (hookItem) {
+							if (hookItem.__N) {
+								var currentValue = hookItem.__[0];
+								hookItem.__ = hookItem.__N;
+								hookItem.__N = undefined;
+								if (currentValue !== hookItem.__[0]) shouldUpdate = true;
+							}
+						});
+						return shouldUpdate || hookState.__c.props !== p
+							? prevScu
+								? prevScu.call(this, p, s, c)
+								: true
+							: false;
+					};
+				}
+			}
+			return hookState.__N || hookState.__;
+		}
+
+		/**
+       * @param {import('./internal').Effect} callback
+       * @param {any[]} args
+       */
+		function useEffect(callback, args) {
+			/** @type {import('./internal').EffectHookState} */
+			var state = getHookState(currentIndex++, 3);
+			if (
+				!preact__WEBPACK_IMPORTED_MODULE_0__.options.__s &&
+          argsChanged(state.__H, args)
+			) {
+				state.__ = callback;
+				state._pendingArgs = args;
+				currentComponent.__H.__h.push(state);
+			}
+		}
+
+		/**
+       * @param {import('./internal').Effect} callback
+       * @param {any[]} args
+       */
+		function useLayoutEffect(callback, args) {
+			/** @type {import('./internal').EffectHookState} */
+			var state = getHookState(currentIndex++, 4);
+			if (
+				!preact__WEBPACK_IMPORTED_MODULE_0__.options.__s &&
+          argsChanged(state.__H, args)
+			) {
+				state.__ = callback;
+				state._pendingArgs = args;
+				currentComponent.__h.push(state);
+			}
+		}
+		function useRef(initialValue) {
+			currentHook = 5;
+			return useMemo(function () {
+				return {
+					current: initialValue,
+				};
+			}, []);
+		}
+
+		/**
+       * @param {object} ref
+       * @param {() => object} createHandle
+       * @param {any[]} args
+       */
+		function useImperativeHandle(ref, createHandle, args) {
+			currentHook = 6;
+			useLayoutEffect(
+				function () {
+					if (typeof ref == 'function') {
+						ref(createHandle());
+						return function () {
+							return ref(null);
+						};
+					}
+					else if (ref) {
+						ref.current = createHandle();
+						return function () {
+							return (ref.current = null);
+						};
+					}
+				},
+				args == null ? args : args.concat(ref)
+			);
+		}
+
+		/**
+       * @param {() => any} factory
+       * @param {any[]} args
+       */
+		function useMemo(factory, args) {
+			/** @type {import('./internal').MemoHookState} */
+			var state = getHookState(currentIndex++, 7);
+			if (argsChanged(state.__H, args)) {
+				state.__V = factory();
+				state._pendingArgs = args;
+				state.__h = factory;
+				return state.__V;
+			}
+			return state.__;
+		}
+
+		/**
+       * @param {() => void} callback
+       * @param {any[]} args
+       */
+		function useCallback(callback, args) {
+			currentHook = 8;
+			return useMemo(function () {
+				return callback;
+			}, args);
+		}
+
+		/**
+       * @param {import('./internal').PreactContext} context
+       */
+		function useContext(context) {
+			var provider = currentComponent.context[context.__c];
+			// We could skip this call here, but than we'd not call
+			// `options._hook`. We need to do that in order to make
+			// the devtools aware of this hook.
+			/** @type {import('./internal').ContextHookState} */
+			var state = getHookState(currentIndex++, 9);
+			// The devtools needs access to the context object to
+			// be able to pull of the default value when no provider
+			// is present in the tree.
+			state.c = context;
+			if (!provider) return context.__;
+			// This is probably not safe to convert to "!"
+			if (state.__ == null) {
+				state.__ = true;
+				provider.sub(currentComponent);
+			}
+			return provider.props.value;
+		}
+
+		/**
+       * Display a custom label for a custom hook for the devtools panel
+       * @type {<T>(value: T, cb?: (value: T) => string | number) => void}
+       */
+		function useDebugValue(value, formatter) {
+			if (preact__WEBPACK_IMPORTED_MODULE_0__.options.useDebugValue) {
+				preact__WEBPACK_IMPORTED_MODULE_0__.options.useDebugValue(
+					formatter ? formatter(value) : value
+				);
+			}
+		}
+
+		/**
+       * @param {(error: any, errorInfo: import('preact').ErrorInfo) => void} cb
+       */
+		function useErrorBoundary(cb) {
+			/** @type {import('./internal').ErrorBoundaryHookState} */
+			var state = getHookState(currentIndex++, 10);
+			var errState = useState();
+			state.__ = cb;
+			if (!currentComponent.componentDidCatch) {
+				currentComponent.componentDidCatch = function (err, errorInfo) {
+					if (state.__) state.__(err, errorInfo);
+					errState[1](err);
+				};
+			}
+			return [
+				errState[0],
+				function () {
+					errState[1](undefined);
+				},
+			];
+		}
+		function useId() {
+			var state = getHookState(currentIndex++, 11);
+			if (!state.__) {
+				// Grab either the root node or the nearest async boundary node.
+				/** @type {import('./internal.d').VNode} */
+				var root = currentComponent.__v;
+				while (root !== null && !root.__m && root.__ !== null) {
+					root = root.__;
+				}
+				var mask = root.__m || (root.__m = [0, 0]);
+				state.__ = 'P' + mask[0] + '-' + mask[1]++;
+			}
+			return state.__;
+		}
+		/**
+       * After paint effects consumer.
+       */
+		function flushAfterPaintEffects() {
+			var component;
+			while ((component = afterPaintEffects.shift())) {
+				if (!component.__P || !component.__H) continue;
+				try {
+					component.__H.__h.forEach(invokeCleanup);
+					component.__H.__h.forEach(invokeEffect);
+					component.__H.__h = [];
+				}
+				catch (e) {
+					component.__H.__h = [];
+					preact__WEBPACK_IMPORTED_MODULE_0__.options.__e(e, component.__v);
+				}
+			}
+		}
+		var HAS_RAF = typeof requestAnimationFrame == 'function';
+
+		/**
+       * Schedule a callback to be invoked after the browser has a chance to paint a new frame.
+       * Do this by combining requestAnimationFrame (rAF) + setTimeout to invoke a callback after
+       * the next browser frame.
+       *
+       * Also, schedule a timeout in parallel to the the rAF to ensure the callback is invoked
+       * even if RAF doesn't fire (for example if the browser tab is not visible)
+       *
+       * @param {() => void} callback
+       */
+		function afterNextFrame(callback) {
+			var done = function done() {
+				clearTimeout(timeout);
+				if (HAS_RAF) cancelAnimationFrame(raf);
+				setTimeout(callback);
+			};
+			var timeout = setTimeout(done, RAF_TIMEOUT);
+			var raf;
+			if (HAS_RAF) {
+				raf = requestAnimationFrame(done);
+			}
+		}
+
+		// Note: if someone used options.debounceRendering = requestAnimationFrame,
+		// then effects will ALWAYS run on the NEXT frame instead of the current one, incurring a ~16ms delay.
+		// Perhaps this is not such a big deal.
+		/**
+       * Schedule afterPaintEffects flush after the browser paints
+       * @param {number} newQueueLength
+       */
+		function afterPaint(newQueueLength) {
+			if (
+				newQueueLength === 1 ||
+          prevRaf !==
+            preact__WEBPACK_IMPORTED_MODULE_0__.options.requestAnimationFrame
+			) {
+				prevRaf =
+            preact__WEBPACK_IMPORTED_MODULE_0__.options.requestAnimationFrame;
+				(prevRaf || afterNextFrame)(flushAfterPaintEffects);
+			}
+		}
+
+		/**
+       * @param {import('./internal').EffectHookState} hook
+       */
+		function invokeCleanup(hook) {
+			// A hook cleanup can introduce a call to render which creates a new root, this will call options.vnode
+			// and move the currentComponent away.
+			var comp = currentComponent;
+			var cleanup = hook.__c;
+			if (typeof cleanup == 'function') {
+				hook.__c = undefined;
+				cleanup();
+			}
+			currentComponent = comp;
+		}
+
+		/**
+       * Invoke a Hook's effect
+       * @param {import('./internal').EffectHookState} hook
+       */
+		function invokeEffect(hook) {
+			// A hook call can introduce a call to render which creates a new root, this will call options.vnode
+			// and move the currentComponent away.
+			var comp = currentComponent;
+			hook.__c = hook.__();
+			currentComponent = comp;
+		}
+
+		/**
+       * @param {any[]} oldArgs
+       * @param {any[]} newArgs
+       */
+		function argsChanged(oldArgs, newArgs) {
+			return (
+				!oldArgs ||
+          oldArgs.length !== newArgs.length ||
+          newArgs.some(function (arg, index) {
+          	return arg !== oldArgs[index];
+          })
+			);
+		}
+		function invokeOrReturn(arg, f) {
+			return typeof f == 'function' ? f(arg) : f;
+		}
+
+		/***/
+	},
+
+	/***/ './src/clone-element.js':
+	/*!******************************!*\
+  !*** ./src/clone-element.js ***!
+  \******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ cloneElement: () => /* binding */ cloneElement,
+			/* harmony export */
+		});
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./util */ './src/util.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./create-element */ './src/create-element.js');
+
+		/**
+       * Clones the given VNode, optionally adding attributes/props and replacing its children.
+       * @param {import('./internal').VNode} vnode The virtual DOM element to clone
+       * @param {object} props Attributes/props to add when cloning
+       * @param {Array<import('./internal').ComponentChildren>} rest Any additional arguments will be used as replacement children.
+       * @returns {import('./internal').VNode}
+       */
+		function cloneElement(vnode, props, children) {
+			var normalizedProps = (0, _util__WEBPACK_IMPORTED_MODULE_0__.assign)(
+					{},
+					vnode.props
+				),
+				key,
+				ref,
+				i;
+			for (i in props) {
+				if (i == 'key') key = props[i];
+				else if (i == 'ref') ref = props[i];
+				else normalizedProps[i] = props[i];
+			}
+			if (arguments.length > 2) {
+				normalizedProps.children =
+            arguments.length > 3
+            	? _util__WEBPACK_IMPORTED_MODULE_0__.slice.call(arguments, 2)
+            	: children;
+			}
+			return (0, _create_element__WEBPACK_IMPORTED_MODULE_1__.createVNode)(
+				vnode.type,
+				normalizedProps,
+				key || vnode.key,
+				ref || vnode.ref,
+				null
+			);
+		}
+
+		/***/
+	},
+
+	/***/ './src/component.js':
+	/*!**************************!*\
+  !*** ./src/component.js ***!
+  \**************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ Component: () => /* binding */ Component,
+			/* harmony export */ enqueueRender: () => /* binding */ enqueueRender,
+			/* harmony export */ getDomSibling: () => /* binding */ getDomSibling,
+			/* harmony export */
+		});
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./util */ './src/util.js');
+		/* harmony import */ var _diff_index__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./diff/index */ './src/diff/index.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ./options */ './src/options.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_3__ =
+        __webpack_require__(/*! ./create-element */ './src/create-element.js');
+
+		/**
+       * Base Component class. Provides `setState()` and `forceUpdate()`, which
+       * trigger rendering
+       * @param {object} props The initial component props
+       * @param {object} context The initial context from parent components'
+       * getChildContext
+       */
+		function Component(props, context) {
+			this.props = props;
+			this.context = context;
+		}
+
+		/**
+       * Update component state and schedule a re-render.
+       * @this {import('./internal').Component}
+       * @param {object | ((s: object, p: object) => object)} update A hash of state
+       * properties to update with new values or a function that given the current
+       * state and props returns a new partial state
+       * @param {() => void} [callback] A function to be called once component state is
+       * updated
+       */
+		Component.prototype.setState = function (update, callback) {
+			// only clone state when copying to nextState the first time.
+			var s;
+			if (this.__s != null && this.__s !== this.state) {
+				s = this.__s;
+			}
+			else {
+				s = this.__s = (0, _util__WEBPACK_IMPORTED_MODULE_0__.assign)(
+					{},
+					this.state
+				);
+			}
+			if (typeof update == 'function') {
+				// Some libraries like `immer` mark the current state as readonly,
+				// preventing us from mutating it, so we need to clone it. See #2716
+				update = update(
+					(0, _util__WEBPACK_IMPORTED_MODULE_0__.assign)({}, s),
+					this.props
+				);
+			}
+			if (update) {
+				(0, _util__WEBPACK_IMPORTED_MODULE_0__.assign)(s, update);
+			}
+
+			// Skip update if updater function returned null
+			if (update == null) return;
+			if (this.__v) {
+				if (callback) {
+					this._sb.push(callback);
+				}
+				enqueueRender(this);
+			}
+		};
+
+		/**
+       * Immediately perform a synchronous re-render of the component
+       * @this {import('./internal').Component}
+       * @param {() => void} [callback] A function to be called after component is
+       * re-rendered
+       */
+		Component.prototype.forceUpdate = function (callback) {
+			if (this.__v) {
+				// Set render mode so that we can differentiate where the render request
+				// is coming from. We need this because forceUpdate should never call
+				// shouldComponentUpdate
+				this.__e = true;
+				if (callback) this.__h.push(callback);
+				enqueueRender(this);
+			}
+		};
+
+		/**
+       * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.
+       * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).
+       * @param {object} props Props (eg: JSX attributes) received from parent
+       * element/component
+       * @param {object} state The component's current state
+       * @param {object} context Context object, as returned by the nearest
+       * ancestor's `getChildContext()`
+       * @returns {import('./index').ComponentChildren | void}
+       */
+		Component.prototype.render =
+        _create_element__WEBPACK_IMPORTED_MODULE_3__.Fragment;
+
+		/**
+       * @param {import('./internal').VNode} vnode
+       * @param {number | null} [childIndex]
+       */
+		function getDomSibling(vnode, childIndex) {
+			if (childIndex == null) {
+				// Use childIndex==null as a signal to resume the search from the vnode's sibling
+				return vnode.__
+					? getDomSibling(vnode.__, vnode.__.__k.indexOf(vnode) + 1)
+					: null;
+			}
+			var sibling;
+			for (; childIndex < vnode.__k.length; childIndex++) {
+				sibling = vnode.__k[childIndex];
+				if (sibling != null && sibling.__e != null) {
+					// Since updateParentDomPointers keeps _dom pointer correct,
+					// we can rely on _dom to tell us if this subtree contains a
+					// rendered DOM node, and what the first rendered DOM node is
+					return sibling.__e;
+				}
+			}
+
+			// If we get here, we have not found a DOM node in this vnode's children.
+			// We must resume from this vnode's sibling (in it's parent _children array)
+			// Only climb up and search the parent if we aren't searching through a DOM
+			// VNode (meaning we reached the DOM parent of the original vnode that began
+			// the search)
+			return typeof vnode.type == 'function' ? getDomSibling(vnode) : null;
+		}
+
+		/**
+       * Trigger in-place re-rendering of a component.
+       * @param {import('./internal').Component} component The component to rerender
+       */
+		function renderComponent(component) {
+			var vnode = component.__v,
+				oldDom = vnode.__e,
+				parentDom = component.__P;
+			var onRenderComponent =
+          _options__WEBPACK_IMPORTED_MODULE_2__['default'].onRenderComponent;
+			if (onRenderComponent) onRenderComponent(component, 'begin');
+			if (parentDom) {
+				var commitQueue = [];
+				var oldVNode = (0, _util__WEBPACK_IMPORTED_MODULE_0__.assign)(
+					{},
+					vnode
+				);
+				oldVNode.__v = vnode.__v + 1;
+				(0, _diff_index__WEBPACK_IMPORTED_MODULE_1__.diff)(
+					parentDom,
+					vnode,
+					oldVNode,
+					component.__n,
+					parentDom.ownerSVGElement !== undefined,
+					vnode.__h != null ? [oldDom] : null,
+					commitQueue,
+					oldDom == null ? getDomSibling(vnode) : oldDom,
+					vnode.__h
+				);
+				(0, _diff_index__WEBPACK_IMPORTED_MODULE_1__.commitRoot)(
+					commitQueue,
+					vnode
+				);
+				if (vnode.__e != oldDom) {
+					updateParentDomPointers(vnode);
+				}
+			}
+			if (onRenderComponent) onRenderComponent(component, 'end');
+		}
+
+		/**
+       * @param {import('./internal').VNode} vnode
+       */
+		function updateParentDomPointers(vnode) {
+			if ((vnode = vnode.__) != null && vnode.__c != null) {
+				vnode.__e = vnode.__c.base = null;
+				for (var i = 0; i < vnode.__k.length; i++) {
+					var child = vnode.__k[i];
+					if (child != null && child.__e != null) {
+						vnode.__e = vnode.__c.base = child.__e;
+						break;
+					}
+				}
+				return updateParentDomPointers(vnode);
+			}
+		}
+
+		/**
+       * The render queue
+       * @type {Array<import('./internal').Component>}
+       */
+		var rerenderQueue = [];
+
+		/*
+       * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is
+       * important that contributors to Preact can consistently reason about what calls to `setState`, etc.
+       * do, and when their effects will be applied. See the links below for some further reading on designing
+       * asynchronous APIs.
+       * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)
+       * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)
+       */
+
+		var prevDebounce;
+
+		/**
+       * Enqueue a rerender of a component
+       * @param {import('./internal').Component} c The component to rerender
+       */
+		function enqueueRender(c) {
+			if (
+				(!c.__d &&
+            (c.__d = true) &&
+            rerenderQueue.push(c) &&
+            !process.__r++) ||
+          prevDebounce !==
+            _options__WEBPACK_IMPORTED_MODULE_2__['default'].debounceRendering
+			) {
+				prevDebounce =
+            _options__WEBPACK_IMPORTED_MODULE_2__['default'].debounceRendering;
+				(prevDebounce || setTimeout)(process);
+			}
+		}
+
+		/** Flush the render queue by rerendering all queued components */
+		function process() {
+			var queue;
+			while ((process.__r = rerenderQueue.length)) {
+				queue = rerenderQueue.sort(function (a, b) {
+					return a.__v.__b - b.__v.__b;
+				});
+				rerenderQueue = [];
+				// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary
+				// process() calls from getting scheduled while `queue` is still being consumed.
+				queue.some(function (c) {
+					if (c.__d) renderComponent(c);
+				});
+			}
+		}
+		process.__r = 0;
+
+		/***/
+	},
+
+	/***/ './src/constants.js':
+	/*!**************************!*\
+  !*** ./src/constants.js ***!
+  \**************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ EMPTY_ARR: () => /* binding */ EMPTY_ARR,
+			/* harmony export */ EMPTY_OBJ: () => /* binding */ EMPTY_OBJ,
+			/* harmony export */ IS_NON_DIMENSIONAL: () =>
+			/* binding */ IS_NON_DIMENSIONAL,
+			/* harmony export */
+		});
+		var EMPTY_OBJ = {};
+		var EMPTY_ARR = [];
+		var IS_NON_DIMENSIONAL =
+        /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
+
+		/***/
+	},
+
+	/***/ './src/create-context.js':
+	/*!*******************************!*\
+  !*** ./src/create-context.js ***!
+  \*******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ createContext: () => /* binding */ createContext,
+			/* harmony export */ i: () => /* binding */ i,
+			/* harmony export */
+		});
+		/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./component */ './src/component.js');
+
+		var i = 0;
+		function createContext(defaultValue, contextId) {
+			contextId = '__cC' + i++;
+			var context = {
+				__c: contextId,
+				__: defaultValue,
+				/** @type {import('./internal').FunctionComponent} */ Consumer:
+            function Consumer(props, contextValue) {
+            	// return props.children(
+            	// 	context[contextId] ? context[contextId].props.value : defaultValue
+            	// );
+            	return props.children(contextValue);
+            },
+				/** @type {import('./internal').FunctionComponent} */ Provider:
+            function Provider(props) {
+            	if (!this.getChildContext) {
+            		var subs = [];
+            		var ctx = {};
+            		ctx[contextId] = this;
+            		this.getChildContext = function () {
+            			return ctx;
+            		};
+            		this.shouldComponentUpdate = function (_props) {
+            			if (this.props.value !== _props.value) {
+            				// I think the forced value propagation here was only needed when `options.debounceRendering` was being bypassed:
+            				// https://github.com/preactjs/preact/commit/4d339fb803bea09e9f198abf38ca1bf8ea4b7771#diff-54682ce380935a717e41b8bfc54737f6R358
+            				// In those cases though, even with the value corrected, we're double-rendering all nodes.
+            				// It might be better to just tell folks not to use force-sync mode.
+            				// Currently, using `useContext()` in a class component will overwrite its `this.context` value.
+            				// subs.some(c => {
+            				// 	c.context = _props.value;
+            				// 	enqueueRender(c);
+            				// });
+
+            				// subs.some(c => {
+            				// 	c.context[contextId] = _props.value;
+            				// 	enqueueRender(c);
+            				// });
+            				subs.some(
+            					_component__WEBPACK_IMPORTED_MODULE_0__.enqueueRender
+            				);
+            			}
+            		};
+            		this.sub = function (c) {
+            			subs.push(c);
+            			var old = c.componentWillUnmount;
+            			c.componentWillUnmount = function () {
+            				subs.splice(subs.indexOf(c), 1);
+            				if (old) old.call(c);
+            			};
+            		};
+            	}
+            	return props.children;
+            },
+			};
+
+			// Devtools needs access to the context object when it
+			// encounters a Provider. This is necessary to support
+			// setting `displayName` on the context object instead
+			// of on the component itself. See:
+			// https://reactjs.org/docs/context.html#contextdisplayname
+
+			return (context.Provider.__ = context.Consumer.contextType = context);
+		}
+
+		/***/
+	},
+
+	/***/ './src/create-element.js':
+	/*!*******************************!*\
+  !*** ./src/create-element.js ***!
+  \*******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ Fragment: () => /* binding */ Fragment,
+			/* harmony export */ createElement: () => /* binding */ createElement,
+			/* harmony export */ createRef: () => /* binding */ createRef,
+			/* harmony export */ createVNode: () => /* binding */ createVNode,
+			/* harmony export */ isValidElement: () => /* binding */ isValidElement,
+			/* harmony export */
+		});
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./util */ './src/util.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./options */ './src/options.js');
+
+		var vnodeId = 0;
+
+		/**
+       * Create an virtual node (used for JSX)
+       * @param {import('./internal').VNode["type"]} type The node name or Component
+       * constructor for this virtual node
+       * @param {object | null | undefined} [props] The properties of the virtual node
+       * @param {Array<import('.').ComponentChildren>} [children] The children of the virtual node
+       * @returns {import('./internal').VNode}
+       */
+		function createElement(type, props, children) {
+			var normalizedProps = {},
+				key,
+				ref,
+				i;
+			for (i in props) {
+				if (i == 'key') key = props[i];
+				else if (i == 'ref') ref = props[i];
+				else normalizedProps[i] = props[i];
+			}
+			if (arguments.length > 2) {
+				normalizedProps.children =
+            arguments.length > 3
+            	? _util__WEBPACK_IMPORTED_MODULE_0__.slice.call(arguments, 2)
+            	: children;
+			}
+
+			// If a Component VNode, check for and apply defaultProps
+			// Note: type may be undefined in development, must never error here.
+			if (typeof type == 'function' && type.defaultProps != null) {
+				for (i in type.defaultProps) {
+					if (normalizedProps[i] === undefined) {
+						normalizedProps[i] = type.defaultProps[i];
+					}
+				}
+			}
+			return createVNode(type, normalizedProps, key, ref, null);
+		}
+
+		/**
+       * Create a VNode (used internally by Preact)
+       * @param {import('./internal').VNode["type"]} type The node name or Component
+       * Constructor for this virtual node
+       * @param {object | string | number | null} props The properties of this virtual node.
+       * If this virtual node represents a text node, this is the text of the node (string or number).
+       * @param {string | number | null} key The key for this virtual node, used when
+       * diffing it against its children
+       * @param {import('./internal').VNode["ref"]} ref The ref property that will
+       * receive a reference to its created child
+       * @returns {import('./internal').VNode}
+       */
+		function createVNode(type, props, key, ref, original) {
+			// V8 seems to be better at detecting type shapes if the object is allocated from the same call site
+			// Do not inline into createElement and coerceToVNode!
+			var vnode = {
+				type: type,
+				props: props,
+				key: key,
+				ref: ref,
+				__k: null,
+				__: null,
+				__b: 0,
+				__e: null,
+				// _nextDom must be initialized to undefined b/c it will eventually
+				// be set to dom.nextSibling which can return `null` and it is important
+				// to be able to distinguish between an uninitialized _nextDom and
+				// a _nextDom that has been set to `null`
+				__d: undefined,
+				__c: null,
+				__h: null,
+				constructor: undefined,
+				__v: original == null ? ++vnodeId : original,
+			};
+
+			// Only invoke the vnode hook if this was *not* a direct copy:
+			if (
+				original == null &&
+          _options__WEBPACK_IMPORTED_MODULE_1__['default'].vnode != null
+			)
+				_options__WEBPACK_IMPORTED_MODULE_1__['default'].vnode(vnode);
+			return vnode;
+		}
+		function createRef() {
+			return {
+				current: null,
+			};
+		}
+		function Fragment(props) {
+			return props.children;
+		}
+
+		/**
+       * Check if a the argument is a valid Preact VNode.
+       * @param {*} vnode
+       * @returns {vnode is import('./internal').VNode}
+       */
+		var isValidElement = function isValidElement(vnode) {
+			return vnode != null && vnode.constructor === undefined;
+		};
+
+		/***/
+	},
+
+	/***/ './src/diff/catch-error.js':
+	/*!*********************************!*\
+  !*** ./src/diff/catch-error.js ***!
+  \*********************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ _catchError: () => /* binding */ _catchError,
+			/* harmony export */
+		});
+		/**
+       * Find the closest error boundary to a thrown error and call it
+       * @param {object} error The thrown value
+       * @param {import('../types/internal').VNode} vnode The vnode that threw
+       * the error that was caught (except for unmounting when this parameter
+       * is the highest parent that was being unmounted)
+       * @param {import('../types/internal').VNode} [oldVNode]
+       * @param {import('../types/internal').ErrorInfo} [errorInfo]
+       */
+		function _catchError(error, vnode, oldVNode, errorInfo) {
+			/** @type {import('../types/internal').Component} */
+			var component, ctor, handled;
+			for (; (vnode = vnode.__); ) {
+				if ((component = vnode.__c) && !component.__) {
+					try {
+						ctor = component.constructor;
+						if (ctor && ctor.getDerivedStateFromError != null) {
+							component.setState(ctor.getDerivedStateFromError(error));
+							handled = component.__d;
+						}
+						if (component.componentDidCatch != null) {
+							component.componentDidCatch(error, errorInfo || {});
+							handled = component.__d;
+						}
+
+						// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.
+						if (handled) {
+							return (component.__E = component);
+						}
+					}
+					catch (e) {
+						error = e;
+					}
+				}
+			}
+			throw error;
+		}
+
+		/***/
+	},
+
+	/***/ './src/diff/children.js':
+	/*!******************************!*\
+  !*** ./src/diff/children.js ***!
+  \******************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ diffChildren: () => /* binding */ diffChildren,
+			/* harmony export */ toChildArray: () => /* binding */ toChildArray,
+			/* harmony export */
+		});
+		/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./index */ './src/diff/index.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ../create-element */ './src/create-element.js');
+		/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ../constants */ './src/constants.js');
+		/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_3__ =
+        __webpack_require__(/*! ../component */ './src/component.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_4__ =
+        __webpack_require__(/*! ../util */ './src/util.js');
+
+		/**
+       * Diff the children of a virtual node
+       * @param {import('../types/internal').PreactElement} parentDom The DOM element whose
+       * children are being diffed
+       * @param {import('../types/internal').ComponentChildren[]} renderResult
+       * @param {import('../types/internal').VNode} newParentVNode The new virtual
+       * node whose children should be diff'ed against oldParentVNode
+       * @param {import('../types/internal').VNode} oldParentVNode The old virtual
+       * node whose children should be diff'ed against newParentVNode
+       * @param {object} globalContext The current context object - modified by getChildContext
+       * @param {boolean} isSvg Whether or not this DOM node is an SVG node
+       * @param {Array<import('../types/internal').PreactElement>} excessDomChildren
+       * @param {Array<import('../types/internal').Component>} commitQueue List of components
+       * which have callbacks to invoke in commitRoot
+       * @param {import('../types/internal').PreactElement} oldDom The current attached DOM
+       * element any new dom elements should be placed around. Likely `null` on first
+       * render (except when hydrating). Can be a sibling DOM element when diffing
+       * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.
+       * @param {boolean} isHydrating Whether or not we are in hydration
+       */
+		function diffChildren(
+			parentDom,
+			renderResult,
+			newParentVNode,
+			oldParentVNode,
+			globalContext,
+			isSvg,
+			excessDomChildren,
+			commitQueue,
+			oldDom,
+			isHydrating
+		) {
+			var i, j, oldVNode, childVNode, newDom, firstChildDom, refs;
+
+			// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR
+			// as EMPTY_OBJ._children should be `undefined`.
+			var oldChildren =
+          (oldParentVNode && oldParentVNode.__k) ||
+          _constants__WEBPACK_IMPORTED_MODULE_2__.EMPTY_ARR;
+			var oldChildrenLength = oldChildren.length;
+			newParentVNode.__k = [];
+			for (i = 0; i < renderResult.length; i++) {
+				childVNode = renderResult[i];
+				// console.debug(`**${newParentVNode.props.id}-child${i}-${childVNode.props?.id}-start`,JSON.stringify(renderResult));
+
+				if (childVNode == null || typeof childVNode == 'boolean') {
+					childVNode = newParentVNode.__k[i] = null;
+				}
+				// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,
+				// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have
+				// it's own DOM & etc. pointers
+				else if (
+					typeof childVNode == 'string' ||
+            typeof childVNode == 'number' ||
+            // eslint-disable-next-line valid-typeof
+            typeof childVNode == 'bigint'
+				) {
+					childVNode = newParentVNode.__k[i] = (0,
+					_create_element__WEBPACK_IMPORTED_MODULE_1__.createVNode)(
+						null,
+						childVNode,
+						null,
+						null,
+						childVNode
+					);
+				}
+				else if (Array.isArray(childVNode)) {
+					childVNode = newParentVNode.__k[i] = (0,
+					_create_element__WEBPACK_IMPORTED_MODULE_1__.createVNode)(
+						_create_element__WEBPACK_IMPORTED_MODULE_1__.Fragment,
+						{
+							children: childVNode,
+						},
+						null,
+						null,
+						null
+					);
+				}
+				else if (childVNode.__b > 0) {
+					// VNode is already in use, clone it. This can happen in the following
+					// scenario:
+					//   const reuse = <div />
+					//   <div>{reuse}<span />{reuse}</div>
+					childVNode = newParentVNode.__k[i] = (0,
+					_create_element__WEBPACK_IMPORTED_MODULE_1__.createVNode)(
+						childVNode.type,
+						childVNode.props,
+						childVNode.key,
+						childVNode.ref ? childVNode.ref : null,
+						childVNode.__v
+					);
+				}
+				else {
+					childVNode = newParentVNode.__k[i] = childVNode;
+				}
+
+				// Terser removes the `continue` here and wraps the loop body
+				// in a `if (childVNode) { ... } condition
+				if (childVNode == null) {
+					continue;
+				}
+				childVNode.__ = newParentVNode;
+				childVNode.__b = newParentVNode.__b + 1;
+
+				// Check if we find a corresponding element in oldChildren.
+				// If found, delete the array item by setting to `undefined`.
+				// We use `undefined`, as `null` is reserved for empty placeholders
+				// (holes).
+				oldVNode = oldChildren[i];
+
+				///PLACE1/////////////////////////////////////
+
+				if (
+					oldVNode === null ||
+            (oldVNode &&
+              childVNode.key == oldVNode.key &&
+              childVNode.type === oldVNode.type)
+				) {
+					oldChildren[i] = undefined;
+				}
+				else {
+					// Either oldVNode === undefined or oldChildrenLength > 0,
+					// so after this loop oldVNode == null or oldVNode is a valid value.
+					for (j = 0; j < oldChildrenLength; j++) {
+						oldVNode = oldChildren[j];
+						// If childVNode is unkeyed, we only match similarly unkeyed nodes, otherwise we match by key.
+						// We always match by type (in either case).
+						if (
+							oldVNode &&
+                childVNode.key == oldVNode.key &&
+                childVNode.type === oldVNode.type
+						) {
+							oldChildren[j] = undefined;
+							break;
+						}
+						oldVNode = null;
+					}
+				}
+				oldVNode =
+            oldVNode || _constants__WEBPACK_IMPORTED_MODULE_2__.EMPTY_OBJ;
+
+				///PLACE2/////////////////////////////////////
+
+				// Morph the old element into the new one, but don't append it to the dom yet
+				(0, _index__WEBPACK_IMPORTED_MODULE_0__.diff)(
+					parentDom,
+					childVNode,
+					oldVNode,
+					globalContext,
+					isSvg,
+					excessDomChildren,
+					commitQueue,
+					oldDom,
+					isHydrating
+				);
+				oldVNode =
+            oldVNode || _constants__WEBPACK_IMPORTED_MODULE_2__.EMPTY_OBJ;
+				newDom = childVNode.__e;
+				if ((j = childVNode.ref) && oldVNode.ref != j) {
+					if (!refs) refs = [];
+					if (oldVNode.ref) refs.push(oldVNode.ref, null, childVNode);
+					refs.push(j, childVNode.__c || newDom, childVNode);
+				}
+				if (newDom != null) {
+					if (firstChildDom == null) {
+						firstChildDom = newDom;
+					}
+					if (
+						typeof childVNode.type == 'function' &&
+              childVNode.__k === oldVNode.__k
+					) {
+						childVNode.__d = oldDom = reorderChildren(
+							childVNode,
+							oldDom,
+							parentDom
+						);
+					}
+					else {
+						oldDom = placeChild(
+							parentDom,
+							childVNode,
+							oldVNode,
+							oldChildren,
+							newDom,
+							oldDom
+						);
+					}
+					if (typeof newParentVNode.type == 'function') {
+						// Because the newParentVNode is Fragment-like, we need to set it's
+						// _nextDom property to the nextSibling of its last child DOM node.
+						//
+						// `oldDom` contains the correct value here because if the last child
+						// is a Fragment-like, then oldDom has already been set to that child's _nextDom.
+						// If the last child is a DOM VNode, then oldDom will be set to that DOM
+						// node's nextSibling.
+						newParentVNode.__d = oldDom;
+					}
+				}
+				else if (
+					oldDom &&
+            oldVNode.__e == oldDom &&
+            oldDom.parentNode != parentDom
+				) {
+					// The above condition is to handle null placeholders. See test in placeholder.test.js:
+					// `efficiently replace null placeholders in parent rerenders`
+					oldDom = (0, _component__WEBPACK_IMPORTED_MODULE_3__.getDomSibling)(
+						oldVNode
+					);
+				}
+			}
+			newParentVNode.__e = firstChildDom;
+
+			// Remove remaining oldChildren if there are any.
+			for (i = oldChildrenLength; i--; ) {
+				if (oldChildren[i] != null) {
+					(0, _index__WEBPACK_IMPORTED_MODULE_0__.unmount)(
+						oldChildren[i],
+						oldChildren[i]
+					);
+				}
+			}
+
+			// Set refs only after unmount
+			if (refs) {
+				for (i = 0; i < refs.length; i++) {
+					(0, _index__WEBPACK_IMPORTED_MODULE_0__.applyRef)(
+						refs[i],
+						refs[++i],
+						refs[++i]
+					);
+				}
+			}
+		}
+		function reorderChildren(childVNode, oldDom, parentDom) {
+			// Note: VNodes in nested suspended trees may be missing _children.
+			var c = childVNode.__k;
+			var tmp = 0;
+			for (; c && tmp < c.length; tmp++) {
+				var vnode = c[tmp];
+				if (vnode) {
+					// We typically enter this code path on sCU bailout, where we copy
+					// oldVNode._children to newVNode._children. If that is the case, we need
+					// to update the old children's _parent pointer to point to the newVNode
+					// (childVNode here).
+					vnode.__ = childVNode;
+					if (typeof vnode.type == 'function') {
+						oldDom = reorderChildren(vnode, oldDom, parentDom);
+					}
+					else {
+						oldDom = placeChild(
+							parentDom,
+							vnode,
+							vnode,
+							c,
+							vnode.__e,
+							oldDom
+						);
+					}
+				}
+			}
+			return oldDom;
+		}
+
+		/**
+       * Flatten and loop through the children of a virtual node
+       * @param {import('@wellbye/pxw/lib/preact').ComponentChildren} children The unflattened
+       * children of a virtual node
+       * @returns {import('../types/internal').VNode[]}
+       */
+		function toChildArray(children, out) {
+			out = out || [];
+			if (children == null || typeof children == 'boolean') {
+			}
+			else if (Array.isArray(children)) {
+				children.some(function (child) {
+					toChildArray(child, out);
+				});
+			}
+			else {
+				out.push(children);
+			}
+			return out;
+		}
+		function placeChild(
+			parentDom,
+			childVNode,
+			oldVNode,
+			oldChildren,
+			newDom,
+			oldDom
+		) {
+			var nextDom;
+			if (childVNode.__d !== undefined) {
+				// Only Fragments or components that return Fragment like VNodes will
+				// have a non-undefined _nextDom. Continue the diff from the sibling
+				// of last DOM child of this child VNode
+				nextDom = childVNode.__d;
+
+				// Eagerly cleanup _nextDom. We don't need to persist the value because
+				// it is only used by `diffChildren` to determine where to resume the diff after
+				// diffing Components and Fragments. Once we store it the nextDOM local var, we
+				// can clean up the property
+				childVNode.__d = undefined;
+			}
+			else if (
+				oldVNode == null ||
+          newDom != oldDom ||
+          newDom.parentNode == null
+			) {
+				outer: if (oldDom == null || oldDom.parentNode !== parentDom) {
+					parentDom.appendChild(newDom);
+					nextDom = null;
+				}
+				else {
+					// `j<oldChildrenLength; j+=2` is an alternative to `j++<oldChildrenLength/2`
+					for (
+						var sibDom = oldDom, j = 0;
+						(sibDom = sibDom.nextSibling) && j < oldChildren.length;
+						j += 1
+					) {
+						if (sibDom == newDom) {
+							break outer;
+						}
+					}
+					parentDom.insertBefore(newDom, oldDom);
+					nextDom = oldDom;
+				}
+			}
+
+			// If we have pre-calculated the nextDOM node, use it. Else calculate it now
+			// Strictly check for `undefined` here cuz `null` is a valid value of `nextDom`.
+			// See more detail in create-element.js:createVNode
+			if (nextDom !== undefined) {
+				oldDom = nextDom;
+			}
+			else {
+				oldDom = newDom.nextSibling;
+			}
+			return oldDom;
+		}
+
+		/***/
+	},
+
+	/***/ './src/diff/index.js':
+	/*!***************************!*\
+  !*** ./src/diff/index.js ***!
+  \***************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ applyRef: () => /* binding */ applyRef,
+			/* harmony export */ commitRoot: () => /* binding */ commitRoot,
+			/* harmony export */ diff: () => /* binding */ diff,
+			/* harmony export */ unmount: () => /* binding */ unmount,
+			/* harmony export */
+		});
+		/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ../constants */ './src/constants.js');
+		/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ../component */ './src/component.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ../create-element */ './src/create-element.js');
+		/* harmony import */ var _children__WEBPACK_IMPORTED_MODULE_3__ =
+        __webpack_require__(/*! ./children */ './src/diff/children.js');
+		/* harmony import */ var _props__WEBPACK_IMPORTED_MODULE_4__ =
+        __webpack_require__(/*! ./props */ './src/diff/props.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5__ =
+        __webpack_require__(/*! ../util */ './src/util.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_6__ =
+        __webpack_require__(/*! ../options */ './src/options.js');
+
+		/**
+       * Diff two virtual nodes and apply proper changes to the DOM
+       * @param {import('../types/internal').PreactElement} parentDom The parent of the DOM element
+       * @param {import('../types/internal').VNode} newVNode The new virtual node
+       * @param {import('../types/internal').VNode} oldVNode The old virtual node
+       * @param {object} globalContext The current context object. Modified by getChildContext
+       * @param {boolean} isSvg Whether or not this element is an SVG node
+       * @param {Array<import('../types/internal').PreactElement>} excessDomChildren
+       * @param {Array<import('../types/internal').Component>} commitQueue List of components
+       * which have callbacks to invoke in commitRoot
+       * @param {import('../types/internal').PreactElement} oldDom The current attached DOM
+       * element any new dom elements should be placed around. Likely `null` on first
+       * render (except when hydrating). Can be a sibling DOM element when diffing
+       * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.
+       * @param {boolean} [isHydrating] Whether or not we are in hydration
+       */
+		function diff(
+			parentDom,
+			newVNode,
+			oldVNode,
+			globalContext,
+			isSvg,
+			excessDomChildren,
+			commitQueue,
+			oldDom,
+			isHydrating
+		) {
+			var tmp,
+				newType = newVNode.type;
+
+			// When passing through createElement it assigns the object
+			// constructor as undefined. This to prevent JSON-injection.
+			if (newVNode.constructor !== undefined) return null;
+
+			// If the previous diff bailed out, resume creating/hydrating.
+			if (oldVNode.__h != null) {
+				isHydrating = oldVNode.__h;
+				oldDom = newVNode.__e = oldVNode.__e;
+				// if we resume, we want the tree to be "unlocked"
+				newVNode.__h = null;
+				excessDomChildren = [oldDom];
+			}
+			if ((tmp = _options__WEBPACK_IMPORTED_MODULE_6__['default'].__b))
+				tmp(newVNode);
+			try {
+				outer: if (typeof newType == 'function') {
+					var _newType$prototype2;
+					var c,
+						isNew,
+						oldProps,
+						oldState,
+						snapshot,
+						clearProcessingException;
+					var newProps = newVNode.props;
+
+					// Necessary for createContext api. Setting this property will pass
+					// the context value as `this.context` just for this component.
+					tmp = newType.contextType;
+					var provider = tmp && globalContext[tmp.__c];
+					var componentContext = tmp
+						? provider
+							? provider.props.value
+							: tmp.__
+						: globalContext;
+
+					// Get component and set it to `c`
+					if (oldVNode.__c) {
+						c = newVNode.__c = oldVNode.__c;
+						clearProcessingException = c.__ = c.__E;
+					}
+					else {
+						var _newType$prototype;
+						// Instantiate the new component
+						if (
+							(_newType$prototype = newType.prototype) !== null &&
+                _newType$prototype !== void 0 &&
+                _newType$prototype.render
+						) {
+							// @ts-ignore The check above verifies that newType is suppose to be constructed
+							newVNode.__c = c = new newType(newProps, componentContext); // eslint-disable-line new-cap
+						}
+						else {
+							// @ts-ignore Trust me, Component implements the interface we want
+							newVNode.__c = c =
+                  new _component__WEBPACK_IMPORTED_MODULE_1__.Component(
+                  	newProps,
+                  	componentContext
+                  );
+							c.constructor = newType;
+							c.render = doRender;
+						}
+						if (provider) provider.sub(c);
+						c.props = newProps;
+						if (!c.state) c.state = {};
+						c.context = componentContext;
+						c.__n = globalContext;
+						isNew = c.__d = true;
+						c.__h = [];
+						c._sb = [];
+					}
+
+					// Invoke getDerivedStateFromProps
+					if (c.__s == null) {
+						c.__s = c.state;
+					}
+					if (newType.getDerivedStateFromProps != null) {
+						if (c.__s == c.state) {
+							c.__s = (0, _util__WEBPACK_IMPORTED_MODULE_5__.assign)(
+								{},
+								c.__s
+							);
+						}
+						(0, _util__WEBPACK_IMPORTED_MODULE_5__.assign)(
+							c.__s,
+							newType.getDerivedStateFromProps(newProps, c.__s)
+						);
+					}
+					oldProps = c.props;
+					oldState = c.state;
+
+					// Invoke pre-render lifecycle methods
+					if (isNew) {
+						if (
+							newType.getDerivedStateFromProps == null &&
+                c.componentWillMount != null
+						) {
+							c.componentWillMount();
+						}
+						if (c.componentDidMount != null) {
+							c.__h.push(c.componentDidMount);
+						}
+					}
+					else {
+						if (
+							newType.getDerivedStateFromProps == null &&
+                newProps !== oldProps &&
+                c.componentWillReceiveProps != null
+						) {
+							c.componentWillReceiveProps(newProps, componentContext);
+						}
+						if (
+							(!c.__e &&
+                  c.shouldComponentUpdate != null &&
+                  c.shouldComponentUpdate(newProps, c.__s, componentContext) ===
+                    false) ||
+                newVNode.__v === oldVNode.__v
+						) {
+							c.props = newProps;
+							c.state = c.__s;
+							// More info about this here: https://gist.github.com/JoviDeCroock/bec5f2ce93544d2e6070ef8e0036e4e8
+							if (newVNode.__v !== oldVNode.__v) c.__d = false;
+							c.__v = newVNode;
+							newVNode.__e = oldVNode.__e;
+							newVNode.__k = oldVNode.__k;
+							newVNode.__k.forEach(function (vnode) {
+								if (vnode) vnode.__ = newVNode;
+							});
+							for (var i = 0; i < c._sb.length; i++) {
+								c.__h.push(c._sb[i]);
+							}
+							c._sb = [];
+							if (c.__h.length) {
+								commitQueue.push(c);
+							}
+							break outer;
+						}
+						if (c.componentWillUpdate != null) {
+							c.componentWillUpdate(newProps, c.__s, componentContext);
+						}
+						if (c.componentDidUpdate != null) {
+							c.__h.push(function () {
+								c.componentDidUpdate(oldProps, oldState, snapshot);
+							});
+						}
+					}
+					c.context = componentContext;
+					c.props = newProps;
+					c.__v = newVNode;
+					c.__P = parentDom;
+					var renderHook =
+                _options__WEBPACK_IMPORTED_MODULE_6__['default'].__r,
+						count = 0;
+					if (
+						(_newType$prototype2 = newType.prototype) !== null &&
+              _newType$prototype2 !== void 0 &&
+              _newType$prototype2.render
+					) {
+						c.state = c.__s;
+						c.__d = false;
+						if (renderHook) renderHook(newVNode);
+						tmp = c.render(c.props, c.state, c.context);
+						for (var _i = 0; _i < c._sb.length; _i++) {
+							c.__h.push(c._sb[_i]);
+						}
+						c._sb = [];
+					}
+					else {
+						do {
+							c.__d = false;
+							if (renderHook) renderHook(newVNode);
+							tmp = c.render(c.props, c.state, c.context);
+
+							// Handle setState called in render, see #2553
+							c.state = c.__s;
+						} while (c.__d && ++count < 25);
+					}
+
+					// Handle setState called in render, see #2553
+					c.state = c.__s;
+					if (c.getChildContext != null) {
+						globalContext = (0, _util__WEBPACK_IMPORTED_MODULE_5__.assign)(
+							(0, _util__WEBPACK_IMPORTED_MODULE_5__.assign)(
+								{},
+								globalContext
+							),
+							c.getChildContext()
+						);
+					}
+					if (!isNew && c.getSnapshotBeforeUpdate != null) {
+						snapshot = c.getSnapshotBeforeUpdate(oldProps, oldState);
+					}
+					var isTopLevelFragment =
+              tmp != null &&
+              tmp.type ===
+                _create_element__WEBPACK_IMPORTED_MODULE_2__.Fragment &&
+              tmp.key == null;
+					var renderResult = isTopLevelFragment ? tmp.props.children : tmp;
+					(0, _children__WEBPACK_IMPORTED_MODULE_3__.diffChildren)(
+						parentDom,
+						Array.isArray(renderResult) ? renderResult : [renderResult],
+						newVNode,
+						oldVNode,
+						globalContext,
+						isSvg,
+						excessDomChildren,
+						commitQueue,
+						oldDom,
+						isHydrating
+					);
+					c.base = newVNode.__e;
+
+					// We successfully rendered this VNode, unset any stored hydration/bailout state:
+					newVNode.__h = null;
+					if (c.__h.length) {
+						commitQueue.push(c);
+					}
+					if (clearProcessingException) {
+						c.__E = c.__ = null;
+					}
+					c.__e = false;
+				}
+				else if (
+					excessDomChildren == null &&
+            newVNode.__v === oldVNode.__v
+				) {
+					newVNode.__k = oldVNode.__k;
+					newVNode.__e = oldVNode.__e;
+				}
+				else {
+					var dom;
+					dom = diffElementNodes(
+						oldVNode.__e,
+						newVNode,
+						oldVNode,
+						globalContext,
+						isSvg,
+						excessDomChildren,
+						commitQueue,
+						isHydrating
+					);
+					newVNode.__e = dom;
+				}
+				if ((tmp = _options__WEBPACK_IMPORTED_MODULE_6__['default'].diffed))
+					tmp(newVNode);
+			}
+			catch (e) {
+				newVNode.__v = null;
+				// if hydrating or creating initial tree, bailout preserves DOM:
+				if (isHydrating || excessDomChildren != null) {
+					newVNode.__e = oldDom;
+					newVNode.__h = !!isHydrating;
+					excessDomChildren[excessDomChildren.indexOf(oldDom)] = null;
+					// ^ could possibly be simplified to:
+					// excessDomChildren.length = 0;
+				}
+
+				_options__WEBPACK_IMPORTED_MODULE_6__['default'].__e(
+					e,
+					newVNode,
+					oldVNode
+				);
+			}
+		}
+
+		/**
+       * @param {Array<import('../types/internal').Component>} commitQueue List of components
+       * which have callbacks to invoke in commitRoot
+       * @param {import('../types/internal').VNode} root
+       */
+		function commitRoot(commitQueue, root) {
+			if (_options__WEBPACK_IMPORTED_MODULE_6__['default'].__c)
+				_options__WEBPACK_IMPORTED_MODULE_6__['default'].__c(
+					root,
+					commitQueue
+				);
+			commitQueue.some(function (c) {
+				try {
+					// @ts-ignore Reuse the commitQueue variable here so the type changes
+					commitQueue = c.__h;
+					c.__h = [];
+					commitQueue.some(function (cb) {
+						// @ts-ignore See above ts-ignore on commitQueue
+						cb.call(c);
+					});
+				}
+				catch (e) {
+					_options__WEBPACK_IMPORTED_MODULE_6__['default'].__e(e, c.__v);
+				}
+			});
+		}
+
+		/**
+       * Diff two virtual nodes representing DOM element
+       * @param {import('../types/internal').PreactElement} dom The DOM element representing
+       * the virtual nodes being diffed
+       * @param {import('../types/internal').VNode} newVNode The new virtual node
+       * @param {import('../types/internal').VNode} oldVNode The old virtual node
+       * @param {object} globalContext The current context object
+       * @param {boolean} isSvg Whether or not this DOM node is an SVG node
+       * @param {*} excessDomChildren
+       * @param {Array<import('../types/internal').Component>} commitQueue List of components
+       * which have callbacks to invoke in commitRoot
+       * @param {boolean} isHydrating Whether or not we are in hydration
+       * @returns {import('../types/internal').PreactElement}
+       */
+		function diffElementNodes(
+			dom,
+			newVNode,
+			oldVNode,
+			globalContext,
+			isSvg,
+			excessDomChildren,
+			commitQueue,
+			isHydrating
+		) {
+			var oldProps = oldVNode.props;
+			var newProps = newVNode.props;
+			var nodeType = newVNode.type;
+			var i = 0;
+
+			// Tracks entering and exiting SVG namespace when descending through the tree.
+			if (nodeType === 'svg') isSvg = true;
+			if (excessDomChildren != null) {
+				for (; i < excessDomChildren.length; i++) {
+					var child = excessDomChildren[i];
+
+					// if newVNode matches an element in excessDomChildren or the `dom`
+					// argument matches an element in excessDomChildren, remove it from
+					// excessDomChildren so it isn't later removed in diffChildren
+					if (
+						child &&
+              'setAttribute' in child === !!nodeType &&
+              (nodeType ? child.localName === nodeType : child.nodeType === 3)
+					) {
+						dom = child;
+						excessDomChildren[i] = null;
+						break;
+					}
+				}
+			}
+			if (dom == null) {
+				if (nodeType === null) {
+					// @ts-ignore createTextNode returns Text, we expect PreactElement
+					// console.log('---',newProps);
+
+					return document.createTextNode(newProps);
+				}
+				if (isSvg) {
+					dom = document.createElementNS(
+						'http://www.w3.org/2000/svg',
+						// @ts-ignore We know `newVNode.type` is a string
+						nodeType
+					);
+				}
+				else {
+					dom = document.createElement(
+						// @ts-ignore We know `newVNode.type` is a string
+						nodeType,
+						newProps.is && newProps
+					);
+				}
+
+				// we created a new parent, so none of the previously attached children can be reused:
+				excessDomChildren = null;
+				// we are creating a new node, so we can assume this is a new subtree (in case we are hydrating), this deopts the hydrate
+				isHydrating = false;
+			}
+			dom.__v = newVNode;
+			if (nodeType === null) {
+				// During hydration, we still have to split merged text from SSR'd HTML.
+				if (
+					oldProps !== newProps &&
+            (!isHydrating || dom.data !== newProps)
+				) {
+					dom.data = newProps;
+				}
+			}
+			else {
+				// If excessDomChildren was not null, repopulate it with the current element's children:
+				excessDomChildren =
+            excessDomChildren &&
+            _util__WEBPACK_IMPORTED_MODULE_5__.slice.call(dom.childNodes);
+				oldProps =
+            oldVNode.props || _constants__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ;
+				var oldHtml = oldProps.dangerouslySetInnerHTML;
+				var newHtml = newProps.dangerouslySetInnerHTML;
+
+				// During hydration, props are not diffed at all (including dangerouslySetInnerHTML)
+				// @TODO we should warn in debug mode when props don't match here.
+				if (!isHydrating) {
+					// But, if we are in a situation where we are using existing DOM (e.g. replaceNode)
+					// we should read the existing DOM attributes to diff them
+					if (excessDomChildren != null) {
+						oldProps = {};
+						for (i = 0; i < dom.attributes.length; i++) {
+							oldProps[dom.attributes[i].name] = dom.attributes[i].value;
+						}
+					}
+					if (newHtml || oldHtml) {
+						// Avoid re-applying the same '__html' if it did not changed between re-render
+						if (
+							!newHtml ||
+                ((!oldHtml || newHtml.__html != oldHtml.__html) &&
+                  newHtml.__html !== dom.innerHTML)
+						) {
+							dom.innerHTML = (newHtml && newHtml.__html) || '';
+						}
+					}
+				}
+				(0, _props__WEBPACK_IMPORTED_MODULE_4__.diffProps)(
+					dom,
+					newProps,
+					oldProps,
+					isSvg,
+					isHydrating
+				);
+
+				// If the new vnode didn't have dangerouslySetInnerHTML, diff its children
+				if (newHtml) {
+					newVNode.__k = [];
+				}
+				else {
+					var _i2 = newVNode.props.children;
+					(0, _children__WEBPACK_IMPORTED_MODULE_3__.diffChildren)(
+						dom,
+						Array.isArray(_i2) ? _i2 : [_i2],
+						newVNode,
+						oldVNode,
+						globalContext,
+						isSvg && nodeType !== 'foreignObject',
+						excessDomChildren,
+						commitQueue,
+						excessDomChildren
+							? excessDomChildren[0]
+							: oldVNode.__k &&
+                    (0, _component__WEBPACK_IMPORTED_MODULE_1__.getDomSibling)(
+                    	oldVNode,
+                    	0
+                    ),
+						isHydrating
+					);
+					// Remove children that are not part of any vnode.
+					if (excessDomChildren != null) {
+						for (_i2 = excessDomChildren.length; _i2--; ) {
+							if (excessDomChildren[_i2] != null)
+								(0, _util__WEBPACK_IMPORTED_MODULE_5__.removeNode)(
+									excessDomChildren[_i2]
+								);
+						}
+					}
+				}
+
+				// (as above, don't diff props during hydration)
+				if (!isHydrating) {
+					if (
+						'value' in newProps &&
+              (i = newProps.value) !== undefined &&
+              // #2756 For the <progress>-element the initial value is 0,
+              // despite the attribute not being present. When the attribute
+              // is missing the progress bar is treated as indeterminate.
+              // To fix that we'll always update it when it is 0 for progress elements
+              (i !== dom.value ||
+                (nodeType === 'progress' && !i) ||
+                // This is only for IE 11 to fix <select> value not being updated.
+                // To avoid a stale select value we need to set the option.value
+                // again, which triggers IE11 to re-evaluate the select value
+                (nodeType === 'option' && i !== oldProps.value))
+					) {
+						(0, _props__WEBPACK_IMPORTED_MODULE_4__.setProperty)(
+							dom,
+							'value',
+							i,
+							oldProps.value,
+							false
+						);
+					}
+					if (
+						'checked' in newProps &&
+              (i = newProps.checked) !== undefined &&
+              i !== dom.checked
+					) {
+						(0, _props__WEBPACK_IMPORTED_MODULE_4__.setProperty)(
+							dom,
+							'checked',
+							i,
+							oldProps.checked,
+							false
+						);
+					}
+				}
+			}
+			return dom;
+		}
+
+		/**
+       * Invoke or update a ref, depending on whether it is a function or object ref.
+       * @param {object|function} ref
+       * @param {any} value
+       * @param {import('../types/internal').VNode} vnode
+       */
+		function applyRef(ref, value, vnode) {
+			try {
+				if (typeof ref == 'function') ref(value);
+				else ref.current = value;
+			}
+			catch (e) {
+				_options__WEBPACK_IMPORTED_MODULE_6__['default'].__e(e, vnode);
+			}
+		}
+
+		/**
+       * Unmount a virtual node from the tree and apply DOM changes
+       * @param {import('../types/internal').VNode} vnode The virtual node to unmount
+       * @param {import('../types/internal').VNode} parentVNode The parent of the VNode that
+       * initiated the unmount
+       * @param {boolean} [skipRemove] Flag that indicates that a parent node of the
+       * current element is already detached from the DOM.
+       */
+		function unmount(vnode, parentVNode, skipRemove) {
+			var r;
+			if (_options__WEBPACK_IMPORTED_MODULE_6__['default'].unmount)
+				_options__WEBPACK_IMPORTED_MODULE_6__['default'].unmount(vnode);
+			if ((r = vnode.ref)) {
+				if (!r.current || r.current === vnode.__e) {
+					applyRef(r, null, parentVNode);
+				}
+			}
+			if ((r = vnode.__c) != null) {
+				if (r.componentWillUnmount) {
+					try {
+						r.componentWillUnmount();
+					}
+					catch (e) {
+						_options__WEBPACK_IMPORTED_MODULE_6__['default'].__e(
+							e,
+							parentVNode
+						);
+					}
+				}
+				r.base = r.__P = null;
+				vnode.__c = undefined;
+			}
+			if ((r = vnode.__k)) {
+				for (var i = 0; i < r.length; i++) {
+					if (r[i]) {
+						unmount(
+							r[i],
+							parentVNode,
+							skipRemove || typeof vnode.type !== 'function'
+						);
+					}
+				}
+			}
+			if (!skipRemove && vnode.__e != null) {
+				(0, _util__WEBPACK_IMPORTED_MODULE_5__.removeNode)(vnode.__e);
+			}
+
+			// Must be set to `undefined` to properly clean up `_nextDom`
+			// for which `null` is a valid value. See comment in `create-element.js`
+			vnode.__ = vnode.__e = vnode.__d = undefined;
+		}
+
+		/** The `.render()` method for a PFC backing instance. */
+		function doRender(props, state, context) {
+			return this.constructor(props, context);
+		}
+
+		/***/
+	},
+
+	/***/ './src/diff/props.js':
+	/*!***************************!*\
+  !*** ./src/diff/props.js ***!
+  \***************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ diffProps: () => /* binding */ diffProps,
+			/* harmony export */ setProperty: () => /* binding */ setProperty,
+			/* harmony export */
+		});
+		/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ../constants */ './src/constants.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ../options */ './src/options.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ../util */ './src/util.js');
+
+		/**
+       * Diff the old and new properties of a VNode and apply changes to the DOM node
+       * @param {import('../types/internal').PreactElement} dom The DOM node to apply
+       * changes to
+       * @param {object} newProps The new props
+       * @param {object} oldProps The old props
+       * @param {boolean} isSvg Whether or not this node is an SVG node
+       * @param {boolean} hydrate Whether or not we are in hydration mode
+       */
+		function diffProps(dom, newProps, oldProps, isSvg, hydrate) {
+			var i;
+			for (i in oldProps) {
+				if (i !== 'children' && i !== 'key' && !(i in newProps)) {
+					setProperty(dom, i, null, oldProps[i], isSvg);
+				}
+			}
+			for (i in newProps) {
+				if (
+					(!hydrate || typeof newProps[i] == 'function') &&
+            i !== 'children' &&
+            i !== 'key' &&
+            i !== 'value' &&
+            i !== 'checked' &&
+            oldProps[i] !== newProps[i]
+				) {
+					setProperty(dom, i, newProps[i], oldProps[i], isSvg);
+				}
+			}
+		}
+		function setStyle(style, key, value) {
+			if (key[0] === '-') {
+				style.setProperty(key, value);
+			}
+			else if (value == null) {
+				style[key] = '';
+			}
+			else if (
+				typeof value != 'number' ||
+          _constants__WEBPACK_IMPORTED_MODULE_0__.IS_NON_DIMENSIONAL.test(key)
+			) {
+				style[key] = value;
+			}
+			else {
+				style[key] = value + 'px';
+			}
+		}
+
+		/**
+       * Set a property value on a DOM node
+       * @param {import('../types/internal').PreactElement} dom The DOM node to modify
+       * @param {string} name The name of the property to set
+       * @param {*} value The value to set the property to
+       * @param {*} oldValue The old value the property had
+       * @param {boolean} isSvg Whether or not this DOM node is an SVG node or not
+       */
+		function setProperty(dom, name, value, oldValue, isSvg) {
+			var useCapture;
+			o: if (name === 'style') {
+				if (typeof value == 'string') {
+					dom.style.cssText = value;
+				}
+				else {
+					if (typeof oldValue == 'string') {
+						dom.style.cssText = oldValue = '';
+					}
+					if (oldValue) {
+						for (name in oldValue) {
+							if (!(value && name in value)) {
+								setStyle(dom.style, name, '');
+							}
+						}
+					}
+					if (value) {
+						for (name in value) {
+							if (!oldValue || value[name] !== oldValue[name]) {
+								setStyle(dom.style, name, value[name]);
+							}
+						}
+					}
+				}
+			}
+			// Benchmark for comparison: https://esbench.com/bench/574c954bdb965b9a00965ac6
+			else if (name[0] === 'o' && name[1] === 'n') {
+				useCapture = name !== (name = name.replace(/Capture$/, ''));
+
+				// Infer correct casing for DOM built-in events:
+				if (name.toLowerCase() in dom) name = name.toLowerCase().slice(2);
+				else name = name.slice(2);
+				if (!dom.l) dom.l = {};
+				dom.l[name + useCapture] = value;
+				if (value) {
+					if (!oldValue) {
+						var handler = useCapture ? eventProxyCapture : eventProxy;
+						dom.addEventListener(name, handler, useCapture);
+					}
+				}
+				else {
+					var _handler = useCapture ? eventProxyCapture : eventProxy;
+					dom.removeEventListener(name, _handler, useCapture);
+				}
+			}
+			else if (name !== 'dangerouslySetInnerHTML') {
+				if (isSvg) {
+					// Normalize incorrect prop usage for SVG:
+					// - xlink:href / xlinkHref --> href (xlink:href was removed from SVG and isn't needed)
+					// - className --> class
+					name = name.replace(/xlink(H|:h)/, 'h').replace(/sName$/, 's');
+				}
+				else if (
+					name !== 'href' &&
+            name !== 'list' &&
+            name !== 'form' &&
+            // Default value in browsers is `-1` and an empty string is
+            // cast to `0` instead
+            name !== 'tabIndex' &&
+            name !== 'download' &&
+            name in dom
+				) {
+					try {
+						dom[name] = value == null ? '' : value;
+						// labelled break is 1b smaller here than a return statement (sorry)
+						break o;
+					}
+					catch (e) {}
+				}
+
+				// ARIA-attributes have a different notion of boolean values.
+				// The value `false` is different from the attribute not
+				// existing on the DOM, so we can't remove it. For non-boolean
+				// ARIA-attributes we could treat false as a removal, but the
+				// amount of exceptions would cost us too many bytes. On top of
+				// that other VDOM frameworks also always stringify `false`.
+
+				if (typeof value === 'function') {
+					// never serialize functions as attribute values
+				}
+				else if (
+					value != null &&
+            (value !== false || name.indexOf('-') != -1)
+				) {
+					dom.setAttribute(name, value);
+				}
+				else {
+					dom.removeAttribute(name);
+				}
+			}
+		}
+
+		/**
+       * Proxy an event to hooked event handlers
+       * @param {Event} e The event object from the browser
+       * @private
+       */
+		function eventProxy(e) {
+			this.l[e.type + false](
+				_options__WEBPACK_IMPORTED_MODULE_1__['default'].event
+					? _options__WEBPACK_IMPORTED_MODULE_1__['default'].event(e)
+					: e
+			);
+		}
+		function eventProxyCapture(e) {
+			this.l[e.type + true](
+				_options__WEBPACK_IMPORTED_MODULE_1__['default'].event
+					? _options__WEBPACK_IMPORTED_MODULE_1__['default'].event(e)
+					: e
+			);
+		}
+
+		/***/
+	},
+
+	/***/ './src/index.js':
+	/*!**********************!*\
+  !*** ./src/index.js ***!
+  \**********************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ Component: () =>
+			/* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_2__.Component,
+			/* harmony export */ Fragment: () =>
+			/* reexport safe */ _create_element__WEBPACK_IMPORTED_MODULE_1__.Fragment,
+			/* harmony export */ cloneElement: () =>
+			/* reexport safe */ _clone_element__WEBPACK_IMPORTED_MODULE_3__.cloneElement,
+			/* harmony export */ createContext: () =>
+			/* reexport safe */ _create_context__WEBPACK_IMPORTED_MODULE_4__.createContext,
+			/* harmony export */ createElement: () =>
+			/* reexport safe */ _create_element__WEBPACK_IMPORTED_MODULE_1__.createElement,
+			/* harmony export */ createRef: () =>
+			/* reexport safe */ _create_element__WEBPACK_IMPORTED_MODULE_1__.createRef,
+			/* harmony export */ h: () =>
+			/* reexport safe */ _create_element__WEBPACK_IMPORTED_MODULE_1__.createElement,
+			/* harmony export */ hydrate: () =>
+			/* reexport safe */ _render__WEBPACK_IMPORTED_MODULE_0__.hydrate,
+			/* harmony export */ isValidElement: () =>
+			/* reexport safe */ _create_element__WEBPACK_IMPORTED_MODULE_1__.isValidElement,
+			/* harmony export */ options: () =>
+			/* reexport safe */ _options__WEBPACK_IMPORTED_MODULE_6__['default'],
+			/* harmony export */ render: () =>
+			/* reexport safe */ _render__WEBPACK_IMPORTED_MODULE_0__.render,
+			/* harmony export */ toChildArray: () =>
+			/* reexport safe */ _diff_children__WEBPACK_IMPORTED_MODULE_5__.toChildArray,
+			/* harmony export */
+		});
+		/* harmony import */ var _render__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./render */ './src/render.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./create-element */ './src/create-element.js');
+		/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ./component */ './src/component.js');
+		/* harmony import */ var _clone_element__WEBPACK_IMPORTED_MODULE_3__ =
+        __webpack_require__(/*! ./clone-element */ './src/clone-element.js');
+		/* harmony import */ var _create_context__WEBPACK_IMPORTED_MODULE_4__ =
+        __webpack_require__(/*! ./create-context */ './src/create-context.js');
+		/* harmony import */ var _diff_children__WEBPACK_IMPORTED_MODULE_5__ =
+        __webpack_require__(/*! ./diff/children */ './src/diff/children.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_6__ =
+        __webpack_require__(/*! ./options */ './src/options.js');
+
+		/***/
+	},
+
+	/***/ './src/options.js':
+	/*!************************!*\
+  !*** ./src/options.js ***!
+  \************************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ default: () => __WEBPACK_DEFAULT_EXPORT__,
+			/* harmony export */
+		});
+		/* harmony import */ var _diff_catch_error__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(
+        	/*! ./diff/catch-error */ './src/diff/catch-error.js'
+        );
+
+		/**
+       * The `option` object can potentially contain callback functions
+       * that are called during various stages of our renderer. This is the
+       * foundation on which all our addons like `preact/debug`, `preact/compat`,
+       * and `preact/hooks` are based on. See the `Options` type in `internal.d.ts`
+       * for a full list of available option hooks (most editors/IDEs allow you to
+       * ctrl+click or cmd+click on mac the type definition below).
+       * @type {import('./internal').Options}
+       */
+		var options = {
+			__e: _diff_catch_error__WEBPACK_IMPORTED_MODULE_0__._catchError,
+		};
+		/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = options;
+
+		/***/
+	},
+
+	/***/ './src/render.js':
+	/*!***********************!*\
+  !*** ./src/render.js ***!
+  \***********************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ hydrate: () => /* binding */ hydrate,
+			/* harmony export */ render: () => /* binding */ render,
+			/* harmony export */
+		});
+		/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./constants */ './src/constants.js');
+		/* harmony import */ var _diff_index__WEBPACK_IMPORTED_MODULE_1__ =
+        __webpack_require__(/*! ./diff/index */ './src/diff/index.js');
+		/* harmony import */ var _create_element__WEBPACK_IMPORTED_MODULE_2__ =
+        __webpack_require__(/*! ./create-element */ './src/create-element.js');
+		/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_3__ =
+        __webpack_require__(/*! ./options */ './src/options.js');
+		/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_4__ =
+        __webpack_require__(/*! ./util */ './src/util.js');
+
+		/**
+       * Render a Preact virtual node into a DOM element
+       * @param {import('./internal').ComponentChild} vnode The virtual node to render
+       * @param {import('./internal').PreactElement} parentDom The DOM element to
+       * render into
+       * @param {import('./internal').PreactElement | object} [replaceNode] Optional: Attempt to re-use an
+       * existing DOM tree rooted at `replaceNode`
+       */
+		function render(vnode, parentDom, replaceNode) {
+			if (_options__WEBPACK_IMPORTED_MODULE_3__['default'].__)
+				_options__WEBPACK_IMPORTED_MODULE_3__['default'].__(vnode, parentDom);
+
+			// We abuse the `replaceNode` parameter in `hydrate()` to signal if we are in
+			// hydration mode or not by passing the `hydrate` function instead of a DOM
+			// element..
+			var isHydrating = typeof replaceNode === 'function';
+
+			// To be able to support calling `render()` multiple times on the same
+			// DOM node, we need to obtain a reference to the previous tree. We do
+			// this by assigning a new `_children` property to DOM nodes which points
+			// to the last rendered tree. By default this property is not present, which
+			// means that we are mounting a new tree for the first time.
+			var oldVNode = isHydrating
+				? null
+				: (replaceNode && replaceNode.__k) || parentDom.__k;
+			vnode = ((!isHydrating && replaceNode) || parentDom).__k = (0,
+			_create_element__WEBPACK_IMPORTED_MODULE_2__.createElement)(
+				_create_element__WEBPACK_IMPORTED_MODULE_2__.Fragment,
+				null,
+				[vnode]
+			);
+
+			// List of effects that need to be called after diffing.
+			var commitQueue = [];
+			vnode.props.id = 'proot';
+			(0, _diff_index__WEBPACK_IMPORTED_MODULE_1__.diff)(
+				parentDom,
+				// Determine the new vnode tree and store it on the DOM element on
+				// our custom `_children` property.
+				vnode,
+				oldVNode || _constants__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ,
+				_constants__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ,
+				parentDom.ownerSVGElement !== undefined,
+				!isHydrating && replaceNode
+					? [replaceNode]
+					: oldVNode
+						? null
+						: parentDom.firstChild
+							? _util__WEBPACK_IMPORTED_MODULE_4__.slice.call(
+								parentDom.childNodes
+							)
+							: null,
+				commitQueue,
+				!isHydrating && replaceNode
+					? replaceNode
+					: oldVNode
+						? oldVNode.__e
+						: parentDom.firstChild,
+				isHydrating
+			);
+
+			// Flush all queued effects
+			(0, _diff_index__WEBPACK_IMPORTED_MODULE_1__.commitRoot)(
+				commitQueue,
+				vnode
+			);
+			return commitQueue;
+		}
+
+		/**
+ * Update an existing DOM element with data from a Preact virtual node
+ * @param {import('./internal').ComponentChild} vnode The virtual node to render
+ * @param {import('./internal').PreactElement} parentDom The DOM element to
+ * updateimport logger from '../demo/logger';
+
+ */
+		function hydrate(vnode, parentDom) {
+			render(vnode, parentDom, hydrate);
+		}
+
+		/***/
+	},
+
+	/***/ './src/util.js':
+	/*!*********************!*\
+  !*** ./src/util.js ***!
+  \*********************/
+	/***/ (
+		__unused_webpack_module,
+		__webpack_exports__,
+		__webpack_require__
+	) => {
+		__webpack_require__.r(__webpack_exports__);
+		/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+			/* harmony export */ assign: () => /* binding */ assign,
+			/* harmony export */ makeTaskQueue: () => /* binding */ makeTaskQueue,
+			/* harmony export */ removeNode: () => /* binding */ removeNode,
+			/* harmony export */ slice: () => /* binding */ slice,
+			/* harmony export */ vnName: () => /* binding */ vnName,
+			/* harmony export */
+		});
+		/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_0__ =
+        __webpack_require__(/*! ./constants */ './src/constants.js');
+
+		/**
+       * Assign properties from `props` to `obj`
+       * @template O, P The obj and props types
+       * @param {O} obj The object to copy properties to
+       * @param {P} props The object to copy properties from
+       * @returns {O & P}
+       */
+		function assign(obj, props) {
+			// @ts-ignore We change the type of `obj` to be `O & P`
+			for (var i in props) {
+				obj[i] = props[i];
+			}
+			return /** @type {O & P} */ obj;
+		}
+
+		/**
+       * Remove a child node from its parent if attached. This is a workaround for
+       * IE11 which doesn't support `Element.prototype.remove()`. Using this function
+       * is smaller than including a dedicated polyfill.
+       * @param {Node} node The node to remove
+       */
+		function removeNode(node) {
+			var parentNode = node.parentNode;
+			if (parentNode) parentNode.removeChild(node);
+		}
+		var slice = _constants__WEBPACK_IMPORTED_MODULE_0__.EMPTY_ARR.slice;
+		function makeTaskQueue(que) {
+			que.task = {};
+			que.task.pushChild = function (where, f) {
+				if (!que.cur) {
+					que.cur = {
+						children: [],
+						task: f,
+					};
+					que.root = que.cur;
+				}
+				else {
+					que.cur.children.push({
+						children: [],
+						task: f,
+						parent: que.cur,
+					});
+				}
+			};
+			que.task.run = function () {
+				var maxStep = 1000;
+				while (que.cur) {
+					var _que$cur = que.cur,
+						cpos = _que$cur.cpos,
+						children = _que$cur.children,
+						task = _que$cur.task,
+						parent = _que$cur.parent;
+					// console.log('ctask',i);
+
+					if (!cpos) {
+						if (task) {
+							que.cur.ret = task();
+						}
+						cpos = 0;
+					}
+					if (cpos < children.length) {
+						var next = children[cpos];
+						que.cur.cpos = cpos + 1;
+						que.cur = next;
+					}
+					else if (parent) {
+						que.lastRet = que.cur.ret;
+						que.cur = parent;
+					}
+					else {
+						break;
+					}
+
+					// if(--maxStep < 0)break;
+				}
+			};
+		}
+
+		function vnName(vnode, noDepth) {
+			var _vnode$props;
+			var name = vnode.type;
+			if (typeof name == 'function') {
+				name = name.name;
+			}
+			if (
+				(_vnode$props = vnode.props) !== null &&
+          _vnode$props !== void 0 &&
+          _vnode$props.id
+			)
+				name += '#' + vnode.props.id;
+			if (name == null) name = '#text<'.concat(vnode.props, '>');
+			if (!noDepth) {
+				var dp = '  '.repeat(vnode.__b);
+				name = dp + name;
+			}
+			return name;
+		}
+
+		/***/
+	},
+
+	/******/
+};
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+	/******/ // Check if module is in cache
+	/******/ var cachedModule = __webpack_module_cache__[moduleId];
+	/******/ if (cachedModule !== undefined) {
+		/******/ return cachedModule.exports;
+		/******/
+	}
+	/******/ // Create a new module (and put it into the cache)
+	/******/ var module = (__webpack_module_cache__[moduleId] = {
+		/******/ // no module.id needed
+		/******/ // no module.loaded needed
+		/******/ exports: {},
+		/******/
+	});
+	/******/
+	/******/ // Execute the module function
+	/******/ __webpack_modules__[moduleId](
+		module,
+		module.exports,
+		__webpack_require__
+	);
+	/******/
+	/******/ // Return the exports of the module
+	/******/ return module.exports;
+	/******/
+}
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+	/******/ // define getter functions for harmony exports
+	/******/ __webpack_require__.d = (exports, definition) => {
+		/******/ for (var key in definition) {
+			/******/ if (
+				__webpack_require__.o(definition, key) &&
+        !__webpack_require__.o(exports, key)
+			) {
+				/******/ Object.defineProperty(exports, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+				/******/
+			}
+			/******/
+		}
+		/******/
+	};
+	/******/
+})();
+/******/
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+	/******/ __webpack_require__.o = (obj, prop) =>
+		Object.prototype.hasOwnProperty.call(obj, prop);
+	/******/
+})();
+/******/
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+	/******/ // define __esModule on exports
+	/******/ __webpack_require__.r = (exports) => {
+		/******/ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+			/******/ Object.defineProperty(exports, Symbol.toStringTag, {
+				value: 'Module',
+			});
+			/******/
+		}
+		/******/ Object.defineProperty(exports, '__esModule', { value: true });
+		/******/
+	};
+	/******/
+})();
+/******/
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+	/*!*****************************!*\
+  !*** ./compat/src/index.js ***!
+  \*****************************/
+	__webpack_require__.r(__webpack_exports__);
+	/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+		/* harmony export */ Children: () =>
+		/* reexport safe */ _Children__WEBPACK_IMPORTED_MODULE_5__.Children,
+		/* harmony export */ Component: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.Component,
+		/* harmony export */ Fragment: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.Fragment,
+		/* harmony export */ PureComponent: () =>
+		/* reexport safe */ _PureComponent__WEBPACK_IMPORTED_MODULE_2__.PureComponent,
+		/* harmony export */ StrictMode: () => /* binding */ StrictMode,
+		/* harmony export */ Suspense: () =>
+		/* reexport safe */ _suspense__WEBPACK_IMPORTED_MODULE_6__.Suspense,
+		/* harmony export */ SuspenseList: () =>
+		/* reexport safe */ _suspense_list__WEBPACK_IMPORTED_MODULE_7__.SuspenseList,
+		/* harmony export */ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:
+      () =>
+      /* reexport safe */ _render__WEBPACK_IMPORTED_MODULE_10__.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+		/* harmony export */ cloneElement: () => /* binding */ cloneElement,
+		/* harmony export */ createContext: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.createContext,
+		/* harmony export */ createElement: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.createElement,
+		/* harmony export */ createFactory: () => /* binding */ createFactory,
+		/* harmony export */ createPortal: () =>
+		/* reexport safe */ _portals__WEBPACK_IMPORTED_MODULE_8__.createPortal,
+		/* harmony export */ createRef: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.createRef,
+		/* harmony export */ default: () => __WEBPACK_DEFAULT_EXPORT__,
+		/* harmony export */ findDOMNode: () => /* binding */ findDOMNode,
+		/* harmony export */ flushSync: () => /* binding */ flushSync,
+		/* harmony export */ forwardRef: () =>
+		/* reexport safe */ _forwardRef__WEBPACK_IMPORTED_MODULE_4__.forwardRef,
+		/* harmony export */ hydrate: () =>
+		/* reexport safe */ _render__WEBPACK_IMPORTED_MODULE_10__.hydrate,
+		/* harmony export */ isValidElement: () => /* binding */ isValidElement,
+		/* harmony export */ lazy: () =>
+		/* reexport safe */ _suspense__WEBPACK_IMPORTED_MODULE_6__.lazy,
+		/* harmony export */ memo: () =>
+		/* reexport safe */ _memo__WEBPACK_IMPORTED_MODULE_3__.memo,
+		/* harmony export */ options: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.options,
+		/* harmony export */ render: () =>
+		/* reexport safe */ _render__WEBPACK_IMPORTED_MODULE_10__.render,
+		/* harmony export */ startTransition: () => /* binding */ startTransition,
+		/* harmony export */ toChildArray: () =>
+		/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray,
+		/* harmony export */ unmountComponentAtNode: () =>
+		/* binding */ unmountComponentAtNode,
+		/* harmony export */ unstable_batchedUpdates: () =>
+		/* binding */ unstable_batchedUpdates,
+		/* harmony export */ useCallback: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useCallback,
+		/* harmony export */ useContext: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useContext,
+		/* harmony export */ useDebugValue: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useDebugValue,
+		/* harmony export */ useDeferredValue: () => /* binding */ useDeferredValue,
+		/* harmony export */ useEffect: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useEffect,
+		/* harmony export */ useErrorBoundary: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useErrorBoundary,
+		/* harmony export */ useId: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useId,
+		/* harmony export */ useImperativeHandle: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useImperativeHandle,
+		/* harmony export */ useInsertionEffect: () =>
+		/* binding */ useInsertionEffect,
+		/* harmony export */ useLayoutEffect: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useLayoutEffect,
+		/* harmony export */ useMemo: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useMemo,
+		/* harmony export */ useReducer: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useReducer,
+		/* harmony export */ useRef: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useRef,
+		/* harmony export */ useState: () =>
+		/* reexport safe */ preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useState,
+		/* harmony export */ useSyncExternalStore: () =>
+		/* binding */ useSyncExternalStore,
+		/* harmony export */ useTransition: () => /* binding */ useTransition,
+		/* harmony export */ version: () => /* binding */ version,
+		/* harmony export */
+	});
+	/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ =
+    __webpack_require__(/*! preact */ './src/index.js');
+	/* harmony import */ var preact_hooks__WEBPACK_IMPORTED_MODULE_1__ =
+    __webpack_require__(/*! preact/hooks */ './hooks/src/index.js');
+	/* harmony import */ var _PureComponent__WEBPACK_IMPORTED_MODULE_2__ =
+    __webpack_require__(/*! ./PureComponent */ './compat/src/PureComponent.js');
+	/* harmony import */ var _memo__WEBPACK_IMPORTED_MODULE_3__ =
+    __webpack_require__(/*! ./memo */ './compat/src/memo.js');
+	/* harmony import */ var _forwardRef__WEBPACK_IMPORTED_MODULE_4__ =
+    __webpack_require__(/*! ./forwardRef */ './compat/src/forwardRef.js');
+	/* harmony import */ var _Children__WEBPACK_IMPORTED_MODULE_5__ =
+    __webpack_require__(/*! ./Children */ './compat/src/Children.js');
+	/* harmony import */ var _suspense__WEBPACK_IMPORTED_MODULE_6__ =
+    __webpack_require__(/*! ./suspense */ './compat/src/suspense.js');
+	/* harmony import */ var _suspense_list__WEBPACK_IMPORTED_MODULE_7__ =
+    __webpack_require__(/*! ./suspense-list */ './compat/src/suspense-list.js');
+	/* harmony import */ var _portals__WEBPACK_IMPORTED_MODULE_8__ =
+    __webpack_require__(/*! ./portals */ './compat/src/portals.js');
+	/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_9__ =
+    __webpack_require__(/*! ./util */ './compat/src/util.js');
+	/* harmony import */ var _render__WEBPACK_IMPORTED_MODULE_10__ =
+    __webpack_require__(/*! ./render */ './compat/src/render.js');
+	function _slicedToArray(arr, i) {
+		return (
+			_arrayWithHoles(arr) ||
+      _iterableToArrayLimit(arr, i) ||
+      _unsupportedIterableToArray(arr, i) ||
+      _nonIterableRest()
+		);
+	}
+	function _nonIterableRest() {
+		throw new TypeError(
+			'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
+		);
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+		if (!o) return;
+		if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
+		var n = Object.prototype.toString.call(o).slice(8, -1);
+		if (n === 'Object' && o.constructor) n = o.constructor.name;
+		if (n === 'Map' || n === 'Set') return Array.from(o);
+		if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+			return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+		if (len == null || len > arr.length) len = arr.length;
+		for (var i = 0, arr2 = new Array(len); i < len; i++) {
+			arr2[i] = arr[i];
+		}
+		return arr2;
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _i =
+      arr == null
+      	? null
+      	: (typeof Symbol !== 'undefined' && arr[Symbol.iterator]) ||
+          arr['@@iterator'];
+		if (_i == null) return;
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _s, _e;
+		try {
+			for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		}
+		catch (err) {
+			_d = true;
+			_e = err;
+		}
+		finally {
+			try {
+				if (!_n && _i['return'] != null) _i['return']();
+			}
+			finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+
+	var version = '17.0.2'; // trick libraries to think we are react
+
+	/**
+   * Legacy version of createElement.
+   * @param {import('./internal').VNode["type"]} type The node name or Component constructor
+   */
+	function createFactory(type) {
+		return preact__WEBPACK_IMPORTED_MODULE_0__.createElement.bind(null, type);
+	}
+
+	/**
+   * Check if the passed element is a valid (p)react node.
+   * @param {*} element The element to check
+   * @returns {boolean}
+   */
+	function isValidElement(element) {
+		return (
+			!!element &&
+      element.$$typeof ===
+        _render__WEBPACK_IMPORTED_MODULE_10__.REACT_ELEMENT_TYPE
+		);
+	}
+
+	/**
+   * Wrap `cloneElement` to abort if the passed element is not a valid element and apply
+   * all vnode normalizations.
+   * @param {import('./internal').VNode} element The vnode to clone
+   * @param {object} props Props to add when cloning
+   * @param {Array<import('./internal').ComponentChildren>} rest Optional component children
+   */
+	function cloneElement(element) {
+		if (!isValidElement(element)) return element;
+		return preact__WEBPACK_IMPORTED_MODULE_0__.cloneElement.apply(
+			null,
+			arguments
+		);
+	}
+
+	/**
+   * Remove a component tree from the DOM, including state and event handlers.
+   * @param {import('./internal').PreactElement} container
+   * @returns {boolean}
+   */
+	function unmountComponentAtNode(container) {
+		if (container.__k) {
+			(0, preact__WEBPACK_IMPORTED_MODULE_0__.render)(null, container);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+   * Get the matching DOM node for a component
+   * @param {import('./internal').Component} component
+   * @returns {import('./internal').PreactElement | null}
+   */
+
+	function findDOMNode(component) {
+		return (
+			(component &&
+        (component.base || (component.nodeType === 1 && component))) ||
+      null
+		);
+	}
+
+	/**
+   * Deprecated way to control batched rendering inside the reconciler, but we
+   * already schedule in batches inside our rendering code
+   * @template Arg
+   * @param {(arg: Arg) => void} callback function that triggers the updated
+   * @param {Arg} [arg] Optional argument that can be passed to the callback
+   */
+	// eslint-disable-next-line camelcase
+	var unstable_batchedUpdates = function unstable_batchedUpdates(
+		callback,
+		arg
+	) {
+		return callback(arg);
+	};
+
+	/**
+   * In React, `flushSync` flushes the entire tree and forces a rerender. It's
+   * implmented here as a no-op.
+   * @template Arg
+   * @template Result
+   * @param {(arg: Arg) => Result} callback function that runs before the flush
+   * @param {Arg} [arg] Optional arugment that can be passed to the callback
+   * @returns
+   */
+	var flushSync = function flushSync(callback, arg) {
+		return callback(arg);
+	};
+
+	/**
+   * Strict Mode is not implemented in Preact, so we provide a stand-in for it
+   * that just renders its children without imposing any restrictions.
+   */
+	var StrictMode = preact__WEBPACK_IMPORTED_MODULE_0__.Fragment;
+	function startTransition(cb) {
+		cb();
+	}
+	function useDeferredValue(val) {
+		return val;
+	}
+	function useTransition() {
+		return [false, startTransition];
+	}
+
+	// TODO: in theory this should be done after a VNode is diffed as we want to insert
+	// styles/... before it attaches
+	var useInsertionEffect =
+    preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useLayoutEffect;
+
+	/**
+   * This is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84
+   * on a high level this cuts out the warnings, ... and attempts a smaller implementation
+   */
+	function useSyncExternalStore(subscribe, getSnapshot) {
+		var value = getSnapshot();
+		var _useState = (0, preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useState)({
+				_instance: {
+					__: value,
+					_getSnapshot: getSnapshot,
+				},
+			}),
+			_useState2 = _slicedToArray(_useState, 2),
+			_instance = _useState2[0]._instance,
+			forceUpdate = _useState2[1];
+		(0, preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useLayoutEffect)(
+			function () {
+				_instance.__ = value;
+				_instance._getSnapshot = getSnapshot;
+				if (
+					!(0, _util__WEBPACK_IMPORTED_MODULE_9__.is)(
+						_instance.__,
+						getSnapshot()
+					)
+				) {
+					forceUpdate({
+						_instance: _instance,
+					});
+				}
+			},
+			[subscribe, value, getSnapshot]
+		);
+		(0, preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useEffect)(
+			function () {
+				if (
+					!(0, _util__WEBPACK_IMPORTED_MODULE_9__.is)(
+						_instance.__,
+						_instance._getSnapshot()
+					)
+				) {
+					forceUpdate({
+						_instance: _instance,
+					});
+				}
+				return subscribe(function () {
+					if (
+						!(0, _util__WEBPACK_IMPORTED_MODULE_9__.is)(
+							_instance.__,
+							_instance._getSnapshot()
+						)
+					) {
+						forceUpdate({
+							_instance: _instance,
+						});
+					}
+				});
+			},
+			[subscribe]
+		);
+		return value;
+	}
+
+	// React copies the named exports to the default one.
+	/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = {
+		useState: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useState,
+		useId: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useId,
+		useReducer: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useReducer,
+		useEffect: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useEffect,
+		useLayoutEffect: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useLayoutEffect,
+		useInsertionEffect: useInsertionEffect,
+		useTransition: useTransition,
+		useDeferredValue: useDeferredValue,
+		useSyncExternalStore: useSyncExternalStore,
+		startTransition: startTransition,
+		useRef: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useRef,
+		useImperativeHandle:
+      preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useImperativeHandle,
+		useMemo: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useMemo,
+		useCallback: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useCallback,
+		useContext: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useContext,
+		useDebugValue: preact_hooks__WEBPACK_IMPORTED_MODULE_1__.useDebugValue,
+		version: version,
+		Children: _Children__WEBPACK_IMPORTED_MODULE_5__.Children,
+		render: _render__WEBPACK_IMPORTED_MODULE_10__.render,
+		hydrate: _render__WEBPACK_IMPORTED_MODULE_10__.hydrate,
+		unmountComponentAtNode: unmountComponentAtNode,
+		createPortal: _portals__WEBPACK_IMPORTED_MODULE_8__.createPortal,
+		createElement: preact__WEBPACK_IMPORTED_MODULE_0__.createElement,
+		createContext: preact__WEBPACK_IMPORTED_MODULE_0__.createContext,
+		createFactory: createFactory,
+		cloneElement: cloneElement,
+		createRef: preact__WEBPACK_IMPORTED_MODULE_0__.createRef,
+		Fragment: preact__WEBPACK_IMPORTED_MODULE_0__.Fragment,
+		isValidElement: isValidElement,
+		findDOMNode: findDOMNode,
+		Component: preact__WEBPACK_IMPORTED_MODULE_0__.Component,
+		PureComponent: _PureComponent__WEBPACK_IMPORTED_MODULE_2__.PureComponent,
+		memo: _memo__WEBPACK_IMPORTED_MODULE_3__.memo,
+		forwardRef: _forwardRef__WEBPACK_IMPORTED_MODULE_4__.forwardRef,
+		flushSync: flushSync,
+		unstable_batchedUpdates: unstable_batchedUpdates,
+		StrictMode: StrictMode,
+		Suspense: _suspense__WEBPACK_IMPORTED_MODULE_6__.Suspense,
+		SuspenseList: _suspense_list__WEBPACK_IMPORTED_MODULE_7__.SuspenseList,
+		lazy: _suspense__WEBPACK_IMPORTED_MODULE_6__.lazy,
+		toChildArray: preact__WEBPACK_IMPORTED_MODULE_0__.toChildArray,
+		__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:
+      _render__WEBPACK_IMPORTED_MODULE_10__.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+	};
+})();
+
+var __webpack_exports__Children = __webpack_exports__.Children;
+var __webpack_exports__Component = __webpack_exports__.Component;
+var __webpack_exports__Fragment = __webpack_exports__.Fragment;
+var __webpack_exports__PureComponent = __webpack_exports__.PureComponent;
+var __webpack_exports__StrictMode = __webpack_exports__.StrictMode;
+var __webpack_exports__Suspense = __webpack_exports__.Suspense;
+var __webpack_exports__SuspenseList = __webpack_exports__.SuspenseList;
+var __webpack_exports___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =
+  __webpack_exports__.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+var __webpack_exports__cloneElement = __webpack_exports__.cloneElement;
+var __webpack_exports__createContext = __webpack_exports__.createContext;
+var __webpack_exports__createElement = __webpack_exports__.createElement;
+var __webpack_exports__createFactory = __webpack_exports__.createFactory;
+var __webpack_exports__createPortal = __webpack_exports__.createPortal;
+var __webpack_exports__createRef = __webpack_exports__.createRef;
+var __webpack_exports__default = __webpack_exports__['default'];
+var __webpack_exports__findDOMNode = __webpack_exports__.findDOMNode;
+var __webpack_exports__flushSync = __webpack_exports__.flushSync;
+var __webpack_exports__forwardRef = __webpack_exports__.forwardRef;
+var __webpack_exports__hydrate = __webpack_exports__.hydrate;
+var __webpack_exports__isValidElement = __webpack_exports__.isValidElement;
+var __webpack_exports__lazy = __webpack_exports__.lazy;
+var __webpack_exports__memo = __webpack_exports__.memo;
+var __webpack_exports__options = __webpack_exports__.options;
+var __webpack_exports__render = __webpack_exports__.render;
+var __webpack_exports__startTransition = __webpack_exports__.startTransition;
+var __webpack_exports__toChildArray = __webpack_exports__.toChildArray;
+var __webpack_exports__unmountComponentAtNode =
+  __webpack_exports__.unmountComponentAtNode;
+var __webpack_exports__unstable_batchedUpdates =
+  __webpack_exports__.unstable_batchedUpdates;
+var __webpack_exports__useCallback = __webpack_exports__.useCallback;
+var __webpack_exports__useContext = __webpack_exports__.useContext;
+var __webpack_exports__useDebugValue = __webpack_exports__.useDebugValue;
+var __webpack_exports__useDeferredValue = __webpack_exports__.useDeferredValue;
+var __webpack_exports__useEffect = __webpack_exports__.useEffect;
+var __webpack_exports__useErrorBoundary = __webpack_exports__.useErrorBoundary;
+var __webpack_exports__useId = __webpack_exports__.useId;
+var __webpack_exports__useImperativeHandle =
+  __webpack_exports__.useImperativeHandle;
+var __webpack_exports__useInsertionEffect =
+  __webpack_exports__.useInsertionEffect;
+var __webpack_exports__useLayoutEffect = __webpack_exports__.useLayoutEffect;
+var __webpack_exports__useMemo = __webpack_exports__.useMemo;
+var __webpack_exports__useReducer = __webpack_exports__.useReducer;
+var __webpack_exports__useRef = __webpack_exports__.useRef;
+var __webpack_exports__useState = __webpack_exports__.useState;
+var __webpack_exports__useSyncExternalStore =
+  __webpack_exports__.useSyncExternalStore;
+var __webpack_exports__useTransition = __webpack_exports__.useTransition;
+var __webpack_exports__version = __webpack_exports__.version;
+export {
+	__webpack_exports__Children as Children,
+	__webpack_exports__Component as Component,
+	__webpack_exports__Fragment as Fragment,
+	__webpack_exports__PureComponent as PureComponent,
+	__webpack_exports__StrictMode as StrictMode,
+	__webpack_exports__Suspense as Suspense,
+	__webpack_exports__SuspenseList as SuspenseList,
+	__webpack_exports___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED as __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+	__webpack_exports__cloneElement as cloneElement,
+	__webpack_exports__createContext as createContext,
+	__webpack_exports__createElement as createElement,
+	__webpack_exports__createFactory as createFactory,
+	__webpack_exports__createPortal as createPortal,
+	__webpack_exports__createRef as createRef,
+	__webpack_exports__default as default,
+	__webpack_exports__findDOMNode as findDOMNode,
+	__webpack_exports__flushSync as flushSync,
+	__webpack_exports__forwardRef as forwardRef,
+	__webpack_exports__hydrate as hydrate,
+	__webpack_exports__isValidElement as isValidElement,
+	__webpack_exports__lazy as lazy,
+	__webpack_exports__memo as memo,
+	__webpack_exports__options as options,
+	__webpack_exports__render as render,
+	__webpack_exports__startTransition as startTransition,
+	__webpack_exports__toChildArray as toChildArray,
+	__webpack_exports__unmountComponentAtNode as unmountComponentAtNode,
+	__webpack_exports__unstable_batchedUpdates as unstable_batchedUpdates,
+	__webpack_exports__useCallback as useCallback,
+	__webpack_exports__useContext as useContext,
+	__webpack_exports__useDebugValue as useDebugValue,
+	__webpack_exports__useDeferredValue as useDeferredValue,
+	__webpack_exports__useEffect as useEffect,
+	__webpack_exports__useErrorBoundary as useErrorBoundary,
+	__webpack_exports__useId as useId,
+	__webpack_exports__useImperativeHandle as useImperativeHandle,
+	__webpack_exports__useInsertionEffect as useInsertionEffect,
+	__webpack_exports__useLayoutEffect as useLayoutEffect,
+	__webpack_exports__useMemo as useMemo,
+	__webpack_exports__useReducer as useReducer,
+	__webpack_exports__useRef as useRef,
+	__webpack_exports__useState as useState,
+	__webpack_exports__useSyncExternalStore as useSyncExternalStore,
+	__webpack_exports__useTransition as useTransition,
+	__webpack_exports__version as version,
+};
+
+//# sourceMappingURL=preact.js.map