{"version":3,"file":"320Chunk.js?v=23.134.0+20261102.30.bbbf8652390b5ce306040b1cece1df0dd99fac01&h=4203cdd535c088127d83","mappings":"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","sources":["webpack://site-client-side/../src/check-props.js","webpack://site-client-side/../src/component-stack.js","webpack://site-client-side/../src/debug.js","webpack://site-client-side/../src/constants.js","webpack://site-client-side/../src/util.js","webpack://site-client-side/../src/devtools.js","webpack://site-client-side/../src/options.js","webpack://site-client-side/../src/create-element.js","webpack://site-client-side/../src/component.js","webpack://site-client-side/../src/diff/children.js","webpack://site-client-side/../src/diff/props.js","webpack://site-client-side/../src/diff/index.js","webpack://site-client-side/../src/render.js","webpack://site-client-side/../src/diff/catch-error.js"],"sourcesContent":["const ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nlet loggedTypeFailures = {};\n\n/**\n * Reset the history of which prop type warnings have been logged.\n */\nexport function resetPropWarnings() {\n\tloggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * Adapted from https://github.com/facebook/prop-types/blob/master/checkPropTypes.js\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n */\nexport function checkPropTypes(\n\ttypeSpecs,\n\tvalues,\n\tlocation,\n\tcomponentName,\n\tgetStack\n) {\n\tObject.keys(typeSpecs).forEach(typeSpecName => {\n\t\tlet error;\n\t\ttry {\n\t\t\terror = typeSpecs[typeSpecName](\n\t\t\t\tvalues,\n\t\t\t\ttypeSpecName,\n\t\t\t\tcomponentName,\n\t\t\t\tlocation,\n\t\t\t\tnull,\n\t\t\t\tReactPropTypesSecret\n\t\t\t);\n\t\t} catch (e) {\n\t\t\terror = e;\n\t\t}\n\t\tif (error && !(error.message in loggedTypeFailures)) {\n\t\t\tloggedTypeFailures[error.message] = true;\n\t\t\tconsole.error(\n\t\t\t\t`Failed ${location} type: ${error.message}${\n\t\t\t\t\t(getStack && `\\n${getStack()}`) || ''\n\t\t\t\t}`\n\t\t\t);\n\t\t}\n\t});\n}\n","import { options, Fragment } from 'preact';\n\n/**\n * Get human readable name of the component/dom node\n * @param {import('./internal').VNode} vnode\n * @param {import('./internal').VNode} vnode\n * @returns {string}\n */\nexport function getDisplayName(vnode) {\n\tif (vnode.type === Fragment) {\n\t\treturn 'Fragment';\n\t} else if (typeof vnode.type == 'function') {\n\t\treturn vnode.type.displayName || vnode.type.name;\n\t} else if (typeof vnode.type == 'string') {\n\t\treturn vnode.type;\n\t}\n\n\treturn '#text';\n}\n\n/**\n * Used to keep track of the currently rendered `vnode` and print it\n * in debug messages.\n */\nlet renderStack = [];\n\n/**\n * Keep track of the current owners. An owner describes a component\n * which was responsible to render a specific `vnode`. This exclude\n * children that are passed via `props.children`, because they belong\n * to the parent owner.\n *\n * ```jsx\n * const Foo = props => <div>{props.children}</div> // div's owner is Foo\n * const Bar = props => {\n *   return (\n *     <Foo><span /></Foo> // Foo's owner is Bar, span's owner is Bar\n *   )\n * }\n * ```\n *\n * Note: A `vnode` may be hoisted to the root scope due to compiler\n * optimiztions. In these cases the `_owner` will be different.\n */\nlet ownerStack = [];\n\n/**\n * Get the currently rendered `vnode`\n * @returns {import('./internal').VNode | null}\n */\nexport function getCurrentVNode() {\n\treturn renderStack.length > 0 ? renderStack[renderStack.length - 1] : null;\n}\n\n/**\n * If the user doesn't have `@babel/plugin-transform-react-jsx-source`\n * somewhere in his tool chain we can't print the filename and source\n * location of a component. In that case we just omit that, but we'll\n * print a helpful message to the console, notifying the user of it.\n */\nlet hasBabelPlugin = false;\n\n/**\n * Check if a `vnode` is a possible owner.\n * @param {import('./internal').VNode} vnode\n */\nfunction isPossibleOwner(vnode) {\n\treturn typeof vnode.type == 'function' && vnode.type != Fragment;\n}\n\n/**\n * Return the component stack that was captured up to this point.\n * @param {import('./internal').VNode} vnode\n * @returns {string}\n */\nexport function getOwnerStack(vnode) {\n\tconst stack = [vnode];\n\tlet next = vnode;\n\twhile (next._owner != null) {\n\t\tstack.push(next._owner);\n\t\tnext = next._owner;\n\t}\n\n\treturn stack.reduce((acc, owner) => {\n\t\tacc += `  in ${getDisplayName(owner)}`;\n\n\t\tconst source = owner.__source;\n\t\tif (source) {\n\t\t\tacc += ` (at ${source.fileName}:${source.lineNumber})`;\n\t\t} else if (!hasBabelPlugin) {\n\t\t\thasBabelPlugin = true;\n\t\t\tconsole.warn(\n\t\t\t\t'Add @babel/plugin-transform-react-jsx-source to get a more detailed component stack. Note that you should not add it to production builds of your App for bundle size reasons.'\n\t\t\t);\n\t\t}\n\n\t\treturn (acc += '\\n');\n\t}, '');\n}\n\n/**\n * Setup code to capture the component trace while rendering. Note that\n * we cannot simply traverse `vnode._parent` upwards, because we have some\n * debug messages for `this.setState` where the `vnode` is `undefined`.\n */\nexport function setupComponentStack() {\n\tlet oldDiff = options._diff;\n\tlet oldDiffed = options.diffed;\n\tlet oldRoot = options._root;\n\tlet oldVNode = options.vnode;\n\tlet oldRender = options._render;\n\n\toptions.diffed = vnode => {\n\t\tif (isPossibleOwner(vnode)) {\n\t\t\townerStack.pop();\n\t\t}\n\t\trenderStack.pop();\n\t\tif (oldDiffed) oldDiffed(vnode);\n\t};\n\n\toptions._diff = vnode => {\n\t\tif (isPossibleOwner(vnode)) {\n\t\t\trenderStack.push(vnode);\n\t\t}\n\t\tif (oldDiff) oldDiff(vnode);\n\t};\n\n\toptions._root = (vnode, parent) => {\n\t\townerStack = [];\n\t\tif (oldRoot) oldRoot(vnode, parent);\n\t};\n\n\toptions.vnode = vnode => {\n\t\tvnode._owner =\n\t\t\townerStack.length > 0 ? ownerStack[ownerStack.length - 1] : null;\n\t\tif (oldVNode) oldVNode(vnode);\n\t};\n\n\toptions._render = vnode => {\n\t\tif (isPossibleOwner(vnode)) {\n\t\t\townerStack.push(vnode);\n\t\t}\n\n\t\tif (oldRender) oldRender(vnode);\n\t};\n}\n","import { checkPropTypes } from './check-props';\nimport { options, Component } from 'preact';\nimport {\n\tELEMENT_NODE,\n\tDOCUMENT_NODE,\n\tDOCUMENT_FRAGMENT_NODE\n} from './constants';\nimport {\n\tgetOwnerStack,\n\tsetupComponentStack,\n\tgetCurrentVNode,\n\tgetDisplayName\n} from './component-stack';\nimport { assign, isNaN } from './util';\n\nconst isWeakMapSupported = typeof WeakMap == 'function';\n\n/**\n * @param {import('./internal').VNode} parent\n * @returns {string}\n */\nfunction getClosestDomNodeParentName(parent) {\n\tif (!parent) return '';\n\tif (typeof parent.type == 'function') {\n\t\tif (parent._parent === null) {\n\t\t\tif (parent._dom !== null && parent._dom.parentNode !== null) {\n\t\t\t\treturn parent._dom.parentNode.localName;\n\t\t\t}\n\t\t\treturn '';\n\t\t}\n\t\treturn getClosestDomNodeParentName(parent._parent);\n\t}\n\treturn /** @type {string} */ (parent.type);\n}\n\nexport function initDebug() {\n\tsetupComponentStack();\n\n\tlet hooksAllowed = false;\n\n\t/* eslint-disable no-console */\n\tlet oldBeforeDiff = options._diff;\n\tlet oldDiffed = options.diffed;\n\tlet oldVnode = options.vnode;\n\tlet oldRender = options._render;\n\tlet oldCatchError = options._catchError;\n\tlet oldRoot = options._root;\n\tlet oldHook = options._hook;\n\tlet oldCommit = options._commit;\n\tconst warnedComponents = !isWeakMapSupported\n\t\t? null\n\t\t: {\n\t\t\t\tuseEffect: new WeakMap(),\n\t\t\t\tuseLayoutEffect: new WeakMap(),\n\t\t\t\tlazyPropTypes: new WeakMap()\n\t\t  };\n\tconst deprecations = [];\n\t/** @type {import(\"./internal.d.ts\").VNode[]} */\n\tlet checkVNodeDom = [];\n\n\toptions._catchError = (error, vnode, oldVNode, errorInfo) => {\n\t\tlet component = vnode && vnode._component;\n\t\tif (component && typeof error.then == 'function') {\n\t\t\tconst promise = error;\n\t\t\terror = new Error(\n\t\t\t\t`Missing Suspense. The throwing component was: ${getDisplayName(vnode)}`\n\t\t\t);\n\n\t\t\tlet parent = vnode;\n\t\t\tfor (; parent; parent = parent._parent) {\n\t\t\t\tif (parent._component && parent._component._childDidSuspend) {\n\t\t\t\t\terror = promise;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// We haven't recovered and we know at this point that there is no\n\t\t\t// Suspense component higher up in the tree\n\t\t\tif (error instanceof Error) {\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t}\n\n\t\ttry {\n\t\t\terrorInfo = errorInfo || {};\n\t\t\terrorInfo.componentStack = getOwnerStack(vnode);\n\t\t\toldCatchError(error, vnode, oldVNode, errorInfo);\n\n\t\t\t// when an error was handled by an ErrorBoundary we will nonetheless emit an error\n\t\t\t// event on the window object. This is to make up for react compatibility in dev mode\n\t\t\t// and thus make the Next.js dev overlay work.\n\t\t\tif (typeof error.then != 'function') {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tthrow error;\n\t\t\t\t});\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tthrow e;\n\t\t}\n\t};\n\n\toptions._root = (vnode, parentNode) => {\n\t\tif (!parentNode) {\n\t\t\tthrow new Error(\n\t\t\t\t'Undefined parent passed to render(), this is the second argument.\\n' +\n\t\t\t\t\t'Check if the element is available in the DOM/has the correct id.'\n\t\t\t);\n\t\t}\n\n\t\tlet isValid;\n\t\tswitch (parentNode.nodeType) {\n\t\t\tcase ELEMENT_NODE:\n\t\t\tcase DOCUMENT_FRAGMENT_NODE:\n\t\t\tcase DOCUMENT_NODE:\n\t\t\t\tisValid = true;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tisValid = false;\n\t\t}\n\n\t\tif (!isValid) {\n\t\t\tlet componentName = getDisplayName(vnode);\n\t\t\tthrow new Error(\n\t\t\t\t`Expected a valid HTML node as a second argument to render.\tReceived ${parentNode} instead: render(<${componentName} />, ${parentNode});`\n\t\t\t);\n\t\t}\n\n\t\tif (oldRoot) oldRoot(vnode, parentNode);\n\t};\n\n\toptions._diff = vnode => {\n\t\tlet { type } = vnode;\n\t\tif (\n\t\t\ttypeof type === 'string' &&\n\t\t\t(type === 'thead' ||\n\t\t\t\ttype === 'tfoot' ||\n\t\t\t\ttype === 'tbody' ||\n\t\t\t\ttype === 'tr' ||\n\t\t\t\ttype === 'td' ||\n\t\t\t\ttype === 'th')\n\t\t) {\n\t\t\tcheckVNodeDom.push(vnode);\n\t\t}\n\n\t\thooksAllowed = true;\n\n\t\tif (type === undefined) {\n\t\t\tthrow new Error(\n\t\t\t\t'Undefined component passed to createElement()\\n\\n' +\n\t\t\t\t\t'You likely forgot to export your component or might have mixed up default and named imports' +\n\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t);\n\t\t} else if (type != null && typeof type == 'object') {\n\t\t\tif (type._children !== undefined && type._dom !== undefined) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Invalid type passed to createElement(): ${type}\\n\\n` +\n\t\t\t\t\t\t'Did you accidentally pass a JSX literal as JSX twice?\\n\\n' +\n\t\t\t\t\t\t`  let My${getDisplayName(vnode)} = ${serializeVNode(type)};\\n` +\n\t\t\t\t\t\t`  let vnode = <My${getDisplayName(vnode)} />;\\n\\n` +\n\t\t\t\t\t\t'This usually happens when you export a JSX literal and not the component.' +\n\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tthrow new Error(\n\t\t\t\t'Invalid type passed to createElement(): ' +\n\t\t\t\t\t(Array.isArray(type) ? 'array' : type)\n\t\t\t);\n\t\t}\n\n\t\tif (\n\t\t\tvnode.ref !== undefined &&\n\t\t\ttypeof vnode.ref != 'function' &&\n\t\t\ttypeof vnode.ref != 'object' &&\n\t\t\t!('$$typeof' in vnode) // allow string refs when preact-compat is installed\n\t\t) {\n\t\t\tthrow new Error(\n\t\t\t\t`Component's \"ref\" property should be a function, or an object created ` +\n\t\t\t\t\t`by createRef(), but got [${typeof vnode.ref}] instead\\n` +\n\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t);\n\t\t}\n\n\t\tif (typeof vnode.type == 'string') {\n\t\t\tfor (const key in vnode.props) {\n\t\t\t\tif (\n\t\t\t\t\tkey[0] === 'o' &&\n\t\t\t\t\tkey[1] === 'n' &&\n\t\t\t\t\ttypeof vnode.props[key] != 'function' &&\n\t\t\t\t\tvnode.props[key] != null\n\t\t\t\t) {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`Component's \"${key}\" property should be a function, ` +\n\t\t\t\t\t\t\t`but got [${typeof vnode.props[key]}] instead\\n` +\n\t\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Check prop-types if available\n\t\tif (typeof vnode.type == 'function' && vnode.type.propTypes) {\n\t\t\tif (\n\t\t\t\tvnode.type.displayName === 'Lazy' &&\n\t\t\t\twarnedComponents &&\n\t\t\t\t!warnedComponents.lazyPropTypes.has(vnode.type)\n\t\t\t) {\n\t\t\t\tconst m =\n\t\t\t\t\t'PropTypes are not supported on lazy(). Use propTypes on the wrapped component itself. ';\n\t\t\t\ttry {\n\t\t\t\t\tconst lazyVNode = vnode.type();\n\t\t\t\t\twarnedComponents.lazyPropTypes.set(vnode.type, true);\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\tm + `Component wrapped in lazy() is ${getDisplayName(lazyVNode)}`\n\t\t\t\t\t);\n\t\t\t\t} catch (promise) {\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\tm + \"We will log the wrapped component's name once it is loaded.\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlet values = vnode.props;\n\t\t\tif (vnode.type._forwarded) {\n\t\t\t\tvalues = assign({}, values);\n\t\t\t\tdelete values.ref;\n\t\t\t}\n\n\t\t\tcheckPropTypes(\n\t\t\t\tvnode.type.propTypes,\n\t\t\t\tvalues,\n\t\t\t\t'prop',\n\t\t\t\tgetDisplayName(vnode),\n\t\t\t\t() => getOwnerStack(vnode)\n\t\t\t);\n\t\t}\n\n\t\tif (oldBeforeDiff) oldBeforeDiff(vnode);\n\t};\n\n\toptions._render = vnode => {\n\t\tif (oldRender) {\n\t\t\toldRender(vnode);\n\t\t}\n\t\thooksAllowed = true;\n\t};\n\n\toptions._hook = (comp, index, type) => {\n\t\tif (!comp || !hooksAllowed) {\n\t\t\tthrow new Error('Hook can only be invoked from render methods.');\n\t\t}\n\n\t\tif (oldHook) oldHook(comp, index, type);\n\t};\n\n\t// Ideally we'd want to print a warning once per component, but we\n\t// don't have access to the vnode that triggered it here. As a\n\t// compromise and to avoid flooding the console with warnings we\n\t// print each deprecation warning only once.\n\tconst warn = (property, message) => ({\n\t\tget() {\n\t\t\tconst key = 'get' + property + message;\n\t\t\tif (deprecations && deprecations.indexOf(key) < 0) {\n\t\t\t\tdeprecations.push(key);\n\t\t\t\tconsole.warn(`getting vnode.${property} is deprecated, ${message}`);\n\t\t\t}\n\t\t},\n\t\tset() {\n\t\t\tconst key = 'set' + property + message;\n\t\t\tif (deprecations && deprecations.indexOf(key) < 0) {\n\t\t\t\tdeprecations.push(key);\n\t\t\t\tconsole.warn(`setting vnode.${property} is not allowed, ${message}`);\n\t\t\t}\n\t\t}\n\t});\n\n\tconst deprecatedAttributes = {\n\t\tnodeName: warn('nodeName', 'use vnode.type'),\n\t\tattributes: warn('attributes', 'use vnode.props'),\n\t\tchildren: warn('children', 'use vnode.props.children')\n\t};\n\n\tconst deprecatedProto = Object.create({}, deprecatedAttributes);\n\n\toptions.vnode = vnode => {\n\t\tconst props = vnode.props;\n\t\tif (\n\t\t\tvnode.type !== null &&\n\t\t\tprops != null &&\n\t\t\t('__source' in props || '__self' in props)\n\t\t) {\n\t\t\tconst newProps = (vnode.props = {});\n\t\t\tfor (let i in props) {\n\t\t\t\tconst v = props[i];\n\t\t\t\tif (i === '__source') vnode.__source = v;\n\t\t\t\telse if (i === '__self') vnode.__self = v;\n\t\t\t\telse newProps[i] = v;\n\t\t\t}\n\t\t}\n\n\t\t// eslint-disable-next-line\n\t\tvnode.__proto__ = deprecatedProto;\n\t\tif (oldVnode) oldVnode(vnode);\n\t};\n\n\toptions.diffed = vnode => {\n\t\t// Check if the user passed plain objects as children. Note that we cannot\n\t\t// move this check into `options.vnode` because components can receive\n\t\t// children in any shape they want (e.g.\n\t\t// `<MyJSONFormatter>{{ foo: 123, bar: \"abc\" }}</MyJSONFormatter>`).\n\t\t// Putting this check in `options.diffed` ensures that\n\t\t// `vnode._children` is set and that we only validate the children\n\t\t// that were actually rendered.\n\t\tif (vnode._children) {\n\t\t\tvnode._children.forEach(child => {\n\t\t\t\tif (typeof child === 'object' && child && child.type === undefined) {\n\t\t\t\t\tconst keys = Object.keys(child).join(',');\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`Objects are not valid as a child. Encountered an object with the keys {${keys}}.` +\n\t\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\thooksAllowed = false;\n\n\t\tif (oldDiffed) oldDiffed(vnode);\n\n\t\tif (vnode._children != null) {\n\t\t\tconst keys = [];\n\t\t\tfor (let i = 0; i < vnode._children.length; i++) {\n\t\t\t\tconst child = vnode._children[i];\n\t\t\t\tif (!child || child.key == null) continue;\n\n\t\t\t\tconst key = child.key;\n\t\t\t\tif (keys.indexOf(key) !== -1) {\n\t\t\t\t\tconsole.error(\n\t\t\t\t\t\t'Following component has two or more children with the ' +\n\t\t\t\t\t\t\t`same key attribute: \"${key}\". This may cause glitches and misbehavior ` +\n\t\t\t\t\t\t\t'in rendering process. Component: \\n\\n' +\n\t\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t\t);\n\n\t\t\t\t\t// Break early to not spam the console\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tkeys.push(key);\n\t\t\t}\n\t\t}\n\n\t\tif (vnode._component != null && vnode._component.__hooks != null) {\n\t\t\t// Validate that none of the hooks in this component contain arguments that are NaN.\n\t\t\t// This is a common mistake that can be hard to debug, so we want to catch it early.\n\t\t\tconst hooks = vnode._component.__hooks._list;\n\t\t\tif (hooks) {\n\t\t\t\tfor (let i = 0; i < hooks.length; i += 1) {\n\t\t\t\t\tconst hook = hooks[i];\n\t\t\t\t\tif (hook._args) {\n\t\t\t\t\t\tfor (const arg of hook._args) {\n\t\t\t\t\t\t\tif (isNaN(arg)) {\n\t\t\t\t\t\t\t\tconst componentName = getDisplayName(vnode);\n\t\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t\t`Invalid argument passed to hook. Hooks should not be called with NaN in the dependency array. Hook index ${i} in component ${componentName} was called with NaN.`\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\toptions._commit = (root, queue) => {\n\t\tfor (let i = 0; i < checkVNodeDom.length; i++) {\n\t\t\tconst vnode = checkVNodeDom[i];\n\n\t\t\t// Check if HTML nesting is valid. We need to do it in `options.diffed`\n\t\t\t// so that we can optionally traverse outside the vdom root in case\n\t\t\t// it's an island embedded in an existing (and valid) HTML tree.\n\t\t\tconst { type, _parent: parent } = vnode;\n\n\t\t\tlet domParentName = getClosestDomNodeParentName(parent);\n\n\t\t\tif (\n\t\t\t\t(type === 'thead' || type === 'tfoot' || type === 'tbody') &&\n\t\t\t\tdomParentName !== 'table'\n\t\t\t) {\n\t\t\t\tconsole.error(\n\t\t\t\t\t'Improper nesting of table. Your <thead/tbody/tfoot> should have a <table> parent.' +\n\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t);\n\t\t\t} else if (\n\t\t\t\ttype === 'tr' &&\n\t\t\t\tdomParentName !== 'thead' &&\n\t\t\t\tdomParentName !== 'tfoot' &&\n\t\t\t\tdomParentName !== 'tbody' &&\n\t\t\t\tdomParentName !== 'table'\n\t\t\t) {\n\t\t\t\tconsole.error(\n\t\t\t\t\t'Improper nesting of table. Your <tr> should have a <thead/tbody/tfoot/table> parent.' +\n\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t);\n\t\t\t} else if (type === 'td' && domParentName !== 'tr') {\n\t\t\t\tconsole.error(\n\t\t\t\t\t'Improper nesting of table. Your <td> should have a <tr> parent.' +\n\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t);\n\t\t\t} else if (type === 'th' && domParentName !== 'tr') {\n\t\t\t\tconsole.error(\n\t\t\t\t\t'Improper nesting of table. Your <th> should have a <tr>.' +\n\t\t\t\t\t\tserializeVNode(vnode) +\n\t\t\t\t\t\t`\\n\\n${getOwnerStack(vnode)}`\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\tcheckVNodeDom = [];\n\n\t\tif (oldCommit) oldCommit(root, queue);\n\t};\n}\n\nconst setState = Component.prototype.setState;\nComponent.prototype.setState = function (update, callback) {\n\tif (this._vnode == null) {\n\t\t// `this._vnode` will be `null` during componentWillMount. But it\n\t\t// is perfectly valid to call `setState` during cWM. So we\n\t\t// need an additional check to verify that we are dealing with a\n\t\t// call inside constructor.\n\t\tif (this.state == null) {\n\t\t\tconsole.warn(\n\t\t\t\t`Calling \"this.setState\" inside the constructor of a component is a ` +\n\t\t\t\t\t`no-op and might be a bug in your application. Instead, set ` +\n\t\t\t\t\t`\"this.state = {}\" directly.\\n\\n${getOwnerStack(getCurrentVNode())}`\n\t\t\t);\n\t\t}\n\t}\n\n\treturn setState.call(this, update, callback);\n};\n\nconst forceUpdate = Component.prototype.forceUpdate;\nComponent.prototype.forceUpdate = function (callback) {\n\tif (this._vnode == null) {\n\t\tconsole.warn(\n\t\t\t`Calling \"this.forceUpdate\" inside the constructor of a component is a ` +\n\t\t\t\t`no-op and might be a bug in your application.\\n\\n${getOwnerStack(\n\t\t\t\t\tgetCurrentVNode()\n\t\t\t\t)}`\n\t\t);\n\t} else if (this._parentDom == null) {\n\t\tconsole.warn(\n\t\t\t`Can't call \"this.forceUpdate\" on an unmounted component. This is a no-op, ` +\n\t\t\t\t`but it indicates a memory leak in your application. To fix, cancel all ` +\n\t\t\t\t`subscriptions and asynchronous tasks in the componentWillUnmount method.` +\n\t\t\t\t`\\n\\n${getOwnerStack(this._vnode)}`\n\t\t);\n\t}\n\treturn forceUpdate.call(this, callback);\n};\n\n/**\n * Serialize a vnode tree to a string\n * @param {import('./internal').VNode} vnode\n * @returns {string}\n */\nexport function serializeVNode(vnode) {\n\tlet { props } = vnode;\n\tlet name = getDisplayName(vnode);\n\n\tlet attrs = '';\n\tfor (let prop in props) {\n\t\tif (props.hasOwnProperty(prop) && prop !== 'children') {\n\t\t\tlet value = props[prop];\n\n\t\t\t// If it is an object but doesn't have toString(), use Object.toString\n\t\t\tif (typeof value == 'function') {\n\t\t\t\tvalue = `function ${value.displayName || value.name}() {}`;\n\t\t\t}\n\n\t\t\tvalue =\n\t\t\t\tObject(value) === value && !value.toString\n\t\t\t\t\t? Object.prototype.toString.call(value)\n\t\t\t\t\t: value + '';\n\n\t\t\tattrs += ` ${prop}=${JSON.stringify(value)}`;\n\t\t}\n\t}\n\n\tlet children = props.children;\n\treturn `<${name}${attrs}${\n\t\tchildren && children.length ? '>..</' + name + '>' : ' />'\n\t}`;\n}\n","export const ELEMENT_NODE = 1;\nexport const DOCUMENT_NODE = 9;\nexport const DOCUMENT_FRAGMENT_NODE = 11;\n","/**\n * Assign properties from `props` to `obj`\n * @template O, P The obj and props types\n * @param {O} obj The object to copy properties to\n * @param {P} props The object to copy properties from\n * @returns {O & P}\n */\nexport function assign(obj, props) {\n\tfor (let i in props) obj[i] = props[i];\n\treturn /** @type {O & P} */ (obj);\n}\n\nexport function isNaN(value) {\n\treturn value !== value;\n}\n","import { options, Fragment, Component } from 'preact';\n\nexport function initDevTools() {\n\tif (typeof window != 'undefined' && window.__PREACT_DEVTOOLS__) {\n\t\twindow.__PREACT_DEVTOOLS__.attachPreact('10.17.0', options, {\n\t\t\tFragment,\n\t\t\tComponent\n\t\t});\n\t}\n}\n","import { _catchError } from './diff/catch-error';\n\n/**\n * The `option` object can potentially contain callback functions\n * that are called during various stages of our renderer. This is the\n * foundation on which all our addons like `preact/debug`, `preact/compat`,\n * and `preact/hooks` are based on. See the `Options` type in `internal.d.ts`\n * for a full list of available option hooks (most editors/IDEs allow you to\n * ctrl+click or cmd+click on mac the type definition below).\n * @type {import('./internal').Options}\n */\nconst options = {\n\t_catchError\n};\n\nexport default options;\n","import { slice } from './util';\nimport options from './options';\n\nlet vnodeId = 0;\n\n/**\n * Create an virtual node (used for JSX)\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component\n * constructor for this virtual node\n * @param {object | null | undefined} [props] The properties of the virtual node\n * @param {Array<import('.').ComponentChildren>} [children] The children of the virtual node\n * @returns {import('./internal').VNode}\n */\nexport function createElement(type, props, children) {\n\tlet normalizedProps = {},\n\t\tkey,\n\t\tref,\n\t\ti;\n\tfor (i in props) {\n\t\tif (i == 'key') key = props[i];\n\t\telse if (i == 'ref') ref = props[i];\n\t\telse normalizedProps[i] = props[i];\n\t}\n\n\tif (arguments.length > 2) {\n\t\tnormalizedProps.children =\n\t\t\targuments.length > 3 ? slice.call(arguments, 2) : children;\n\t}\n\n\t// If a Component VNode, check for and apply defaultProps\n\t// Note: type may be undefined in development, must never error here.\n\tif (typeof type == 'function' && type.defaultProps != null) {\n\t\tfor (i in type.defaultProps) {\n\t\t\tif (normalizedProps[i] === undefined) {\n\t\t\t\tnormalizedProps[i] = type.defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn createVNode(type, normalizedProps, key, ref, null);\n}\n\n/**\n * Create a VNode (used internally by Preact)\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component\n * Constructor for this virtual node\n * @param {object | string | number | null} props The properties of this virtual node.\n * If this virtual node represents a text node, this is the text of the node (string or number).\n * @param {string | number | null} key The key for this virtual node, used when\n * diffing it against its children\n * @param {import('./internal').VNode[\"ref\"]} ref The ref property that will\n * receive a reference to its created child\n * @returns {import('./internal').VNode}\n */\nexport function createVNode(type, props, key, ref, original) {\n\t// V8 seems to be better at detecting type shapes if the object is allocated from the same call site\n\t// Do not inline into createElement and coerceToVNode!\n\tconst vnode = {\n\t\ttype,\n\t\tprops,\n\t\tkey,\n\t\tref,\n\t\t_children: null,\n\t\t_parent: null,\n\t\t_depth: 0,\n\t\t_dom: null,\n\t\t// _nextDom must be initialized to undefined b/c it will eventually\n\t\t// be set to dom.nextSibling which can return `null` and it is important\n\t\t// to be able to distinguish between an uninitialized _nextDom and\n\t\t// a _nextDom that has been set to `null`\n\t\t_nextDom: undefined,\n\t\t_component: null,\n\t\t_hydrating: null,\n\t\tconstructor: undefined,\n\t\t_original: original == null ? ++vnodeId : original\n\t};\n\n\t// Only invoke the vnode hook if this was *not* a direct copy:\n\tif (original == null && options.vnode != null) options.vnode(vnode);\n\n\treturn vnode;\n}\n\nexport function createRef() {\n\treturn { current: null };\n}\n\nexport function Fragment(props) {\n\treturn props.children;\n}\n\n/**\n * Check if a the argument is a valid Preact VNode.\n * @param {*} vnode\n * @returns {vnode is import('./internal').VNode}\n */\nexport const isValidElement = vnode =>\n\tvnode != null && vnode.constructor === undefined;\n","import { assign } from './util';\nimport { diff, commitRoot } from './diff/index';\nimport options from './options';\nimport { Fragment } from './create-element';\n\n/**\n * Base Component class. Provides `setState()` and `forceUpdate()`, which\n * trigger rendering\n * @param {object} props The initial component props\n * @param {object} context The initial context from parent components'\n * getChildContext\n */\nexport function Component(props, context) {\n\tthis.props = props;\n\tthis.context = context;\n}\n\n/**\n * Update component state and schedule a re-render.\n * @this {import('./internal').Component}\n * @param {object | ((s: object, p: object) => object)} update A hash of state\n * properties to update with new values or a function that given the current\n * state and props returns a new partial state\n * @param {() => void} [callback] A function to be called once component state is\n * updated\n */\nComponent.prototype.setState = function (update, callback) {\n\t// only clone state when copying to nextState the first time.\n\tlet s;\n\tif (this._nextState != null && this._nextState !== this.state) {\n\t\ts = this._nextState;\n\t} else {\n\t\ts = this._nextState = assign({}, this.state);\n\t}\n\n\tif (typeof update == 'function') {\n\t\t// Some libraries like `immer` mark the current state as readonly,\n\t\t// preventing us from mutating it, so we need to clone it. See #2716\n\t\tupdate = update(assign({}, s), this.props);\n\t}\n\n\tif (update) {\n\t\tassign(s, update);\n\t}\n\n\t// Skip update if updater function returned null\n\tif (update == null) return;\n\n\tif (this._vnode) {\n\t\tif (callback) {\n\t\t\tthis._stateCallbacks.push(callback);\n\t\t}\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Immediately perform a synchronous re-render of the component\n * @this {import('./internal').Component}\n * @param {() => void} [callback] A function to be called after component is\n * re-rendered\n */\nComponent.prototype.forceUpdate = function (callback) {\n\tif (this._vnode) {\n\t\t// Set render mode so that we can differentiate where the render request\n\t\t// is coming from. We need this because forceUpdate should never call\n\t\t// shouldComponentUpdate\n\t\tthis._force = true;\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n * @param {object} props Props (eg: JSX attributes) received from parent\n * element/component\n * @param {object} state The component's current state\n * @param {object} context Context object, as returned by the nearest\n * ancestor's `getChildContext()`\n * @returns {import('./index').ComponentChildren | void}\n */\nComponent.prototype.render = Fragment;\n\n/**\n * @param {import('./internal').VNode} vnode\n * @param {number | null} [childIndex]\n */\nexport function getDomSibling(vnode, childIndex) {\n\tif (childIndex == null) {\n\t\t// Use childIndex==null as a signal to resume the search from the vnode's sibling\n\t\treturn vnode._parent\n\t\t\t? getDomSibling(vnode._parent, vnode._parent._children.indexOf(vnode) + 1)\n\t\t\t: null;\n\t}\n\n\tlet sibling;\n\tfor (; childIndex < vnode._children.length; childIndex++) {\n\t\tsibling = vnode._children[childIndex];\n\n\t\tif (sibling != null && sibling._dom != null) {\n\t\t\t// Since updateParentDomPointers keeps _dom pointer correct,\n\t\t\t// we can rely on _dom to tell us if this subtree contains a\n\t\t\t// rendered DOM node, and what the first rendered DOM node is\n\t\t\treturn sibling._dom;\n\t\t}\n\t}\n\n\t// If we get here, we have not found a DOM node in this vnode's children.\n\t// We must resume from this vnode's sibling (in it's parent _children array)\n\t// Only climb up and search the parent if we aren't searching through a DOM\n\t// VNode (meaning we reached the DOM parent of the original vnode that began\n\t// the search)\n\treturn typeof vnode.type == 'function' ? getDomSibling(vnode) : null;\n}\n\n/**\n * Trigger in-place re-rendering of a component.\n * @param {import('./internal').Component} component The component to rerender\n */\nfunction renderComponent(component) {\n\tlet vnode = component._vnode,\n\t\toldDom = vnode._dom,\n\t\tparentDom = component._parentDom;\n\n\tif (parentDom) {\n\t\tlet commitQueue = [],\n\t\t\trefQueue = [];\n\t\tconst oldVNode = assign({}, vnode);\n\t\toldVNode._original = vnode._original + 1;\n\n\t\tdiff(\n\t\t\tparentDom,\n\t\t\tvnode,\n\t\t\toldVNode,\n\t\t\tcomponent._globalContext,\n\t\t\tparentDom.ownerSVGElement !== undefined,\n\t\t\tvnode._hydrating != null ? [oldDom] : null,\n\t\t\tcommitQueue,\n\t\t\toldDom == null ? getDomSibling(vnode) : oldDom,\n\t\t\tvnode._hydrating,\n\t\t\trefQueue\n\t\t);\n\n\t\tcommitRoot(commitQueue, vnode, refQueue);\n\n\t\tif (vnode._dom != oldDom) {\n\t\t\tupdateParentDomPointers(vnode);\n\t\t}\n\t}\n}\n\n/**\n * @param {import('./internal').VNode} vnode\n */\nfunction updateParentDomPointers(vnode) {\n\tif ((vnode = vnode._parent) != null && vnode._component != null) {\n\t\tvnode._dom = vnode._component.base = null;\n\t\tfor (let i = 0; i < vnode._children.length; i++) {\n\t\t\tlet child = vnode._children[i];\n\t\t\tif (child != null && child._dom != null) {\n\t\t\t\tvnode._dom = vnode._component.base = child._dom;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn updateParentDomPointers(vnode);\n\t}\n}\n\n/**\n * The render queue\n * @type {Array<import('./internal').Component>}\n */\nlet rerenderQueue = [];\n\n/*\n * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is\n * important that contributors to Preact can consistently reason about what calls to `setState`, etc.\n * do, and when their effects will be applied. See the links below for some further reading on designing\n * asynchronous APIs.\n * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)\n * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)\n */\n\nlet prevDebounce;\n\nconst defer =\n\ttypeof Promise == 'function'\n\t\t? Promise.prototype.then.bind(Promise.resolve())\n\t\t: setTimeout;\n\n/**\n * Enqueue a rerender of a component\n * @param {import('./internal').Component} c The component to rerender\n */\nexport function enqueueRender(c) {\n\tif (\n\t\t(!c._dirty &&\n\t\t\t(c._dirty = true) &&\n\t\t\trerenderQueue.push(c) &&\n\t\t\t!process._rerenderCount++) ||\n\t\tprevDebounce !== options.debounceRendering\n\t) {\n\t\tprevDebounce = options.debounceRendering;\n\t\t(prevDebounce || defer)(process);\n\t}\n}\n\n/**\n * @param {import('./internal').Component} a\n * @param {import('./internal').Component} b\n */\nconst depthSort = (a, b) => a._vnode._depth - b._vnode._depth;\n\n/** Flush the render queue by rerendering all queued components */\nfunction process() {\n\tlet c;\n\trerenderQueue.sort(depthSort);\n\t// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary\n\t// process() calls from getting scheduled while `queue` is still being consumed.\n\twhile ((c = rerenderQueue.shift())) {\n\t\tif (c._dirty) {\n\t\t\tlet renderQueueLength = rerenderQueue.length;\n\t\t\trenderComponent(c);\n\t\t\tif (rerenderQueue.length > renderQueueLength) {\n\t\t\t\t// When i.e. rerendering a provider additional new items can be injected, we want to\n\t\t\t\t// keep the order from top to bottom with those new items so we can handle them in a\n\t\t\t\t// single pass\n\t\t\t\trerenderQueue.sort(depthSort);\n\t\t\t}\n\t\t}\n\t}\n\tprocess._rerenderCount = 0;\n}\n\nprocess._rerenderCount = 0;\n","import { diff, unmount, applyRef } from './index';\nimport { createVNode, Fragment } from '../create-element';\nimport { EMPTY_OBJ, EMPTY_ARR } from '../constants';\nimport { isArray } from '../util';\nimport { getDomSibling } from '../component';\n\n/**\n * Diff the children of a virtual node\n * @param {import('../internal').PreactElement} parentDom The DOM element whose\n * children are being diffed\n * @param {import('../internal').ComponentChildren[]} renderResult\n * @param {import('../internal').VNode} newParentVNode The new virtual\n * node whose children should be diff'ed against oldParentVNode\n * @param {import('../internal').VNode} oldParentVNode The old virtual\n * node whose children should be diff'ed against newParentVNode\n * @param {object} globalContext The current context object - modified by getChildContext\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {Array<import('../internal').PreactElement>} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {import('../internal').PreactElement} oldDom The current attached DOM\n * element any new dom elements should be placed around. Likely `null` on first\n * render (except when hydrating). Can be a sibling DOM element when diffing\n * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {Array<any>} refQueue an array of elements needed to invoke refs\n */\nexport function diffChildren(\n\tparentDom,\n\trenderResult,\n\tnewParentVNode,\n\toldParentVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating,\n\trefQueue\n) {\n\tlet i,\n\t\tj,\n\t\toldVNode,\n\t\tchildVNode,\n\t\tnewDom,\n\t\tfirstChildDom,\n\t\tskew = 0;\n\n\t// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR\n\t// as EMPTY_OBJ._children should be `undefined`.\n\tlet oldChildren = (oldParentVNode && oldParentVNode._children) || EMPTY_ARR;\n\n\tlet oldChildrenLength = oldChildren.length,\n\t\tremainingOldChildren = oldChildrenLength,\n\t\tnewChildrenLength = renderResult.length;\n\n\tnewParentVNode._children = [];\n\tfor (i = 0; i < newChildrenLength; i++) {\n\t\tchildVNode = renderResult[i];\n\n\t\tif (\n\t\t\tchildVNode == null ||\n\t\t\ttypeof childVNode == 'boolean' ||\n\t\t\ttypeof childVNode == 'function'\n\t\t) {\n\t\t\tchildVNode = newParentVNode._children[i] = null;\n\t\t}\n\t\t// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,\n\t\t// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have\n\t\t// it's own DOM & etc. pointers\n\t\telse if (\n\t\t\ttypeof childVNode == 'string' ||\n\t\t\ttypeof childVNode == 'number' ||\n\t\t\t// eslint-disable-next-line valid-typeof\n\t\t\ttypeof childVNode == 'bigint'\n\t\t) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tnull,\n\t\t\t\tchildVNode,\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tchildVNode\n\t\t\t);\n\t\t} else if (isArray(childVNode)) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tFragment,\n\t\t\t\t{ children: childVNode },\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tnull\n\t\t\t);\n\t\t} else if (childVNode._depth > 0) {\n\t\t\t// VNode is already in use, clone it. This can happen in the following\n\t\t\t// scenario:\n\t\t\t//   const reuse = <div />\n\t\t\t//   <div>{reuse}<span />{reuse}</div>\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tchildVNode.type,\n\t\t\t\tchildVNode.props,\n\t\t\t\tchildVNode.key,\n\t\t\t\tchildVNode.ref ? childVNode.ref : null,\n\t\t\t\tchildVNode._original\n\t\t\t);\n\t\t} else {\n\t\t\tchildVNode = newParentVNode._children[i] = childVNode;\n\t\t}\n\n\t\t// Terser removes the `continue` here and wraps the loop body\n\t\t// in a `if (childVNode) { ... } condition\n\t\tif (childVNode == null) {\n\t\t\toldVNode = oldChildren[i];\n\t\t\tif (oldVNode && oldVNode.key == null && oldVNode._dom) {\n\t\t\t\tif (oldVNode._dom == oldDom) {\n\t\t\t\t\toldDom = getDomSibling(oldVNode);\n\t\t\t\t}\n\n\t\t\t\tunmount(oldVNode, oldVNode, false);\n\t\t\t}\n\n\t\t\tcontinue;\n\t\t}\n\n\t\tchildVNode._parent = newParentVNode;\n\t\tchildVNode._depth = newParentVNode._depth + 1;\n\n\t\tlet skewedIndex = i + skew;\n\t\tconst matchingIndex = findMatchingIndex(\n\t\t\tchildVNode,\n\t\t\toldChildren,\n\t\t\tskewedIndex,\n\t\t\tremainingOldChildren\n\t\t);\n\n\t\tif (matchingIndex === -1) {\n\t\t\toldVNode = EMPTY_OBJ;\n\t\t} else {\n\t\t\toldVNode = oldChildren[matchingIndex] || EMPTY_OBJ;\n\t\t\toldChildren[matchingIndex] = undefined;\n\t\t\tremainingOldChildren--;\n\t\t}\n\n\t\t// Morph the old element into the new one, but don't append it to the dom yet\n\t\tdiff(\n\t\t\tparentDom,\n\t\t\tchildVNode,\n\t\t\toldVNode,\n\t\t\tglobalContext,\n\t\t\tisSvg,\n\t\t\texcessDomChildren,\n\t\t\tcommitQueue,\n\t\t\toldDom,\n\t\t\tisHydrating,\n\t\t\trefQueue\n\t\t);\n\n\t\tnewDom = childVNode._dom;\n\t\tif ((j = childVNode.ref) && oldVNode.ref != j) {\n\t\t\tif (oldVNode.ref) {\n\t\t\t\tapplyRef(oldVNode.ref, null, childVNode);\n\t\t\t}\n\t\t\trefQueue.push(j, childVNode._component || newDom, childVNode);\n\t\t}\n\n\t\tif (newDom != null) {\n\t\t\tif (firstChildDom == null) {\n\t\t\t\tfirstChildDom = newDom;\n\t\t\t}\n\n\t\t\tlet isMounting = oldVNode === EMPTY_OBJ || oldVNode._original === null;\n\t\t\tif (isMounting) {\n\t\t\t\tif (matchingIndex == -1) {\n\t\t\t\t\tskew--;\n\t\t\t\t}\n\t\t\t} else if (matchingIndex !== skewedIndex) {\n\t\t\t\tif (matchingIndex === skewedIndex + 1) {\n\t\t\t\t\tskew++;\n\t\t\t\t} else if (matchingIndex > skewedIndex) {\n\t\t\t\t\tif (remainingOldChildren > newChildrenLength - skewedIndex) {\n\t\t\t\t\t\tskew += matchingIndex - skewedIndex;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// ### Change from keyed: I think this was missing from the algo...\n\t\t\t\t\t\tskew--;\n\t\t\t\t\t}\n\t\t\t\t} else if (matchingIndex < skewedIndex) {\n\t\t\t\t\tif (matchingIndex == skewedIndex - 1) {\n\t\t\t\t\t\tskew = matchingIndex - skewedIndex;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tskew = 0;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tskew = 0;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tskewedIndex = i + skew;\n\n\t\t\tif (\n\t\t\t\ttypeof childVNode.type == 'function' &&\n\t\t\t\t(matchingIndex !== skewedIndex ||\n\t\t\t\t\toldVNode._children === childVNode._children)\n\t\t\t) {\n\t\t\t\toldDom = reorderChildren(childVNode, oldDom, parentDom);\n\t\t\t} else if (\n\t\t\t\ttypeof childVNode.type != 'function' &&\n\t\t\t\t(matchingIndex !== skewedIndex || isMounting)\n\t\t\t) {\n\t\t\t\toldDom = placeChild(parentDom, newDom, oldDom);\n\t\t\t} else if (childVNode._nextDom !== undefined) {\n\t\t\t\t// Only Fragments or components that return Fragment like VNodes will\n\t\t\t\t// have a non-undefined _nextDom. Continue the diff from the sibling\n\t\t\t\t// of last DOM child of this child VNode\n\t\t\t\toldDom = childVNode._nextDom;\n\n\t\t\t\t// Eagerly cleanup _nextDom. We don't need to persist the value because\n\t\t\t\t// it is only used by `diffChildren` to determine where to resume the diff after\n\t\t\t\t// diffing Components and Fragments. Once we store it the nextDOM local var, we\n\t\t\t\t// can clean up the property\n\t\t\t\tchildVNode._nextDom = undefined;\n\t\t\t} else {\n\t\t\t\toldDom = newDom.nextSibling;\n\t\t\t}\n\n\t\t\tif (typeof newParentVNode.type == 'function') {\n\t\t\t\t// Because the newParentVNode is Fragment-like, we need to set it's\n\t\t\t\t// _nextDom property to the nextSibling of its last child DOM node.\n\t\t\t\t//\n\t\t\t\t// `oldDom` contains the correct value here because if the last child\n\t\t\t\t// is a Fragment-like, then oldDom has already been set to that child's _nextDom.\n\t\t\t\t// If the last child is a DOM VNode, then oldDom will be set to that DOM\n\t\t\t\t// node's nextSibling.\n\t\t\t\tnewParentVNode._nextDom = oldDom;\n\t\t\t}\n\t\t}\n\t}\n\n\tnewParentVNode._dom = firstChildDom;\n\n\t// Remove remaining oldChildren if there are any.\n\tfor (i = oldChildrenLength; i--; ) {\n\t\tif (oldChildren[i] != null) {\n\t\t\tif (\n\t\t\t\ttypeof newParentVNode.type == 'function' &&\n\t\t\t\toldChildren[i]._dom != null &&\n\t\t\t\toldChildren[i]._dom == newParentVNode._nextDom\n\t\t\t) {\n\t\t\t\t// If the newParentVNode.__nextDom points to a dom node that is about to\n\t\t\t\t// be unmounted, then get the next sibling of that vnode and set\n\t\t\t\t// _nextDom to it\n\n\t\t\t\tnewParentVNode._nextDom = oldChildren[i]._dom.nextSibling;\n\t\t\t}\n\n\t\t\tunmount(oldChildren[i], oldChildren[i]);\n\t\t}\n\t}\n}\n\nfunction reorderChildren(childVNode, oldDom, parentDom) {\n\t// Note: VNodes in nested suspended trees may be missing _children.\n\tlet c = childVNode._children;\n\n\tlet tmp = 0;\n\tfor (; c && tmp < c.length; tmp++) {\n\t\tlet vnode = c[tmp];\n\t\tif (vnode) {\n\t\t\t// We typically enter this code path on sCU bailout, where we copy\n\t\t\t// oldVNode._children to newVNode._children. If that is the case, we need\n\t\t\t// to update the old children's _parent pointer to point to the newVNode\n\t\t\t// (childVNode here).\n\t\t\tvnode._parent = childVNode;\n\n\t\t\tif (typeof vnode.type == 'function') {\n\t\t\t\toldDom = reorderChildren(vnode, oldDom, parentDom);\n\t\t\t} else {\n\t\t\t\toldDom = placeChild(parentDom, vnode._dom, oldDom);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn oldDom;\n}\n\n/**\n * Flatten and loop through the children of a virtual node\n * @param {import('../index').ComponentChildren} children The unflattened\n * children of a virtual node\n * @returns {import('../internal').VNode[]}\n */\nexport function toChildArray(children, out) {\n\tout = out || [];\n\tif (children == null || typeof children == 'boolean') {\n\t} else if (isArray(children)) {\n\t\tchildren.some(child => {\n\t\t\ttoChildArray(child, out);\n\t\t});\n\t} else {\n\t\tout.push(children);\n\t}\n\treturn out;\n}\n\nfunction placeChild(parentDom, newDom, oldDom) {\n\tif (oldDom == null || oldDom.parentNode !== parentDom) {\n\t\tparentDom.insertBefore(newDom, null);\n\t} else if (newDom != oldDom || newDom.parentNode == null) {\n\t\tparentDom.insertBefore(newDom, oldDom);\n\t}\n\n\treturn newDom.nextSibling;\n}\n\n/**\n * @param {import('../internal').VNode | string} childVNode\n * @param {import('../internal').VNode[]} oldChildren\n * @param {number} skewedIndex\n * @param {number} remainingOldChildren\n * @returns {number}\n */\nfunction findMatchingIndex(\n\tchildVNode,\n\toldChildren,\n\tskewedIndex,\n\tremainingOldChildren\n) {\n\tconst key = childVNode.key;\n\tconst type = childVNode.type;\n\tlet x = skewedIndex - 1;\n\tlet y = skewedIndex + 1;\n\tlet oldVNode = oldChildren[skewedIndex];\n\n\tif (\n\t\toldVNode === null ||\n\t\t(oldVNode && key == oldVNode.key && type === oldVNode.type)\n\t) {\n\t\treturn skewedIndex;\n\t} else if (remainingOldChildren > (oldVNode != null ? 1 : 0)) {\n\t\twhile (x >= 0 || y < oldChildren.length) {\n\t\t\tif (x >= 0) {\n\t\t\t\toldVNode = oldChildren[x];\n\t\t\t\tif (oldVNode && key == oldVNode.key && type === oldVNode.type) {\n\t\t\t\t\treturn x;\n\t\t\t\t}\n\t\t\t\tx--;\n\t\t\t}\n\n\t\t\tif (y < oldChildren.length) {\n\t\t\t\toldVNode = oldChildren[y];\n\t\t\t\tif (oldVNode && key == oldVNode.key && type === oldVNode.type) {\n\t\t\t\t\treturn y;\n\t\t\t\t}\n\t\t\t\ty++;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn -1;\n}\n","import { IS_NON_DIMENSIONAL } from '../constants';\nimport options from '../options';\n\n/**\n * Diff the old and new properties of a VNode and apply changes to the DOM node\n * @param {import('../internal').PreactElement} dom The DOM node to apply\n * changes to\n * @param {object} newProps The new props\n * @param {object} oldProps The old props\n * @param {boolean} isSvg Whether or not this node is an SVG node\n * @param {boolean} hydrate Whether or not we are in hydration mode\n */\nexport function diffProps(dom, newProps, oldProps, isSvg, hydrate) {\n\tlet i;\n\n\tfor (i in oldProps) {\n\t\tif (i !== 'children' && i !== 'key' && !(i in newProps)) {\n\t\t\tsetProperty(dom, i, null, oldProps[i], isSvg);\n\t\t}\n\t}\n\n\tfor (i in newProps) {\n\t\tif (\n\t\t\t(!hydrate || typeof newProps[i] == 'function') &&\n\t\t\ti !== 'children' &&\n\t\t\ti !== 'key' &&\n\t\t\ti !== 'value' &&\n\t\t\ti !== 'checked' &&\n\t\t\toldProps[i] !== newProps[i]\n\t\t) {\n\t\t\tsetProperty(dom, i, newProps[i], oldProps[i], isSvg);\n\t\t}\n\t}\n}\n\nfunction setStyle(style, key, value) {\n\tif (key[0] === '-') {\n\t\tstyle.setProperty(key, value == null ? '' : value);\n\t} else if (value == null) {\n\t\tstyle[key] = '';\n\t} else if (typeof value != 'number' || IS_NON_DIMENSIONAL.test(key)) {\n\t\tstyle[key] = value;\n\t} else {\n\t\tstyle[key] = value + 'px';\n\t}\n}\n\n/**\n * Set a property value on a DOM node\n * @param {import('../internal').PreactElement} dom The DOM node to modify\n * @param {string} name The name of the property to set\n * @param {*} value The value to set the property to\n * @param {*} oldValue The old value the property had\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node or not\n */\nexport function setProperty(dom, name, value, oldValue, isSvg) {\n\tlet useCapture;\n\n\to: if (name === 'style') {\n\t\tif (typeof value == 'string') {\n\t\t\tdom.style.cssText = value;\n\t\t} else {\n\t\t\tif (typeof oldValue == 'string') {\n\t\t\t\tdom.style.cssText = oldValue = '';\n\t\t\t}\n\n\t\t\tif (oldValue) {\n\t\t\t\tfor (name in oldValue) {\n\t\t\t\t\tif (!(value && name in value)) {\n\t\t\t\t\t\tsetStyle(dom.style, name, '');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (value) {\n\t\t\t\tfor (name in value) {\n\t\t\t\t\tif (!oldValue || value[name] !== oldValue[name]) {\n\t\t\t\t\t\tsetStyle(dom.style, name, value[name]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t// Benchmark for comparison: https://esbench.com/bench/574c954bdb965b9a00965ac6\n\telse if (name[0] === 'o' && name[1] === 'n') {\n\t\tuseCapture = name !== (name = name.replace(/Capture$/, ''));\n\n\t\t// Infer correct casing for DOM built-in events:\n\t\tif (name.toLowerCase() in dom) name = name.toLowerCase().slice(2);\n\t\telse name = name.slice(2);\n\n\t\tif (!dom._listeners) dom._listeners = {};\n\t\tdom._listeners[name + useCapture] = value;\n\n\t\tif (value) {\n\t\t\tif (!oldValue) {\n\t\t\t\tconst handler = useCapture ? eventProxyCapture : eventProxy;\n\t\t\t\tdom.addEventListener(name, handler, useCapture);\n\t\t\t}\n\t\t} else {\n\t\t\tconst handler = useCapture ? eventProxyCapture : eventProxy;\n\t\t\tdom.removeEventListener(name, handler, useCapture);\n\t\t}\n\t} else if (name !== 'dangerouslySetInnerHTML') {\n\t\tif (isSvg) {\n\t\t\t// Normalize incorrect prop usage for SVG:\n\t\t\t// - xlink:href / xlinkHref --> href (xlink:href was removed from SVG and isn't needed)\n\t\t\t// - className --> class\n\t\t\tname = name.replace(/xlink(H|:h)/, 'h').replace(/sName$/, 's');\n\t\t} else if (\n\t\t\tname !== 'width' &&\n\t\t\tname !== 'height' &&\n\t\t\tname !== 'href' &&\n\t\t\tname !== 'list' &&\n\t\t\tname !== 'form' &&\n\t\t\t// Default value in browsers is `-1` and an empty string is\n\t\t\t// cast to `0` instead\n\t\t\tname !== 'tabIndex' &&\n\t\t\tname !== 'download' &&\n\t\t\tname !== 'rowSpan' &&\n\t\t\tname !== 'colSpan' &&\n\t\t\tname in dom\n\t\t) {\n\t\t\ttry {\n\t\t\t\tdom[name] = value == null ? '' : value;\n\t\t\t\t// labelled break is 1b smaller here than a return statement (sorry)\n\t\t\t\tbreak o;\n\t\t\t} catch (e) {}\n\t\t}\n\n\t\t// aria- and data- attributes have no boolean representation.\n\t\t// A `false` value is different from the attribute not being\n\t\t// present, so we can't remove it. For non-boolean aria\n\t\t// attributes we could treat false as a removal, but the\n\t\t// amount of exceptions would cost too many bytes. On top of\n\t\t// that other frameworks generally stringify `false`.\n\n\t\tif (typeof value === 'function') {\n\t\t\t// never serialize functions as attribute values\n\t\t} else if (value != null && (value !== false || name[4] === '-')) {\n\t\t\tdom.setAttribute(name, value);\n\t\t} else {\n\t\t\tdom.removeAttribute(name);\n\t\t}\n\t}\n}\n\n/**\n * Proxy an event to hooked event handlers\n * @param {Event} e The event object from the browser\n * @private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type + false](options.event ? options.event(e) : e);\n}\n\nfunction eventProxyCapture(e) {\n\treturn this._listeners[e.type + true](options.event ? options.event(e) : e);\n}\n","import { EMPTY_OBJ } from '../constants';\nimport { Component, getDomSibling } from '../component';\nimport { Fragment } from '../create-element';\nimport { diffChildren } from './children';\nimport { diffProps, setProperty } from './props';\nimport { assign, isArray, removeNode, slice } from '../util';\nimport options from '../options';\n\n/**\n * Diff two virtual nodes and apply proper changes to the DOM\n * @param {import('../internal').PreactElement} parentDom The parent of the DOM element\n * @param {import('../internal').VNode} newVNode The new virtual node\n * @param {import('../internal').VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object. Modified by getChildContext\n * @param {boolean} isSvg Whether or not this element is an SVG node\n * @param {Array<import('../internal').PreactElement>} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {import('../internal').PreactElement} oldDom The current attached DOM\n * element any new dom elements should be placed around. Likely `null` on first\n * render (except when hydrating). Can be a sibling DOM element when diffing\n * Fragments that have siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {Array<any>} refQueue an array of elements needed to invoke refs\n */\nexport function diff(\n\tparentDom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating,\n\trefQueue\n) {\n\tlet tmp,\n\t\tnewType = newVNode.type;\n\n\t// When passing through createElement it assigns the object\n\t// constructor as undefined. This to prevent JSON-injection.\n\tif (newVNode.constructor !== undefined) return null;\n\n\t// If the previous diff bailed out, resume creating/hydrating.\n\tif (oldVNode._hydrating != null) {\n\t\tisHydrating = oldVNode._hydrating;\n\t\toldDom = newVNode._dom = oldVNode._dom;\n\t\t// if we resume, we want the tree to be \"unlocked\"\n\t\tnewVNode._hydrating = null;\n\t\texcessDomChildren = [oldDom];\n\t}\n\n\tif ((tmp = options._diff)) tmp(newVNode);\n\n\touter: if (typeof newType == 'function') {\n\t\ttry {\n\t\t\tlet c, isNew, oldProps, oldState, snapshot, clearProcessingException;\n\t\t\tlet newProps = newVNode.props;\n\n\t\t\t// Necessary for createContext api. Setting this property will pass\n\t\t\t// the context value as `this.context` just for this component.\n\t\t\ttmp = newType.contextType;\n\t\t\tlet provider = tmp && globalContext[tmp._id];\n\t\t\tlet componentContext = tmp\n\t\t\t\t? provider\n\t\t\t\t\t? provider.props.value\n\t\t\t\t\t: tmp._defaultValue\n\t\t\t\t: globalContext;\n\n\t\t\t// Get component and set it to `c`\n\t\t\tif (oldVNode._component) {\n\t\t\t\tc = newVNode._component = oldVNode._component;\n\t\t\t\tclearProcessingException = c._processingException = c._pendingError;\n\t\t\t} else {\n\t\t\t\t// Instantiate the new component\n\t\t\t\tif ('prototype' in newType && newType.prototype.render) {\n\t\t\t\t\t// @ts-ignore The check above verifies that newType is suppose to be constructed\n\t\t\t\t\tnewVNode._component = c = new newType(newProps, componentContext); // eslint-disable-line new-cap\n\t\t\t\t} else {\n\t\t\t\t\t// @ts-ignore Trust me, Component implements the interface we want\n\t\t\t\t\tnewVNode._component = c = new Component(newProps, componentContext);\n\t\t\t\t\tc.constructor = newType;\n\t\t\t\t\tc.render = doRender;\n\t\t\t\t}\n\t\t\t\tif (provider) provider.sub(c);\n\n\t\t\t\tc.props = newProps;\n\t\t\t\tif (!c.state) c.state = {};\n\t\t\t\tc.context = componentContext;\n\t\t\t\tc._globalContext = globalContext;\n\t\t\t\tisNew = c._dirty = true;\n\t\t\t\tc._renderCallbacks = [];\n\t\t\t\tc._stateCallbacks = [];\n\t\t\t}\n\n\t\t\t// Invoke getDerivedStateFromProps\n\t\t\tif (c._nextState == null) {\n\t\t\t\tc._nextState = c.state;\n\t\t\t}\n\n\t\t\tif (newType.getDerivedStateFromProps != null) {\n\t\t\t\tif (c._nextState == c.state) {\n\t\t\t\t\tc._nextState = assign({}, c._nextState);\n\t\t\t\t}\n\n\t\t\t\tassign(\n\t\t\t\t\tc._nextState,\n\t\t\t\t\tnewType.getDerivedStateFromProps(newProps, c._nextState)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\toldProps = c.props;\n\t\t\toldState = c.state;\n\t\t\tc._vnode = newVNode;\n\n\t\t\t// Invoke pre-render lifecycle methods\n\t\t\tif (isNew) {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tc.componentWillMount != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillMount();\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidMount != null) {\n\t\t\t\t\tc._renderCallbacks.push(c.componentDidMount);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tnewProps !== oldProps &&\n\t\t\t\t\tc.componentWillReceiveProps != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillReceiveProps(newProps, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\t!c._force &&\n\t\t\t\t\t((c.shouldComponentUpdate != null &&\n\t\t\t\t\t\tc.shouldComponentUpdate(\n\t\t\t\t\t\t\tnewProps,\n\t\t\t\t\t\t\tc._nextState,\n\t\t\t\t\t\t\tcomponentContext\n\t\t\t\t\t\t) === false) ||\n\t\t\t\t\t\tnewVNode._original === oldVNode._original)\n\t\t\t\t) {\n\t\t\t\t\t// More info about this here: https://gist.github.com/JoviDeCroock/bec5f2ce93544d2e6070ef8e0036e4e8\n\t\t\t\t\tif (newVNode._original !== oldVNode._original) {\n\t\t\t\t\t\t// When we are dealing with a bail because of sCU we have to update\n\t\t\t\t\t\t// the props, state and dirty-state.\n\t\t\t\t\t\t// when we are dealing with strict-equality we don't as the child could still\n\t\t\t\t\t\t// be dirtied see #3883\n\t\t\t\t\t\tc.props = newProps;\n\t\t\t\t\t\tc.state = c._nextState;\n\t\t\t\t\t\tc._dirty = false;\n\t\t\t\t\t}\n\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t\tnewVNode._children.forEach(vnode => {\n\t\t\t\t\t\tif (vnode) vnode._parent = newVNode;\n\t\t\t\t\t});\n\n\t\t\t\t\tfor (let i = 0; i < c._stateCallbacks.length; i++) {\n\t\t\t\t\t\tc._renderCallbacks.push(c._stateCallbacks[i]);\n\t\t\t\t\t}\n\t\t\t\t\tc._stateCallbacks = [];\n\n\t\t\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\t\t\tcommitQueue.push(c);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\n\t\t\t\tif (c.componentWillUpdate != null) {\n\t\t\t\t\tc.componentWillUpdate(newProps, c._nextState, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidUpdate != null) {\n\t\t\t\t\tc._renderCallbacks.push(() => {\n\t\t\t\t\t\tc.componentDidUpdate(oldProps, oldState, snapshot);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tc.context = componentContext;\n\t\t\tc.props = newProps;\n\t\t\tc._parentDom = parentDom;\n\t\t\tc._force = false;\n\n\t\t\tlet renderHook = options._render,\n\t\t\t\tcount = 0;\n\t\t\tif ('prototype' in newType && newType.prototype.render) {\n\t\t\t\tc.state = c._nextState;\n\t\t\t\tc._dirty = false;\n\n\t\t\t\tif (renderHook) renderHook(newVNode);\n\n\t\t\t\ttmp = c.render(c.props, c.state, c.context);\n\n\t\t\t\tfor (let i = 0; i < c._stateCallbacks.length; i++) {\n\t\t\t\t\tc._renderCallbacks.push(c._stateCallbacks[i]);\n\t\t\t\t}\n\t\t\t\tc._stateCallbacks = [];\n\t\t\t} else {\n\t\t\t\tdo {\n\t\t\t\t\tc._dirty = false;\n\t\t\t\t\tif (renderHook) renderHook(newVNode);\n\n\t\t\t\t\ttmp = c.render(c.props, c.state, c.context);\n\n\t\t\t\t\t// Handle setState called in render, see #2553\n\t\t\t\t\tc.state = c._nextState;\n\t\t\t\t} while (c._dirty && ++count < 25);\n\t\t\t}\n\n\t\t\t// Handle setState called in render, see #2553\n\t\t\tc.state = c._nextState;\n\n\t\t\tif (c.getChildContext != null) {\n\t\t\t\tglobalContext = assign(assign({}, globalContext), c.getChildContext());\n\t\t\t}\n\n\t\t\tif (!isNew && c.getSnapshotBeforeUpdate != null) {\n\t\t\t\tsnapshot = c.getSnapshotBeforeUpdate(oldProps, oldState);\n\t\t\t}\n\n\t\t\tlet isTopLevelFragment =\n\t\t\t\ttmp != null && tmp.type === Fragment && tmp.key == null;\n\t\t\tlet renderResult = isTopLevelFragment ? tmp.props.children : tmp;\n\n\t\t\tdiffChildren(\n\t\t\t\tparentDom,\n\t\t\t\tisArray(renderResult) ? renderResult : [renderResult],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg,\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\toldDom,\n\t\t\t\tisHydrating,\n\t\t\t\trefQueue\n\t\t\t);\n\n\t\t\tc.base = newVNode._dom;\n\n\t\t\t// We successfully rendered this VNode, unset any stored hydration/bailout state:\n\t\t\tnewVNode._hydrating = null;\n\n\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\tcommitQueue.push(c);\n\t\t\t}\n\n\t\t\tif (clearProcessingException) {\n\t\t\t\tc._pendingError = c._processingException = null;\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tnewVNode._original = null;\n\t\t\t// if hydrating or creating initial tree, bailout preserves DOM:\n\t\t\tif (isHydrating || excessDomChildren != null) {\n\t\t\t\tnewVNode._dom = oldDom;\n\t\t\t\tnewVNode._hydrating = !!isHydrating;\n\t\t\t\texcessDomChildren[excessDomChildren.indexOf(oldDom)] = null;\n\t\t\t\t// ^ could possibly be simplified to:\n\t\t\t\t// excessDomChildren.length = 0;\n\t\t\t}\n\t\t\toptions._catchError(e, newVNode, oldVNode);\n\t\t}\n\t} else if (\n\t\texcessDomChildren == null &&\n\t\tnewVNode._original === oldVNode._original\n\t) {\n\t\tnewVNode._children = oldVNode._children;\n\t\tnewVNode._dom = oldVNode._dom;\n\t} else {\n\t\tnewVNode._dom = diffElementNodes(\n\t\t\toldVNode._dom,\n\t\t\tnewVNode,\n\t\t\toldVNode,\n\t\t\tglobalContext,\n\t\t\tisSvg,\n\t\t\texcessDomChildren,\n\t\t\tcommitQueue,\n\t\t\tisHydrating,\n\t\t\trefQueue\n\t\t);\n\t}\n\n\tif ((tmp = options.diffed)) tmp(newVNode);\n}\n\n/**\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {import('../internal').VNode} root\n */\nexport function commitRoot(commitQueue, root, refQueue) {\n\tfor (let i = 0; i < refQueue.length; i++) {\n\t\tapplyRef(refQueue[i], refQueue[++i], refQueue[++i]);\n\t}\n\n\tif (options._commit) options._commit(root, commitQueue);\n\n\tcommitQueue.some(c => {\n\t\ttry {\n\t\t\t// @ts-ignore Reuse the commitQueue variable here so the type changes\n\t\t\tcommitQueue = c._renderCallbacks;\n\t\t\tc._renderCallbacks = [];\n\t\t\tcommitQueue.some(cb => {\n\t\t\t\t// @ts-ignore See above ts-ignore on commitQueue\n\t\t\t\tcb.call(c);\n\t\t\t});\n\t\t} catch (e) {\n\t\t\toptions._catchError(e, c._vnode);\n\t\t}\n\t});\n}\n\n/**\n * Diff two virtual nodes representing DOM element\n * @param {import('../internal').PreactElement} dom The DOM element representing\n * the virtual nodes being diffed\n * @param {import('../internal').VNode} newVNode The new virtual node\n * @param {import('../internal').VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {*} excessDomChildren\n * @param {Array<import('../internal').Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {Array<any>} refQueue an array of elements needed to invoke refs\n * @returns {import('../internal').PreactElement}\n */\nfunction diffElementNodes(\n\tdom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\tisHydrating,\n\trefQueue\n) {\n\tlet oldProps = oldVNode.props;\n\tlet newProps = newVNode.props;\n\tlet nodeType = newVNode.type;\n\tlet i = 0;\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tif (nodeType === 'svg') isSvg = true;\n\n\tif (excessDomChildren != null) {\n\t\tfor (; i < excessDomChildren.length; i++) {\n\t\t\tconst child = excessDomChildren[i];\n\n\t\t\t// if newVNode matches an element in excessDomChildren or the `dom`\n\t\t\t// argument matches an element in excessDomChildren, remove it from\n\t\t\t// excessDomChildren so it isn't later removed in diffChildren\n\t\t\tif (\n\t\t\t\tchild &&\n\t\t\t\t'setAttribute' in child === !!nodeType &&\n\t\t\t\t(nodeType ? child.localName === nodeType : child.nodeType === 3)\n\t\t\t) {\n\t\t\t\tdom = child;\n\t\t\t\texcessDomChildren[i] = null;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (dom == null) {\n\t\tif (nodeType === null) {\n\t\t\t// @ts-ignore createTextNode returns Text, we expect PreactElement\n\t\t\treturn document.createTextNode(newProps);\n\t\t}\n\n\t\tif (isSvg) {\n\t\t\tdom = document.createElementNS(\n\t\t\t\t'http://www.w3.org/2000/svg',\n\t\t\t\t// @ts-ignore We know `newVNode.type` is a string\n\t\t\t\tnodeType\n\t\t\t);\n\t\t} else {\n\t\t\tdom = document.createElement(\n\t\t\t\t// @ts-ignore We know `newVNode.type` is a string\n\t\t\t\tnodeType,\n\t\t\t\tnewProps.is && newProps\n\t\t\t);\n\t\t}\n\n\t\t// we created a new parent, so none of the previously attached children can be reused:\n\t\texcessDomChildren = null;\n\t\t// we are creating a new node, so we can assume this is a new subtree (in case we are hydrating), this deopts the hydrate\n\t\tisHydrating = false;\n\t}\n\n\tif (nodeType === null) {\n\t\t// During hydration, we still have to split merged text from SSR'd HTML.\n\t\tif (oldProps !== newProps && (!isHydrating || dom.data !== newProps)) {\n\t\t\tdom.data = newProps;\n\t\t}\n\t} else {\n\t\t// If excessDomChildren was not null, repopulate it with the current element's children:\n\t\texcessDomChildren = excessDomChildren && slice.call(dom.childNodes);\n\n\t\toldProps = oldVNode.props || EMPTY_OBJ;\n\n\t\tlet oldHtml = oldProps.dangerouslySetInnerHTML;\n\t\tlet newHtml = newProps.dangerouslySetInnerHTML;\n\n\t\t// During hydration, props are not diffed at all (including dangerouslySetInnerHTML)\n\t\t// @TODO we should warn in debug mode when props don't match here.\n\t\tif (!isHydrating) {\n\t\t\t// But, if we are in a situation where we are using existing DOM (e.g. replaceNode)\n\t\t\t// we should read the existing DOM attributes to diff them\n\t\t\tif (excessDomChildren != null) {\n\t\t\t\toldProps = {};\n\t\t\t\tfor (i = 0; i < dom.attributes.length; i++) {\n\t\t\t\t\toldProps[dom.attributes[i].name] = dom.attributes[i].value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (newHtml || oldHtml) {\n\t\t\t\t// Avoid re-applying the same '__html' if it did not changed between re-render\n\t\t\t\tif (\n\t\t\t\t\t!newHtml ||\n\t\t\t\t\t((!oldHtml || newHtml.__html != oldHtml.__html) &&\n\t\t\t\t\t\tnewHtml.__html !== dom.innerHTML)\n\t\t\t\t) {\n\t\t\t\t\tdom.innerHTML = (newHtml && newHtml.__html) || '';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tdiffProps(dom, newProps, oldProps, isSvg, isHydrating);\n\n\t\t// If the new vnode didn't have dangerouslySetInnerHTML, diff its children\n\t\tif (newHtml) {\n\t\t\tnewVNode._children = [];\n\t\t} else {\n\t\t\ti = newVNode.props.children;\n\t\t\tdiffChildren(\n\t\t\t\tdom,\n\t\t\t\tisArray(i) ? i : [i],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg && nodeType !== 'foreignObject',\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\texcessDomChildren\n\t\t\t\t\t? excessDomChildren[0]\n\t\t\t\t\t: oldVNode._children && getDomSibling(oldVNode, 0),\n\t\t\t\tisHydrating,\n\t\t\t\trefQueue\n\t\t\t);\n\n\t\t\t// Remove children that are not part of any vnode.\n\t\t\tif (excessDomChildren != null) {\n\t\t\t\tfor (i = excessDomChildren.length; i--; ) {\n\t\t\t\t\tif (excessDomChildren[i] != null) removeNode(excessDomChildren[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// (as above, don't diff props during hydration)\n\t\tif (!isHydrating) {\n\t\t\tif (\n\t\t\t\t'value' in newProps &&\n\t\t\t\t(i = newProps.value) !== undefined &&\n\t\t\t\t// #2756 For the <progress>-element the initial value is 0,\n\t\t\t\t// despite the attribute not being present. When the attribute\n\t\t\t\t// is missing the progress bar is treated as indeterminate.\n\t\t\t\t// To fix that we'll always update it when it is 0 for progress elements\n\t\t\t\t(i !== dom.value ||\n\t\t\t\t\t(nodeType === 'progress' && !i) ||\n\t\t\t\t\t// This is only for IE 11 to fix <select> value not being updated.\n\t\t\t\t\t// To avoid a stale select value we need to set the option.value\n\t\t\t\t\t// again, which triggers IE11 to re-evaluate the select value\n\t\t\t\t\t(nodeType === 'option' && i !== oldProps.value))\n\t\t\t) {\n\t\t\t\tsetProperty(dom, 'value', i, oldProps.value, false);\n\t\t\t}\n\t\t\tif (\n\t\t\t\t'checked' in newProps &&\n\t\t\t\t(i = newProps.checked) !== undefined &&\n\t\t\t\ti !== dom.checked\n\t\t\t) {\n\t\t\t\tsetProperty(dom, 'checked', i, oldProps.checked, false);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/**\n * Invoke or update a ref, depending on whether it is a function or object ref.\n * @param {object|function} ref\n * @param {any} value\n * @param {import('../internal').VNode} vnode\n */\nexport function applyRef(ref, value, vnode) {\n\ttry {\n\t\tif (typeof ref == 'function') ref(value);\n\t\telse ref.current = value;\n\t} catch (e) {\n\t\toptions._catchError(e, vnode);\n\t}\n}\n\n/**\n * Unmount a virtual node from the tree and apply DOM changes\n * @param {import('../internal').VNode} vnode The virtual node to unmount\n * @param {import('../internal').VNode} parentVNode The parent of the VNode that\n * initiated the unmount\n * @param {boolean} [skipRemove] Flag that indicates that a parent node of the\n * current element is already detached from the DOM.\n */\nexport function unmount(vnode, parentVNode, skipRemove) {\n\tlet r;\n\tif (options.unmount) options.unmount(vnode);\n\n\tif ((r = vnode.ref)) {\n\t\tif (!r.current || r.current === vnode._dom) {\n\t\t\tapplyRef(r, null, parentVNode);\n\t\t}\n\t}\n\n\tif ((r = vnode._component) != null) {\n\t\tif (r.componentWillUnmount) {\n\t\t\ttry {\n\t\t\t\tr.componentWillUnmount();\n\t\t\t} catch (e) {\n\t\t\t\toptions._catchError(e, parentVNode);\n\t\t\t}\n\t\t}\n\n\t\tr.base = r._parentDom = null;\n\t\tvnode._component = undefined;\n\t}\n\n\tif ((r = vnode._children)) {\n\t\tfor (let i = 0; i < r.length; i++) {\n\t\t\tif (r[i]) {\n\t\t\t\tunmount(\n\t\t\t\t\tr[i],\n\t\t\t\t\tparentVNode,\n\t\t\t\t\tskipRemove || typeof vnode.type !== 'function'\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif (!skipRemove && vnode._dom != null) {\n\t\tremoveNode(vnode._dom);\n\t}\n\n\t// Must be set to `undefined` to properly clean up `_nextDom`\n\t// for which `null` is a valid value. See comment in `create-element.js`\n\tvnode._parent = vnode._dom = vnode._nextDom = undefined;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n","import { EMPTY_OBJ } from './constants';\nimport { commitRoot, diff } from './diff/index';\nimport { createElement, Fragment } from './create-element';\nimport options from './options';\nimport { slice } from './util';\n\n/**\n * Render a Preact virtual node into a DOM element\n * @param {import('./internal').ComponentChild} vnode The virtual node to render\n * @param {import('./internal').PreactElement} parentDom The DOM element to\n * render into\n * @param {import('./internal').PreactElement | object} [replaceNode] Optional: Attempt to re-use an\n * existing DOM tree rooted at `replaceNode`\n */\nexport function render(vnode, parentDom, replaceNode) {\n\tif (options._root) options._root(vnode, parentDom);\n\n\t// We abuse the `replaceNode` parameter in `hydrate()` to signal if we are in\n\t// hydration mode or not by passing the `hydrate` function instead of a DOM\n\t// element..\n\tlet isHydrating = typeof replaceNode === 'function';\n\n\t// To be able to support calling `render()` multiple times on the same\n\t// DOM node, we need to obtain a reference to the previous tree. We do\n\t// this by assigning a new `_children` property to DOM nodes which points\n\t// to the last rendered tree. By default this property is not present, which\n\t// means that we are mounting a new tree for the first time.\n\tlet oldVNode = isHydrating\n\t\t? null\n\t\t: (replaceNode && replaceNode._children) || parentDom._children;\n\n\tvnode = ((!isHydrating && replaceNode) || parentDom)._children =\n\t\tcreateElement(Fragment, null, [vnode]);\n\n\t// List of effects that need to be called after diffing.\n\tlet commitQueue = [],\n\t\trefQueue = [];\n\tdiff(\n\t\tparentDom,\n\t\t// Determine the new vnode tree and store it on the DOM element on\n\t\t// our custom `_children` property.\n\t\tvnode,\n\t\toldVNode || EMPTY_OBJ,\n\t\tEMPTY_OBJ,\n\t\tparentDom.ownerSVGElement !== undefined,\n\t\t!isHydrating && replaceNode\n\t\t\t? [replaceNode]\n\t\t\t: oldVNode\n\t\t\t? null\n\t\t\t: parentDom.firstChild\n\t\t\t? slice.call(parentDom.childNodes)\n\t\t\t: null,\n\t\tcommitQueue,\n\t\t!isHydrating && replaceNode\n\t\t\t? replaceNode\n\t\t\t: oldVNode\n\t\t\t? oldVNode._dom\n\t\t\t: parentDom.firstChild,\n\t\tisHydrating,\n\t\trefQueue\n\t);\n\n\t// Flush all queued effects\n\tcommitRoot(commitQueue, vnode, refQueue);\n}\n\n/**\n * Update an existing DOM element with data from a Preact virtual node\n * @param {import('./internal').ComponentChild} vnode The virtual node to render\n * @param {import('./internal').PreactElement} parentDom The DOM element to\n * update\n */\nexport function hydrate(vnode, parentDom) {\n\trender(vnode, parentDom, hydrate);\n}\n","/**\n * Find the closest error boundary to a thrown error and call it\n * @param {object} error The thrown value\n * @param {import('../internal').VNode} vnode The vnode that threw\n * the error that was caught (except for unmounting when this parameter\n * is the highest parent that was being unmounted)\n * @param {import('../internal').VNode} [oldVNode]\n * @param {import('../internal').ErrorInfo} [errorInfo]\n */\nexport function _catchError(error, vnode, oldVNode, errorInfo) {\n\t/** @type {import('../internal').Component} */\n\tlet component, ctor, handled;\n\n\tfor (; (vnode = vnode._parent); ) {\n\t\tif ((component = vnode._component) && !component._processingException) {\n\t\t\ttry {\n\t\t\t\tctor = component.constructor;\n\n\t\t\t\tif (ctor && ctor.getDerivedStateFromError != null) {\n\t\t\t\t\tcomponent.setState(ctor.getDerivedStateFromError(error));\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\tif (component.componentDidCatch != null) {\n\t\t\t\t\tcomponent.componentDidCatch(error, errorInfo || {});\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\t// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.\n\t\t\t\tif (handled) {\n\t\t\t\t\treturn (component._pendingError = component);\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\terror = e;\n\t\t\t}\n\t\t}\n\t}\n\n\tthrow error;\n}\n"],"names":["a","c","t","type","n","displayName","name","u","l","s","length","f","d","p","e","__o","push","reduce","__source","fileName","lineNumber","console","warn","h","WeakMap","v","__","__e","parentNode","localName","y","prototype","setState","this","__v","state","call","m","forceUpdate","b","props","o","r","hasOwnProperty","Object","toString","JSON","stringify","i","children","__P","__b","diffed","vnode","__r","pop","__h","w","__c","g","useEffect","useLayoutEffect","lazyPropTypes","E","k","then","Error","componentStack","setTimeout","nodeType","__k","Array","isArray","ref","propTypes","has","set","__f","keys","forEach","message","error","_","get","indexOf","j","nodeName","attributes","I","create","__self","__proto__","join","key","__H","done","value","window","__PREACT_DEVTOOLS__","attachPreact","Fragment","Component","options","removeChild","arguments","defaultProps","__d","constructor","context","base","x","debounceRendering","sort","shift","L","__n","ownerSVGElement","M","P","S","H","T","z","A","O","nextSibling","$","C","q","insertBefore","setProperty","test","style","cssText","replace","toLowerCase","slice","addEventListener","removeEventListener","removeAttribute","setAttribute","event","contextType","__E","render","B","sub","_sb","__s","getDerivedStateFromProps","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","componentWillUpdate","componentDidUpdate","getChildContext","getSnapshotBeforeUpdate","N","some","document","createTextNode","createElementNS","createElement","is","data","childNodes","dangerouslySetInnerHTML","__html","innerHTML","checked","current","unmount","componentWillUnmount","D","firstChild","getDerivedStateFromError","componentDidCatch","Promise","bind","resolve"],"sourceRoot":""}