{
  "version": 3,
  "sources": [ "../webpack/bootstrap", "../../src/constants.js", "../../src/options.js", "../../src/create-element.js", "../../src/component.js", "../../src/create-context.js", "../../src/util.js", "../../src/diff/children.js", "../../src/diff/props.js", "../../src/diff/index.js", "../../src/render.js", "../../src/clone-element.js", "../../src/diff/catch-error.js", "../node_modules/preact/compat/jsx-runtime.mjs", "../node_modules/cookie/index.js", "../../src/index.js", "../../src/PureComponent.js", "../../src/forwardRef.js", "../../src/Children.js", "../../src/suspense.js", "../../src/suspense-list.js", "../../src/portals.js", "../../src/scheduler.js", "../../src/memo.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/slicedToArray.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js", "../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js", "../node_modules/universal-cookie/es6/utils.js", "../node_modules/universal-cookie/es6/Cookies.js", "../node_modules/react-cookie/es6/Cookies.js", "../node_modules/react-cookie/es6/CookiesContext.js", "components/user-nav.js", "../node_modules/react-cookie/es6/useCookies.js", "index.js" ],
  "names": [ "installedModules", "__webpack_require__", "moduleId", "exports", "module", "i", "l", "modules", "call", "m", "c", "d", "name", "getter", "o", "Object", "defineProperty", "enumerable", "get", "r", "Symbol", "toStringTag", "value", "t", "mode", "__esModule", "ns", "create", "key", "bind", "n", "object", "property", "prototype", "hasOwnProperty", "p", "s", "options", "isValidElement", "rerenderQueue", "defer", "prevDebounce", "EMPTY_OBJ", "EMPTY_ARR", "IS_NON_DIMENSIONAL", "assign", "obj", "props", "removeNode", "node", "parentNode", "removeChild", "createElement", "type", "children", "ref", "normalizedProps", "arguments", "length", "push", "defaultProps", "createVNode", "original", "vnode", "undefined", "constructor", "createRef", "current", "Fragment", "Component", "context", "getDomSibling", "childIndex", "indexOf", "sibling", "updateParentDomPointers", "child", "base", "enqueueRender", "process", "debounceRendering", "queue", "sort", "a", "b", "some", "component", "commitQueue", "oldVNode", "oldDom", "parentDom", "diff", "ownerSVGElement", "commitRoot", "diffChildren", "renderResult", "newParentVNode", "oldParentVNode", "globalContext", "isSvg", "excessDomChildren", "isHydrating", "j", "childVNode", "newDom", "firstChildDom", "refs", "oldChildren", "oldChildrenLength", "Array", "isArray", "reorderChildren", "placeChild", "unmount", "applyRef", "tmp", "toChildArray", "out", "nextDom", "sibDom", "outer", "appendChild", "nextSibling", "insertBefore", "setStyle", "style", "setProperty", "test", "dom", "oldValue", "useCapture", "cssText", "replace", "toLowerCase", "slice", "_listeners", "addEventListener", "eventProxyCapture", "eventProxy", "removeEventListener", "e", "setAttribute", "removeAttribute", "event", "newVNode", "isNew", "oldProps", "oldState", "snapshot", "clearProcessingException", "newProps", "provider", "componentContext", "newType", "contextType", "render", "doRender", "sub", "state", "getDerivedStateFromProps", "componentWillMount", "componentDidMount", "componentWillReceiveProps", "shouldComponentUpdate", "forEach", "componentWillUpdate", "componentDidUpdate", "getChildContext", "getSnapshotBeforeUpdate", "diffElementNodes", "diffed", "root", "cb", "oldHtml", "newHtml", "nodeType", "localName", "document", "createTextNode", "createElementNS", "is", "data", "childNodes", "dangerouslySetInnerHTML", "attributes", "innerHTML", "hydrate", "diffProps", "firstChild", "checked", "parentVNode", "skipRemove", "componentWillUnmount", "this", "replaceNode", "cloneElement", "createContext", "defaultValue", "contextId", "Consumer", "contextValue", "Provider", "subs", "ctx", "_props", "old", "splice", "error", "ctor", "handled", "getDerivedStateFromError", "setState", "componentDidCatch", "update", "callback", "forceUpdate", "Promise", "then", "resolve", "setTimeout", "parse", "str", "TypeError", "opt", "pairs", "split", "pairSplitRegExp", "dec", "decode", "pair", "eq_idx", "substr", "trim", "val", "tryDecode", "serialize", "enc", "encode", "fieldContentRegExp", "maxAge", "isNaN", "Error", "Math", "floor", "domain", "path", "expires", "toUTCString", "httpOnly", "secure", "sameSite", "decodeURIComponent", "encodeURIComponent", "__source", "__self", "defaults", "currentIndex", "currentComponent", "prevRaf", "currentHook", "afterPaintEffects", "oldBeforeDiff", "oldBeforeRender", "oldAfterDiff", "oldCommit", "oldBeforeUnmount", "getHookState", "index", "hooks", "useState", "initialState", "useReducer", "invokeOrReturn", "reducer", "init", "hookState", "_reducer", "nextValue", "action", "useEffect", "args", "argsChanged", "useLayoutEffect", "useRef", "initialValue", "useMemo", "factory", "useContext", "flushAfterPaintEffects", "invokeCleanup", "invokeEffect", "requestAnimationFrame", "raf", "done", "clearTimeout", "timeout", "HAS_RAF", "cancelAnimationFrame", "filter", "hook", "comp", "oldArgs", "newArgs", "arg", "f", "shallowDiffers", "PureComponent", "isPureReactComponent", "oldDiffHook", "REACT_FORWARD_SYMBOL", "for", "Forwarded", "mapFn", "fn", "map", "Children", "count", "only", "normalized", "toArray", "oldCatchError", "oldUnmount", "Suspense", "_suspenders", "suspended", "SuspenseList", "_next", "_map", "promise", "suspendingVNode", "suspendingComponent", "resolved", "onResolved", "onSuspensionComplete", "suspendedVNode", "removeOriginal", "detachedParent", "originalParent", "pop", "wasHydrating", "detachedComponent", "detachedClone", "effect", "fallback", "list", "delete", "revealOrder", "size", "ContextProvider", "Portal", "_this", "container", "_container", "_temp", "before", "delegated", "u", "wrappedUnsuspend", "unsuspend", "Map", "reverse", "set", "REACT_ELEMENT_TYPE", "CAMEL_PROPS", "onChangeInputType", "isReactComponent", "configurable", "v", "writable", "oldEventHook", "empty", "isPropagationStopped", "cancelBubble", "isDefaultPrevented", "defaultPrevented", "persist", "nativeEvent", "classNameDescriptor", "class", "oldVNodeHook", "multiple", "selected", "className", "$$typeof", "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED", "ReactCurrentDispatcher", "readContext", "performance", "now", "element", "useImperativeHandle", "createHandle", "concat", "useCallback", "useDebugValue", "formatter", "version", "parent", "textContent", "preactRender", "preactHydrate", "unmountComponentAtNode", "createPortal", "createFactory", "preactCloneElement", "apply", "findDOMNode", "memo", "comparer", "shouldUpdate", "nextProps", "updateRef", "Memoed", "displayName", "forwardRef", "clone", "unstable_batchedUpdates", "StrictMode", "lazy", "loader", "prom", "Lazy", "default", "_arrayLikeToArray", "arr", "len", "arr2", "_slicedToArray", "iterator", "_arr", "_n", "_d", "_e", "_s", "_i", "next", "err", "minLen", "toString", "from", "readCookie", "cleanValue", "cleanupCookieValue", "doNotParse", "isParsingCookie", "JSON", "__assign", "Cookies", "cookies", "changeListeners", "HAS_DOCUMENT_COOKIE", "cookie", "parseCookies", "catch", "_updateBrowserValues", "parseOptions", "_emitChange", "params", "getAll", "result", "name_1", "_a", "stringify", "remove", "finalOptions", "Date", "addChangeListener", "removeChangeListener", "idx", "CookiesContext", "React", "UserNav", "dependencies", "allCookies", "setCookies", "previousCookiesRef", "onChange", "newCookies", "oldCookies", "dependencies_1", "dependency", "useCookies", "setCookie", "hostname", "window", "location", "host", "URLSearchParams", "search", "utm_campaign", "utm_source", "utm_medium", "utm_term", "utm_data", "referrer", "method", "placeholder", "id", "aria-hidden", "href", "user_nav", "cart_items", "avatar", "src", "alt", "querySelectorAll", "domContainer", "ReactDOM" ],
  "mappings": "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",
  "file": "UserNav.gc-widgets.js",
  "sourcesContent": [ " \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"https://files.grapecity.com/gc-forms/beta/js/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 4);\n", "export const EMPTY_OBJ = {};\nexport const EMPTY_ARR = [];\nexport const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\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\t_vnodeId: 0\n};\n\nexport default options;\n", "import options from './options';\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 > 3) {\n\t\tchildren = [children];\n\t\t// https://github.com/preactjs/preact/issues/1916\n\t\tfor (i = 3; i < arguments.length; i++) {\n\t\t\tchildren.push(arguments[i]);\n\t\t}\n\t}\n\tif (children != null) {\n\t\tnormalizedProps.children = 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 ? ++options._vnodeId : original\n\t};\n\n\tif (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) this._renderCallbacks.push(callback);\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\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);\n\t\tcommitRoot(commitQueue, vnode);\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 * Asynchronously schedule a callback\n * @type {(cb: () => void) => void}\n */\n/* istanbul ignore next */\n// Note the following line isn't tree-shaken by rollup cuz of rollup/rollup#2566\nconst defer =\n\ttypeof Promise == 'function'\n\t\t? Promise.prototype.then.bind(Promise.resolve())\n\t\t: setTimeout;\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\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/** Flush the render queue by rerendering all queued components */\nfunction process() {\n\tlet queue;\n\twhile ((process._rerenderCount = rerenderQueue.length)) {\n\t\tqueue = rerenderQueue.sort((a, b) => a._vnode._depth - b._vnode._depth);\n\t\trerenderQueue = [];\n\t\t// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary\n\t\t// process() calls from getting scheduled while `queue` is still being consumed.\n\t\tqueue.some(c => {\n\t\t\tif (c._dirty) renderComponent(c);\n\t\t});\n\t}\n}\nprocess._rerenderCount = 0;\n", "import { enqueueRender } from './component';\n\nexport let i = 0;\n\nexport function createContext(defaultValue, contextId) {\n\tcontextId = '__cC' + i++;\n\n\tconst context = {\n\t\t_id: contextId,\n\t\t_defaultValue: defaultValue,\n\t\t/** @type {import('./internal').FunctionComponent} */\n\t\tConsumer(props, contextValue) {\n\t\t\t// return props.children(\n\t\t\t// \tcontext[contextId] ? context[contextId].props.value : defaultValue\n\t\t\t// );\n\t\t\treturn props.children(contextValue);\n\t\t},\n\t\t/** @type {import('./internal').FunctionComponent} */\n\t\tProvider(props) {\n\t\t\tif (!this.getChildContext) {\n\t\t\t\tlet subs = [];\n\t\t\t\tlet ctx = {};\n\t\t\t\tctx[contextId] = this;\n\n\t\t\t\tthis.getChildContext = () => ctx;\n\n\t\t\t\tthis.shouldComponentUpdate = function(_props) {\n\t\t\t\t\tif (this.props.value !== _props.value) {\n\t\t\t\t\t\t// I think the forced value propagation here was only needed when `options.debounceRendering` was being bypassed:\n\t\t\t\t\t\t// https://github.com/preactjs/preact/commit/4d339fb803bea09e9f198abf38ca1bf8ea4b7771#diff-54682ce380935a717e41b8bfc54737f6R358\n\t\t\t\t\t\t// In those cases though, even with the value corrected, we're double-rendering all nodes.\n\t\t\t\t\t\t// It might be better to just tell folks not to use force-sync mode.\n\t\t\t\t\t\t// Currently, using `useContext()` in a class component will overwrite its `this.context` value.\n\t\t\t\t\t\t// subs.some(c => {\n\t\t\t\t\t\t// \tc.context = _props.value;\n\t\t\t\t\t\t// \tenqueueRender(c);\n\t\t\t\t\t\t// });\n\n\t\t\t\t\t\t// subs.some(c => {\n\t\t\t\t\t\t// \tc.context[contextId] = _props.value;\n\t\t\t\t\t\t// \tenqueueRender(c);\n\t\t\t\t\t\t// });\n\t\t\t\t\t\tsubs.some(enqueueRender);\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\tthis.sub = c => {\n\t\t\t\t\tsubs.push(c);\n\t\t\t\t\tlet old = c.componentWillUnmount;\n\t\t\t\t\tc.componentWillUnmount = () => {\n\t\t\t\t\t\tsubs.splice(subs.indexOf(c), 1);\n\t\t\t\t\t\tif (old) old.call(c);\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn props.children;\n\t\t}\n\t};\n\n\t// Devtools needs access to the context object when it\n\t// encounters a Provider. This is necessary to support\n\t// setting `displayName` on the context object instead\n\t// of on the component itself. See:\n\t// https://reactjs.org/docs/context.html#contextdisplayname\n\n\treturn (context.Provider._contextRef = context.Consumer.contextType = context);\n}\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\n/**\n * Check if two objects have a different shape\n * @param {object} a\n * @param {object} b\n * @returns {boolean}\n */\nexport function shallowDiffers(a, b) {\n\tfor (let i in a) if (i !== '__source' && !(i in b)) return true;\n\tfor (let i in b) if (i !== '__source' && a[i] !== b[i]) return true;\n\treturn false;\n}\n\nexport function removeNode(node) {\n\tlet parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n", "import { diff, unmount, applyRef } from './index';\nimport { createVNode, Fragment } from '../create-element';\nimport { EMPTY_OBJ, EMPTY_ARR } from '../constants';\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 */\nexport function diffChildren(\n\tparentDom,\n\trenderResult,\n\tnewParentVNode,\n\toldParentVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating\n) {\n\tlet i, j, oldVNode, childVNode, newDom, firstChildDom, refs;\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\n\tnewParentVNode._children = [];\n\tfor (i = 0; i < renderResult.length; i++) {\n\t\tchildVNode = renderResult[i];\n\n\t\tif (childVNode == null || typeof childVNode == 'boolean') {\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 (Array.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\tnull,\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\tcontinue;\n\t\t}\n\n\t\tchildVNode._parent = newParentVNode;\n\t\tchildVNode._depth = newParentVNode._depth + 1;\n\n\t\t// Check if we find a corresponding element in oldChildren.\n\t\t// If found, delete the array item by setting to `undefined`.\n\t\t// We use `undefined`, as `null` is reserved for empty placeholders\n\t\t// (holes).\n\t\toldVNode = oldChildren[i];\n\n\t\tif (\n\t\t\toldVNode === null ||\n\t\t\t(oldVNode &&\n\t\t\t\tchildVNode.key == oldVNode.key &&\n\t\t\t\tchildVNode.type === oldVNode.type)\n\t\t) {\n\t\t\toldChildren[i] = undefined;\n\t\t} else {\n\t\t\t// Either oldVNode === undefined or oldChildrenLength > 0,\n\t\t\t// so after this loop oldVNode == null or oldVNode is a valid value.\n\t\t\tfor (j = 0; j < oldChildrenLength; j++) {\n\t\t\t\toldVNode = oldChildren[j];\n\t\t\t\t// If childVNode is unkeyed, we only match similarly unkeyed nodes, otherwise we match by key.\n\t\t\t\t// We always match by type (in either case).\n\t\t\t\tif (\n\t\t\t\t\toldVNode &&\n\t\t\t\t\tchildVNode.key == oldVNode.key &&\n\t\t\t\t\tchildVNode.type === oldVNode.type\n\t\t\t\t) {\n\t\t\t\t\toldChildren[j] = undefined;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\toldVNode = null;\n\t\t\t}\n\t\t}\n\n\t\toldVNode = oldVNode || EMPTY_OBJ;\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);\n\n\t\tnewDom = childVNode._dom;\n\n\t\tif ((j = childVNode.ref) && oldVNode.ref != j) {\n\t\t\tif (!refs) refs = [];\n\t\t\tif (oldVNode.ref) refs.push(oldVNode.ref, null, childVNode);\n\t\t\trefs.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\tif (\n\t\t\t\ttypeof childVNode.type == 'function' &&\n\t\t\t\tchildVNode._children != null && // Can be null if childVNode suspended\n\t\t\t\tchildVNode._children === oldVNode._children\n\t\t\t) {\n\t\t\t\tchildVNode._nextDom = oldDom = reorderChildren(\n\t\t\t\t\tchildVNode,\n\t\t\t\t\toldDom,\n\t\t\t\t\tparentDom\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\toldDom = placeChild(\n\t\t\t\t\tparentDom,\n\t\t\t\t\tchildVNode,\n\t\t\t\t\toldVNode,\n\t\t\t\t\toldChildren,\n\t\t\t\t\tnewDom,\n\t\t\t\t\toldDom\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Browsers will infer an option's `value` from `textContent` when\n\t\t\t// no value is present. This essentially bypasses our code to set it\n\t\t\t// later in `diff()`. It works fine in all browsers except for IE11\n\t\t\t// where it breaks setting `select.value`. There it will be always set\n\t\t\t// to an empty string. Re-applying an options value will fix that, so\n\t\t\t// there are probably some internal data structures that aren't\n\t\t\t// updated properly.\n\t\t\t//\n\t\t\t// To fix it we make sure to reset the inferred value, so that our own\n\t\t\t// value check in `diff()` won't be skipped.\n\t\t\tif (!isHydrating && newParentVNode.type === 'option') {\n\t\t\t\t// @ts-ignore We have validated that the type of parentDOM is 'option'\n\t\t\t\t// in the above check\n\t\t\t\tparentDom.value = '';\n\t\t\t} else if (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} else if (\n\t\t\toldDom &&\n\t\t\toldVNode._dom == oldDom &&\n\t\t\toldDom.parentNode != parentDom\n\t\t) {\n\t\t\t// The above condition is to handle null placeholders. See test in placeholder.test.js:\n\t\t\t// `efficiently replace null placeholders in parent rerenders`\n\t\t\toldDom = getDomSibling(oldVNode);\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\t\t\t\tnewParentVNode._nextDom = getDomSibling(oldParentVNode, i + 1);\n\t\t\t}\n\n\t\t\tunmount(oldChildren[i], oldChildren[i]);\n\t\t}\n\t}\n\n\t// Set refs only after unmount\n\tif (refs) {\n\t\tfor (i = 0; i < refs.length; i++) {\n\t\t\tapplyRef(refs[i], refs[++i], refs[++i]);\n\t\t}\n\t}\n}\n\nfunction reorderChildren(childVNode, oldDom, parentDom) {\n\tfor (let tmp = 0; tmp < childVNode._children.length; tmp++) {\n\t\tlet vnode = childVNode._children[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(\n\t\t\t\t\tparentDom,\n\t\t\t\t\tvnode,\n\t\t\t\t\tvnode,\n\t\t\t\t\tchildVNode._children,\n\t\t\t\t\tvnode._dom,\n\t\t\t\t\toldDom\n\t\t\t\t);\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 (Array.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(\n\tparentDom,\n\tchildVNode,\n\toldVNode,\n\toldChildren,\n\tnewDom,\n\toldDom\n) {\n\tlet nextDom;\n\tif (childVNode._nextDom !== undefined) {\n\t\t// Only Fragments or components that return Fragment like VNodes will\n\t\t// have a non-undefined _nextDom. Continue the diff from the sibling\n\t\t// of last DOM child of this child VNode\n\t\tnextDom = childVNode._nextDom;\n\n\t\t// Eagerly cleanup _nextDom. We don't need to persist the value because\n\t\t// it is only used by `diffChildren` to determine where to resume the diff after\n\t\t// diffing Components and Fragments. Once we store it the nextDOM local var, we\n\t\t// can clean up the property\n\t\tchildVNode._nextDom = undefined;\n\t} else if (\n\t\toldVNode == null ||\n\t\tnewDom != oldDom ||\n\t\tnewDom.parentNode == null\n\t) {\n\t\touter: if (oldDom == null || oldDom.parentNode !== parentDom) {\n\t\t\tparentDom.appendChild(newDom);\n\t\t\tnextDom = null;\n\t\t} else {\n\t\t\t// `j<oldChildrenLength; j+=2` is an alternative to `j++<oldChildrenLength/2`\n\t\t\tfor (\n\t\t\t\tlet sibDom = oldDom, j = 0;\n\t\t\t\t(sibDom = sibDom.nextSibling) && j < oldChildren.length;\n\t\t\t\tj += 2\n\t\t\t) {\n\t\t\t\tif (sibDom == newDom) {\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\t\t\t}\n\t\t\tparentDom.insertBefore(newDom, oldDom);\n\t\t\tnextDom = oldDom;\n\t\t}\n\t}\n\n\t// If we have pre-calculated the nextDOM node, use it. Else calculate it now\n\t// Strictly check for `undefined` here cuz `null` is a valid value of `nextDom`.\n\t// See more detail in create-element.js:createVNode\n\tif (nextDom !== undefined) {\n\t\toldDom = nextDom;\n\t} else {\n\t\toldDom = newDom.nextSibling;\n\t}\n\n\treturn oldDom;\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);\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 !== '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 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-attributes have a different notion of boolean values.\n\t\t// The value `false` is different from the attribute not\n\t\t// existing on the DOM, so we can't remove it. For non-boolean\n\t\t// ARIA-attributes we could treat false as a removal, but the\n\t\t// amount of exceptions would cost us too many bytes. On top of\n\t\t// that other VDOM frameworks also always stringify `false`.\n\n\t\tif (typeof value === 'function') {\n\t\t\t// never serialize functions as attribute values\n\t\t} else if (\n\t\t\tvalue != null &&\n\t\t\t(value !== false || (name[0] === 'a' && name[1] === 'r'))\n\t\t) {\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\tthis._listeners[e.type + false](options.event ? options.event(e) : e);\n}\n\nfunction eventProxyCapture(e) {\n\tthis._listeners[e.type + true](options.event ? options.event(e) : e);\n}\n", "import { EMPTY_OBJ, EMPTY_ARR } from '../constants';\nimport { Component } from '../component';\nimport { Fragment } from '../create-element';\nimport { diffChildren } from './children';\nimport { diffProps, setProperty } from './props';\nimport { assign, removeNode } 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 */\nexport function diff(\n\tparentDom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating\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\ttry {\n\t\touter: if (typeof newType == 'function') {\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}\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\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\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\tc.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\tnewVNode._original === oldVNode._original\n\t\t\t\t) {\n\t\t\t\t\tc.props = newProps;\n\t\t\t\t\tc.state = c._nextState;\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) c._dirty = false;\n\t\t\t\t\tc._vnode = newVNode;\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\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.state = c._nextState;\n\n\t\t\tif ((tmp = options._render)) tmp(newVNode);\n\n\t\t\tc._dirty = false;\n\t\t\tc._vnode = newVNode;\n\t\t\tc._parentDom = parentDom;\n\n\t\t\ttmp = c.render(c.props, c.state, c.context);\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\tArray.isArray(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);\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\n\t\t\tc._force = false;\n\t\t} else if (\n\t\t\texcessDomChildren == null &&\n\t\t\tnewVNode._original === oldVNode._original\n\t\t) {\n\t\t\tnewVNode._children = oldVNode._children;\n\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t} else {\n\t\t\tnewVNode._dom = diffElementNodes(\n\t\t\t\toldVNode._dom,\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\tisHydrating\n\t\t\t);\n\t\t}\n\n\t\tif ((tmp = options.diffed)) tmp(newVNode);\n\t} catch (e) {\n\t\tnewVNode._original = null;\n\t\t// if hydrating or creating initial tree, bailout preserves DOM:\n\t\tif (isHydrating || excessDomChildren != null) {\n\t\t\tnewVNode._dom = oldDom;\n\t\t\tnewVNode._hydrating = !!isHydrating;\n\t\t\texcessDomChildren[excessDomChildren.indexOf(oldDom)] = null;\n\t\t\t// ^ could possibly be simplified to:\n\t\t\t// excessDomChildren.length = 0;\n\t\t}\n\t\toptions._catchError(e, newVNode, oldVNode);\n\t}\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) {\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 * @returns {import('../internal').PreactElement}\n */\nfunction diffElementNodes(\n\tdom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\tisHydrating\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(child === dom ||\n\t\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 =\n\t\t\texcessDomChildren && EMPTY_ARR.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 (let 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\tArray.isArray(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\tdom.firstChild,\n\t\t\t\tisHydrating\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 || (nodeType === 'progress' && !i))\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) applyRef(r, null, parentVNode);\n\t}\n\n\tlet dom;\n\tif (!skipRemove && typeof vnode.type != 'function') {\n\t\tskipRemove = (dom = vnode._dom) != null;\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._dom = vnode._nextDom = undefined;\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}\n\n\tif ((r = vnode._children)) {\n\t\tfor (let i = 0; i < r.length; i++) {\n\t\t\tif (r[i]) unmount(r[i], parentVNode, skipRemove);\n\t\t}\n\t}\n\n\tif (dom != null) removeNode(dom);\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 {\n\trender as preactRender,\n\thydrate as preactHydrate,\n\toptions,\n\ttoChildArray,\n\tComponent\n} from 'preact';\n\nexport const REACT_ELEMENT_TYPE =\n\t(typeof Symbol != 'undefined' && Symbol.for && Symbol.for('react.element')) ||\n\t0xeac7;\n\nconst CAMEL_PROPS = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;\n\n// Input types for which onchange should not be converted to oninput.\n// type=\"file|checkbox|radio\", plus \"range\" in IE11.\n// (IE11 doesn't support Symbol, which we use here to turn `rad` into `ra` which matches \"range\")\nconst onChangeInputType = type =>\n\t(typeof Symbol != 'undefined' && typeof Symbol() == 'symbol'\n\t\t? /fil|che|rad/i\n\t\t: /fil|che|ra/i\n\t).test(type);\n\n// Some libraries like `react-virtualized` explicitly check for this.\nComponent.prototype.isReactComponent = {};\n\n// `UNSAFE_*` lifecycle hooks\n// Preact only ever invokes the unprefixed methods.\n// Here we provide a base \"fallback\" implementation that calls any defined UNSAFE_ prefixed method.\n// - If a component defines its own `componentDidMount()` (including via defineProperty), use that.\n// - If a component defines `UNSAFE_componentDidMount()`, `componentDidMount` is the alias getter/setter.\n// - If anything assigns to an `UNSAFE_*` property, the assignment is forwarded to the unprefixed property.\n// See https://github.com/preactjs/preact/issues/1941\n[\n\t'componentWillMount',\n\t'componentWillReceiveProps',\n\t'componentWillUpdate'\n].forEach(key => {\n\tObject.defineProperty(Component.prototype, key, {\n\t\tconfigurable: true,\n\t\tget() {\n\t\t\treturn this['UNSAFE_' + key];\n\t\t},\n\t\tset(v) {\n\t\t\tObject.defineProperty(this, key, {\n\t\t\t\tconfigurable: true,\n\t\t\t\twritable: true,\n\t\t\t\tvalue: v\n\t\t\t});\n\t\t}\n\t});\n});\n\n/**\n * Proxy render() since React returns a Component reference.\n * @param {import('./internal').VNode} vnode VNode tree to render\n * @param {import('./internal').PreactElement} parent DOM node to render vnode tree into\n * @param {() => void} [callback] Optional callback that will be called after rendering\n * @returns {import('./internal').Component | null} The root component reference or null\n */\nexport function render(vnode, parent, callback) {\n\t// React destroys any existing DOM nodes, see #1727\n\t// ...but only on the first render, see #1828\n\tif (parent._children == null) {\n\t\tparent.textContent = '';\n\t}\n\n\tpreactRender(vnode, parent);\n\tif (typeof callback == 'function') callback();\n\n\treturn vnode ? vnode._component : null;\n}\n\nexport function hydrate(vnode, parent, callback) {\n\tpreactHydrate(vnode, parent);\n\tif (typeof callback == 'function') callback();\n\n\treturn vnode ? vnode._component : null;\n}\n\nlet oldEventHook = options.event;\noptions.event = e => {\n\tif (oldEventHook) e = oldEventHook(e);\n\te.persist = empty;\n\te.isPropagationStopped = isPropagationStopped;\n\te.isDefaultPrevented = isDefaultPrevented;\n\treturn (e.nativeEvent = e);\n};\n\nfunction empty() {}\n\nfunction isPropagationStopped() {\n\treturn this.cancelBubble;\n}\n\nfunction isDefaultPrevented() {\n\treturn this.defaultPrevented;\n}\n\nlet classNameDescriptor = {\n\tconfigurable: true,\n\tget() {\n\t\treturn this.class;\n\t}\n};\n\nlet oldVNodeHook = options.vnode;\noptions.vnode = vnode => {\n\tlet type = vnode.type;\n\tlet props = vnode.props;\n\tlet normalizedProps = props;\n\n\t// only normalize props on Element nodes\n\tif (typeof type === 'string') {\n\t\tnormalizedProps = {};\n\n\t\tfor (let i in props) {\n\t\t\tlet value = props[i];\n\n\t\t\tif (i === 'value' && 'defaultValue' in props && value == null) {\n\t\t\t\t// Skip applying value if it is null/undefined and we already set\n\t\t\t\t// a default value\n\t\t\t\tcontinue;\n\t\t\t} else if (\n\t\t\t\ti === 'defaultValue' &&\n\t\t\t\t'value' in props &&\n\t\t\t\tprops.value == null\n\t\t\t) {\n\t\t\t\t// `defaultValue` is treated as a fallback `value` when a value prop is present but null/undefined.\n\t\t\t\t// `defaultValue` for Elements with no value prop is the same as the DOM defaultValue property.\n\t\t\t\ti = 'value';\n\t\t\t} else if (i === 'download' && value === true) {\n\t\t\t\t// Calling `setAttribute` with a truthy value will lead to it being\n\t\t\t\t// passed as a stringified value, e.g. `download=\"true\"`. React\n\t\t\t\t// converts it to an empty string instead, otherwise the attribute\n\t\t\t\t// value will be used as the file name and the file will be called\n\t\t\t\t// \"true\" upon downloading it.\n\t\t\t\tvalue = '';\n\t\t\t} else if (/ondoubleclick/i.test(i)) {\n\t\t\t\ti = 'ondblclick';\n\t\t\t} else if (\n\t\t\t\t/^onchange(textarea|input)/i.test(i + type) &&\n\t\t\t\t!onChangeInputType(props.type)\n\t\t\t) {\n\t\t\t\ti = 'oninput';\n\t\t\t} else if (/^on(Ani|Tra|Tou|BeforeInp)/.test(i)) {\n\t\t\t\ti = i.toLowerCase();\n\t\t\t} else if (CAMEL_PROPS.test(i)) {\n\t\t\t\ti = i.replace(/[A-Z0-9]/, '-$&').toLowerCase();\n\t\t\t} else if (value === null) {\n\t\t\t\tvalue = undefined;\n\t\t\t}\n\n\t\t\tnormalizedProps[i] = value;\n\t\t}\n\n\t\t// Add support for array select values: <select multiple value={[]} />\n\t\tif (\n\t\t\ttype == 'select' &&\n\t\t\tnormalizedProps.multiple &&\n\t\t\tArray.isArray(normalizedProps.value)\n\t\t) {\n\t\t\t// forEach() always returns undefined, which we abuse here to unset the value prop.\n\t\t\tnormalizedProps.value = toChildArray(props.children).forEach(child => {\n\t\t\t\tchild.props.selected =\n\t\t\t\t\tnormalizedProps.value.indexOf(child.props.value) != -1;\n\t\t\t});\n\t\t}\n\n\t\t// Adding support for defaultValue in select tag\n\t\tif (type == 'select' && normalizedProps.defaultValue != null) {\n\t\t\tnormalizedProps.value = toChildArray(props.children).forEach(child => {\n\t\t\t\tif (normalizedProps.multiple) {\n\t\t\t\t\tchild.props.selected =\n\t\t\t\t\t\tnormalizedProps.defaultValue.indexOf(child.props.value) != -1;\n\t\t\t\t} else {\n\t\t\t\t\tchild.props.selected =\n\t\t\t\t\t\tnormalizedProps.defaultValue == child.props.value;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tvnode.props = normalizedProps;\n\t}\n\n\tif (type && props.class != props.className) {\n\t\tclassNameDescriptor.enumerable = 'className' in props;\n\t\tif (props.className != null) normalizedProps.class = props.className;\n\t\tObject.defineProperty(normalizedProps, 'className', classNameDescriptor);\n\t}\n\n\tvnode.$$typeof = REACT_ELEMENT_TYPE;\n\n\tif (oldVNodeHook) oldVNodeHook(vnode);\n};\n\n// Only needed for react-relay\nlet currentComponent;\nconst oldBeforeRender = options._render;\noptions._render = function(vnode) {\n\tif (oldBeforeRender) {\n\t\toldBeforeRender(vnode);\n\t}\n\tcurrentComponent = vnode._component;\n};\n\n// This is a very very private internal function for React it\n// is used to sort-of do runtime dependency injection. So far\n// only `react-relay` makes use of it. It uses it to read the\n// context value.\nexport const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {\n\tReactCurrentDispatcher: {\n\t\tcurrent: {\n\t\t\treadContext(context) {\n\t\t\t\treturn currentComponent._globalContext[context._id].props.value;\n\t\t\t}\n\t\t}\n\t}\n};\n", "import { assign } from './util';\nimport { createVNode } from './create-element';\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {import('./internal').VNode} vnode The virtual DOM element to clone\n * @param {object} props Attributes/props to add when cloning\n * @param {Array<import('./internal').ComponentChildren>} rest Any additional arguments will be used as replacement children.\n * @returns {import('./internal').VNode}\n */\nexport function cloneElement(vnode, props, children) {\n\tlet normalizedProps = assign({}, vnode.props),\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 > 3) {\n\t\tchildren = [children];\n\t\tfor (i = 3; i < arguments.length; i++) {\n\t\t\tchildren.push(arguments[i]);\n\t\t}\n\t}\n\tif (children != null) {\n\t\tnormalizedProps.children = children;\n\t}\n\n\treturn createVNode(\n\t\tvnode.type,\n\t\tnormalizedProps,\n\t\tkey || vnode.key,\n\t\tref || vnode.ref,\n\t\tnull\n\t);\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 */\nexport function _catchError(error, vnode) {\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);\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", "export * from 'preact/jsx-runtime';\n", "/*!\n * cookie\n * Copyright(c) 2012-2014 Roman Shtylman\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module exports.\n * @public\n */\n\nexports.parse = parse;\nexports.serialize = serialize;\n\n/**\n * Module variables.\n * @private\n */\n\nvar decode = decodeURIComponent;\nvar encode = encodeURIComponent;\nvar pairSplitRegExp = /; */;\n\n/**\n * RegExp to match field-content in RFC 7230 sec 3.2\n *\n * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]\n * field-vchar   = VCHAR / obs-text\n * obs-text      = %x80-FF\n */\n\nvar fieldContentRegExp = /^[\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+$/;\n\n/**\n * Parse a cookie header.\n *\n * Parse the given cookie header string into an object\n * The object has the various cookies as keys(names) => values\n *\n * @param {string} str\n * @param {object} [options]\n * @return {object}\n * @public\n */\n\nfunction parse(str, options) {\n  if (typeof str !== 'string') {\n    throw new TypeError('argument str must be a string');\n  }\n\n  var obj = {}\n  var opt = options || {};\n  var pairs = str.split(pairSplitRegExp);\n  var dec = opt.decode || decode;\n\n  for (var i = 0; i < pairs.length; i++) {\n    var pair = pairs[i];\n    var eq_idx = pair.indexOf('=');\n\n    // skip things that don't look like key=value\n    if (eq_idx < 0) {\n      continue;\n    }\n\n    var key = pair.substr(0, eq_idx).trim()\n    var val = pair.substr(++eq_idx, pair.length).trim();\n\n    // quoted values\n    if ('\"' == val[0]) {\n      val = val.slice(1, -1);\n    }\n\n    // only assign once\n    if (undefined == obj[key]) {\n      obj[key] = tryDecode(val, dec);\n    }\n  }\n\n  return obj;\n}\n\n/**\n * Serialize data into a cookie header.\n *\n * Serialize the a name value pair into a cookie string suitable for\n * http headers. An optional options object specified cookie parameters.\n *\n * serialize('foo', 'bar', { httpOnly: true })\n *   => \"foo=bar; httpOnly\"\n *\n * @param {string} name\n * @param {string} val\n * @param {object} [options]\n * @return {string}\n * @public\n */\n\nfunction serialize(name, val, options) {\n  var opt = options || {};\n  var enc = opt.encode || encode;\n\n  if (typeof enc !== 'function') {\n    throw new TypeError('option encode is invalid');\n  }\n\n  if (!fieldContentRegExp.test(name)) {\n    throw new TypeError('argument name is invalid');\n  }\n\n  var value = enc(val);\n\n  if (value && !fieldContentRegExp.test(value)) {\n    throw new TypeError('argument val is invalid');\n  }\n\n  var str = name + '=' + value;\n\n  if (null != opt.maxAge) {\n    var maxAge = opt.maxAge - 0;\n    if (isNaN(maxAge)) throw new Error('maxAge should be a Number');\n    str += '; Max-Age=' + Math.floor(maxAge);\n  }\n\n  if (opt.domain) {\n    if (!fieldContentRegExp.test(opt.domain)) {\n      throw new TypeError('option domain is invalid');\n    }\n\n    str += '; Domain=' + opt.domain;\n  }\n\n  if (opt.path) {\n    if (!fieldContentRegExp.test(opt.path)) {\n      throw new TypeError('option path is invalid');\n    }\n\n    str += '; Path=' + opt.path;\n  }\n\n  if (opt.expires) {\n    if (typeof opt.expires.toUTCString !== 'function') {\n      throw new TypeError('option expires is invalid');\n    }\n\n    str += '; Expires=' + opt.expires.toUTCString();\n  }\n\n  if (opt.httpOnly) {\n    str += '; HttpOnly';\n  }\n\n  if (opt.secure) {\n    str += '; Secure';\n  }\n\n  if (opt.sameSite) {\n    var sameSite = typeof opt.sameSite === 'string'\n      ? opt.sameSite.toLowerCase() : opt.sameSite;\n\n    switch (sameSite) {\n      case true:\n        str += '; SameSite=Strict';\n        break;\n      case 'lax':\n        str += '; SameSite=Lax';\n        break;\n      case 'strict':\n        str += '; SameSite=Strict';\n        break;\n      case 'none':\n        str += '; SameSite=None';\n        break;\n      default:\n        throw new TypeError('option sameSite is invalid');\n    }\n  }\n\n  return str;\n}\n\n/**\n * Try decoding a string using a decoding function.\n *\n * @param {string} str\n * @param {function} decode\n * @private\n */\n\nfunction tryDecode(str, decode) {\n  try {\n    return decode(str);\n  } catch (e) {\n    return str;\n  }\n}\n", "import {\n\tcreateElement,\n\trender as preactRender,\n\tcloneElement as preactCloneElement,\n\tcreateRef,\n\tComponent,\n\tcreateContext,\n\tFragment\n} from 'preact';\nimport {\n\tuseState,\n\tuseReducer,\n\tuseEffect,\n\tuseLayoutEffect,\n\tuseRef,\n\tuseImperativeHandle,\n\tuseMemo,\n\tuseCallback,\n\tuseContext,\n\tuseDebugValue\n} from 'preact/hooks';\nimport { PureComponent } from './PureComponent';\nimport { memo } from './memo';\nimport { forwardRef } from './forwardRef';\nimport { Children } from './Children';\nimport { Suspense, lazy } from './suspense';\nimport { SuspenseList } from './suspense-list';\nimport { createPortal } from './portals';\nimport {\n\thydrate,\n\trender,\n\tREACT_ELEMENT_TYPE,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\n} from './render';\nexport * from './scheduler';\n\nconst version = '16.8.0'; // trick libraries to think we are react\n\n/**\n * Legacy version of createElement.\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component constructor\n */\nfunction createFactory(type) {\n\treturn createElement.bind(null, type);\n}\n\n/**\n * Check if the passed element is a valid (p)react node.\n * @param {*} element The element to check\n * @returns {boolean}\n */\nfunction isValidElement(element) {\n\treturn !!element && element.$$typeof === REACT_ELEMENT_TYPE;\n}\n\n/**\n * Wrap `cloneElement` to abort if the passed element is not a valid element and apply\n * all vnode normalizations.\n * @param {import('./internal').VNode} element The vnode to clone\n * @param {object} props Props to add when cloning\n * @param {Array<import('./internal').ComponentChildren>} rest Optional component children\n */\nfunction cloneElement(element) {\n\tif (!isValidElement(element)) return element;\n\treturn preactCloneElement.apply(null, arguments);\n}\n\n/**\n * Remove a component tree from the DOM, including state and event handlers.\n * @param {import('./internal').PreactElement} container\n * @returns {boolean}\n */\nfunction unmountComponentAtNode(container) {\n\tif (container._children) {\n\t\tpreactRender(null, container);\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/**\n * Get the matching DOM node for a component\n * @param {import('./internal').Component} component\n * @returns {import('./internal').PreactElement | null}\n */\nfunction findDOMNode(component) {\n\treturn (\n\t\t(component &&\n\t\t\t(component.base || (component.nodeType === 1 && component))) ||\n\t\tnull\n\t);\n}\n\n/**\n * Deprecated way to control batched rendering inside the reconciler, but we\n * already schedule in batches inside our rendering code\n * @template Arg\n * @param {(arg: Arg) => void} callback function that triggers the updated\n * @param {Arg} [arg] Optional argument that can be passed to the callback\n */\n// eslint-disable-next-line camelcase\nconst unstable_batchedUpdates = (callback, arg) => callback(arg);\n\n/**\n * Strict Mode is not implemented in Preact, so we provide a stand-in for it\n * that just renders its children without imposing any restrictions.\n */\nconst StrictMode = Fragment;\n\nexport * from 'preact/hooks';\nexport {\n\tversion,\n\tChildren,\n\trender,\n\thydrate,\n\tunmountComponentAtNode,\n\tcreatePortal,\n\tcreateElement,\n\tcreateContext,\n\tcreateFactory,\n\tcloneElement,\n\tcreateRef,\n\tFragment,\n\tisValidElement,\n\tfindDOMNode,\n\tComponent,\n\tPureComponent,\n\tmemo,\n\tforwardRef,\n\t// eslint-disable-next-line camelcase\n\tunstable_batchedUpdates,\n\tStrictMode,\n\tSuspense,\n\tSuspenseList,\n\tlazy,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\n};\n\n// React copies the named exports to the default one.\nexport default {\n\tuseState,\n\tuseReducer,\n\tuseEffect,\n\tuseLayoutEffect,\n\tuseRef,\n\tuseImperativeHandle,\n\tuseMemo,\n\tuseCallback,\n\tuseContext,\n\tuseDebugValue,\n\tversion,\n\tChildren,\n\trender,\n\thydrate,\n\tunmountComponentAtNode,\n\tcreatePortal,\n\tcreateElement,\n\tcreateContext,\n\tcreateFactory,\n\tcloneElement,\n\tcreateRef,\n\tFragment,\n\tisValidElement,\n\tfindDOMNode,\n\tComponent,\n\tPureComponent,\n\tmemo,\n\tforwardRef,\n\tunstable_batchedUpdates,\n\tStrictMode,\n\tSuspense,\n\tSuspenseList,\n\tlazy,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\n};\n", "import { Component } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Component class with a predefined `shouldComponentUpdate` implementation\n */\nexport function PureComponent(p) {\n\tthis.props = p;\n}\nPureComponent.prototype = new Component();\n// Some third-party libraries check if this property is present\nPureComponent.prototype.isPureReactComponent = true;\nPureComponent.prototype.shouldComponentUpdate = function(props, state) {\n\treturn shallowDiffers(this.props, props) || shallowDiffers(this.state, state);\n};\n", "import { options } from 'preact';\nimport { assign } from './util';\n\nlet oldDiffHook = options._diff;\noptions._diff = vnode => {\n\tif (vnode.type && vnode.type._forwarded && vnode.ref) {\n\t\tvnode.props.ref = vnode.ref;\n\t\tvnode.ref = null;\n\t}\n\tif (oldDiffHook) oldDiffHook(vnode);\n};\n\nexport const REACT_FORWARD_SYMBOL =\n\t(typeof Symbol != 'undefined' &&\n\t\tSymbol.for &&\n\t\tSymbol.for('react.forward_ref')) ||\n\t0xf47;\n\n/**\n * Pass ref down to a child. This is mainly used in libraries with HOCs that\n * wrap components. Using `forwardRef` there is an easy way to get a reference\n * of the wrapped component instead of one of the wrapper itself.\n * @param {import('./index').ForwardFn} fn\n * @returns {import('./internal').FunctionComponent}\n */\nexport function forwardRef(fn) {\n\t// We always have ref in props.ref, except for\n\t// mobx-react. It will call this function directly\n\t// and always pass ref as the second argument.\n\tfunction Forwarded(props, ref) {\n\t\tlet clone = assign({}, props);\n\t\tdelete clone.ref;\n\t\tref = props.ref || ref;\n\t\treturn fn(\n\t\t\tclone,\n\t\t\t!ref || (typeof ref === 'object' && !('current' in ref)) ? null : ref\n\t\t);\n\t}\n\n\t// mobx-react checks for this being present\n\tForwarded.$$typeof = REACT_FORWARD_SYMBOL;\n\t// mobx-react heavily relies on implementation details.\n\t// It expects an object here with a `render` property,\n\t// and prototype.render will fail. Without this\n\t// mobx-react throws.\n\tForwarded.render = Forwarded;\n\n\tForwarded.prototype.isReactComponent = Forwarded._forwarded = true;\n\tForwarded.displayName = 'ForwardRef(' + (fn.displayName || fn.name) + ')';\n\treturn Forwarded;\n}\n", "import { toChildArray } from 'preact';\n\nconst mapFn = (children, fn) => {\n\tif (children == null) return null;\n\treturn toChildArray(toChildArray(children).map(fn));\n};\n\n// This API is completely unnecessary for Preact, so it's basically passthrough.\nexport const Children = {\n\tmap: mapFn,\n\tforEach: mapFn,\n\tcount(children) {\n\t\treturn children ? toChildArray(children).length : 0;\n\t},\n\tonly(children) {\n\t\tconst normalized = toChildArray(children);\n\t\tif (normalized.length !== 1) throw 'Children.only';\n\t\treturn normalized[0];\n\t},\n\ttoArray: toChildArray\n};\n", "import { Component, createElement, options, Fragment } from 'preact';\nimport { assign } from './util';\n\nconst oldCatchError = options._catchError;\noptions._catchError = function(error, newVNode, oldVNode) {\n\tif (error.then) {\n\t\t/** @type {import('./internal').Component} */\n\t\tlet component;\n\t\tlet vnode = newVNode;\n\n\t\tfor (; (vnode = vnode._parent); ) {\n\t\t\tif ((component = vnode._component) && component._childDidSuspend) {\n\t\t\t\tif (newVNode._dom == null) {\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t}\n\t\t\t\t// Don't call oldCatchError if we found a Suspense\n\t\t\t\treturn component._childDidSuspend(error, newVNode);\n\t\t\t}\n\t\t}\n\t}\n\toldCatchError(error, newVNode, oldVNode);\n};\n\nconst oldUnmount = options.unmount;\noptions.unmount = function(vnode) {\n\t/** @type {import('./internal').Component} */\n\tconst component = vnode._component;\n\tif (component && component._onResolve) {\n\t\tcomponent._onResolve();\n\t}\n\n\t// if the component is still hydrating\n\t// most likely it is because the component is suspended\n\t// we set the vnode.type as `null` so that it is not a typeof function\n\t// so the unmount will remove the vnode._dom\n\tif (component && vnode._hydrating === true) {\n\t\tvnode.type = null;\n\t}\n\n\tif (oldUnmount) oldUnmount(vnode);\n};\n\nfunction detachedClone(vnode, detachedParent, parentDom) {\n\tif (vnode) {\n\t\tif (vnode._component && vnode._component.__hooks) {\n\t\t\tvnode._component.__hooks._list.forEach(effect => {\n\t\t\t\tif (typeof effect._cleanup == 'function') effect._cleanup();\n\t\t\t});\n\n\t\t\tvnode._component.__hooks = null;\n\t\t}\n\n\t\tvnode = assign({}, vnode);\n\t\tif (vnode._component != null) {\n\t\t\tif (vnode._component._parentDom === parentDom) {\n\t\t\t\tvnode._component._parentDom = detachedParent;\n\t\t\t}\n\t\t\tvnode._component = null;\n\t\t}\n\n\t\tvnode._children =\n\t\t\tvnode._children &&\n\t\t\tvnode._children.map(child =>\n\t\t\t\tdetachedClone(child, detachedParent, parentDom)\n\t\t\t);\n\t}\n\n\treturn vnode;\n}\n\nfunction removeOriginal(vnode, detachedParent, originalParent) {\n\tif (vnode) {\n\t\tvnode._original = null;\n\t\tvnode._children =\n\t\t\tvnode._children &&\n\t\t\tvnode._children.map(child =>\n\t\t\t\tremoveOriginal(child, detachedParent, originalParent)\n\t\t\t);\n\n\t\tif (vnode._component) {\n\t\t\tif (vnode._component._parentDom === detachedParent) {\n\t\t\t\tif (vnode._dom) {\n\t\t\t\t\toriginalParent.insertBefore(vnode._dom, vnode._nextDom);\n\t\t\t\t}\n\t\t\t\tvnode._component._force = true;\n\t\t\t\tvnode._component._parentDom = originalParent;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn vnode;\n}\n\n// having custom inheritance instead of a class here saves a lot of bytes\nexport function Suspense() {\n\t// we do not call super here to golf some bytes...\n\tthis._pendingSuspensionCount = 0;\n\tthis._suspenders = null;\n\tthis._detachOnNextRender = null;\n}\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspense.prototype = new Component();\n\n/**\n * @this {import('./internal').SuspenseComponent}\n * @param {Promise} promise The thrown promise\n * @param {import('./internal').VNode<any, any>} suspendingVNode The suspending component\n */\nSuspense.prototype._childDidSuspend = function(promise, suspendingVNode) {\n\tconst suspendingComponent = suspendingVNode._component;\n\n\t/** @type {import('./internal').SuspenseComponent} */\n\tconst c = this;\n\n\tif (c._suspenders == null) {\n\t\tc._suspenders = [];\n\t}\n\tc._suspenders.push(suspendingComponent);\n\n\tconst resolve = suspended(c._vnode);\n\n\tlet resolved = false;\n\tconst onResolved = () => {\n\t\tif (resolved) return;\n\n\t\tresolved = true;\n\t\tsuspendingComponent._onResolve = null;\n\n\t\tif (resolve) {\n\t\t\tresolve(onSuspensionComplete);\n\t\t} else {\n\t\t\tonSuspensionComplete();\n\t\t}\n\t};\n\n\tsuspendingComponent._onResolve = onResolved;\n\n\tconst onSuspensionComplete = () => {\n\t\tif (!--c._pendingSuspensionCount) {\n\t\t\t// If the suspension was during hydration we don't need to restore the\n\t\t\t// suspended children into the _children array\n\t\t\tif (c.state._suspended) {\n\t\t\t\tconst suspendedVNode = c.state._suspended;\n\t\t\t\tc._vnode._children[0] = removeOriginal(\n\t\t\t\t\tsuspendedVNode,\n\t\t\t\t\tsuspendedVNode._component._parentDom,\n\t\t\t\t\tsuspendedVNode._component._originalParentDom\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tc.setState({ _suspended: (c._detachOnNextRender = null) });\n\n\t\t\tlet suspended;\n\t\t\twhile ((suspended = c._suspenders.pop())) {\n\t\t\t\tsuspended.forceUpdate();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * We do not set `suspended: true` during hydration because we want the actual markup\n\t * to remain on screen and hydrate it when the suspense actually gets resolved.\n\t * While in non-hydration cases the usual fallback -> component flow would occour.\n\t */\n\tconst wasHydrating = suspendingVNode._hydrating === true;\n\tif (!c._pendingSuspensionCount++ && !wasHydrating) {\n\t\tc.setState({ _suspended: (c._detachOnNextRender = c._vnode._children[0]) });\n\t}\n\tpromise.then(onResolved, onResolved);\n};\n\nSuspense.prototype.componentWillUnmount = function() {\n\tthis._suspenders = [];\n};\n\n/**\n * @this {import('./internal').SuspenseComponent}\n * @param {import('./internal').SuspenseComponent[\"props\"]} props\n * @param {import('./internal').SuspenseState} state\n */\nSuspense.prototype.render = function(props, state) {\n\tif (this._detachOnNextRender) {\n\t\t// When the Suspense's _vnode was created by a call to createVNode\n\t\t// (i.e. due to a setState further up in the tree)\n\t\t// it's _children prop is null, in this case we \"forget\" about the parked vnodes to detach\n\t\tif (this._vnode._children) {\n\t\t\tconst detachedParent = document.createElement('div');\n\t\t\tconst detachedComponent = this._vnode._children[0]._component;\n\t\t\tthis._vnode._children[0] = detachedClone(\n\t\t\t\tthis._detachOnNextRender,\n\t\t\t\tdetachedParent,\n\t\t\t\t(detachedComponent._originalParentDom = detachedComponent._parentDom)\n\t\t\t);\n\t\t}\n\n\t\tthis._detachOnNextRender = null;\n\t}\n\n\t// Wrap fallback tree in a VNode that prevents itself from being marked as aborting mid-hydration:\n\t/** @type {import('./internal').VNode} */\n\tconst fallback =\n\t\tstate._suspended && createElement(Fragment, null, props.fallback);\n\tif (fallback) fallback._hydrating = null;\n\n\treturn [\n\t\tcreateElement(Fragment, null, state._suspended ? null : props.children),\n\t\tfallback\n\t];\n};\n\n/**\n * Checks and calls the parent component's _suspended method, passing in the\n * suspended vnode. This is a way for a parent (e.g. SuspenseList) to get notified\n * that one of its children/descendants suspended.\n *\n * The parent MAY return a callback. The callback will get called when the\n * suspension resolves, notifying the parent of the fact.\n * Moreover, the callback gets function `unsuspend` as a parameter. The resolved\n * child descendant will not actually get unsuspended until `unsuspend` gets called.\n * This is a way for the parent to delay unsuspending.\n *\n * If the parent does not return a callback then the resolved vnode\n * gets unsuspended immediately when it resolves.\n *\n * @param {import('./internal').VNode} vnode\n * @returns {((unsuspend: () => void) => void)?}\n */\nexport function suspended(vnode) {\n\t/** @type {import('./internal').Component} */\n\tlet component = vnode._parent._component;\n\treturn component && component._suspended && component._suspended(vnode);\n}\n\nexport function lazy(loader) {\n\tlet prom;\n\tlet component;\n\tlet error;\n\n\tfunction Lazy(props) {\n\t\tif (!prom) {\n\t\t\tprom = loader();\n\t\t\tprom.then(\n\t\t\t\texports => {\n\t\t\t\t\tcomponent = exports.default || exports;\n\t\t\t\t},\n\t\t\t\te => {\n\t\t\t\t\terror = e;\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\n\t\tif (error) {\n\t\t\tthrow error;\n\t\t}\n\n\t\tif (!component) {\n\t\t\tthrow prom;\n\t\t}\n\n\t\treturn createElement(component, props);\n\t}\n\n\tLazy.displayName = 'Lazy';\n\tLazy._forwarded = true;\n\treturn Lazy;\n}\n", "import { Component, toChildArray } from 'preact';\nimport { suspended } from './suspense.js';\n\n// Indexes to linked list nodes (nodes are stored as arrays to save bytes).\nconst SUSPENDED_COUNT = 0;\nconst RESOLVED_COUNT = 1;\nconst NEXT_NODE = 2;\n\n// Having custom inheritance instead of a class here saves a lot of bytes.\nexport function SuspenseList() {\n\tthis._next = null;\n\tthis._map = null;\n}\n\n// Mark one of child's earlier suspensions as resolved.\n// Some pending callbacks may become callable due to this\n// (e.g. the last suspended descendant gets resolved when\n// revealOrder === 'together'). Process those callbacks as well.\nconst resolve = (list, child, node) => {\n\tif (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {\n\t\t// The number a child (or any of its descendants) has been suspended\n\t\t// matches the number of times it's been resolved. Therefore we\n\t\t// mark the child as completely resolved by deleting it from ._map.\n\t\t// This is used to figure out when *all* children have been completely\n\t\t// resolved when revealOrder is 'together'.\n\t\tlist._map.delete(child);\n\t}\n\n\t// If revealOrder is falsy then we can do an early exit, as the\n\t// callbacks won't get queued in the node anyway.\n\t// If revealOrder is 'together' then also do an early exit\n\t// if all suspended descendants have not yet been resolved.\n\tif (\n\t\t!list.props.revealOrder ||\n\t\t(list.props.revealOrder[0] === 't' && list._map.size)\n\t) {\n\t\treturn;\n\t}\n\n\t// Walk the currently suspended children in order, calling their\n\t// stored callbacks on the way. Stop if we encounter a child that\n\t// has not been completely resolved yet.\n\tnode = list._next;\n\twhile (node) {\n\t\twhile (node.length > 3) {\n\t\t\tnode.pop()();\n\t\t}\n\t\tif (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {\n\t\t\tbreak;\n\t\t}\n\t\tlist._next = node = node[NEXT_NODE];\n\t}\n};\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspenseList.prototype = new Component();\n\nSuspenseList.prototype._suspended = function(child) {\n\tconst list = this;\n\tconst delegated = suspended(list._vnode);\n\n\tlet node = list._map.get(child);\n\tnode[SUSPENDED_COUNT]++;\n\n\treturn unsuspend => {\n\t\tconst wrappedUnsuspend = () => {\n\t\t\tif (!list.props.revealOrder) {\n\t\t\t\t// Special case the undefined (falsy) revealOrder, as there\n\t\t\t\t// is no need to coordinate a specific order or unsuspends.\n\t\t\t\tunsuspend();\n\t\t\t} else {\n\t\t\t\tnode.push(unsuspend);\n\t\t\t\tresolve(list, child, node);\n\t\t\t}\n\t\t};\n\t\tif (delegated) {\n\t\t\tdelegated(wrappedUnsuspend);\n\t\t} else {\n\t\t\twrappedUnsuspend();\n\t\t}\n\t};\n};\n\nSuspenseList.prototype.render = function(props) {\n\tthis._next = null;\n\tthis._map = new Map();\n\n\tconst children = toChildArray(props.children);\n\tif (props.revealOrder && props.revealOrder[0] === 'b') {\n\t\t// If order === 'backwards' (or, well, anything starting with a 'b')\n\t\t// then flip the child list around so that the last child will be\n\t\t// the first in the linked list.\n\t\tchildren.reverse();\n\t}\n\t// Build the linked list. Iterate through the children in reverse order\n\t// so that `_next` points to the first linked list node to be resolved.\n\tfor (let i = children.length; i--; ) {\n\t\t// Create a new linked list node as an array of form:\n\t\t// \t[suspended_count, resolved_count, next_node]\n\t\t// where suspended_count and resolved_count are numeric counters for\n\t\t// keeping track how many times a node has been suspended and resolved.\n\t\t//\n\t\t// Note that suspended_count starts from 1 instead of 0, so we can block\n\t\t// processing callbacks until componentDidMount has been called. In a sense\n\t\t// node is suspended at least until componentDidMount gets called!\n\t\t//\n\t\t// Pending callbacks are added to the end of the node:\n\t\t// \t[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]\n\t\tthis._map.set(children[i], (this._next = [1, 0, this._next]));\n\t}\n\treturn props.children;\n};\n\nSuspenseList.prototype.componentDidUpdate = SuspenseList.prototype.componentDidMount = function() {\n\t// Iterate through all children after mounting for two reasons:\n\t// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases\n\t//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.\n\t//    The nodes can now be completely consumed from the linked list.\n\t// 2. Handle nodes that might have gotten resolved between render and\n\t//    componentDidMount.\n\tthis._map.forEach((node, child) => {\n\t\tresolve(this, child, node);\n\t});\n};\n", "import { createElement, render } from 'preact';\n\n/**\n * @param {import('../../src/index').RenderableProps<{ context: any }>} props\n */\nfunction ContextProvider(props) {\n\tthis.getChildContext = () => props.context;\n\treturn props.children;\n}\n\n/**\n * Portal component\n * @this {import('./internal').Component}\n * @param {object | null | undefined} props\n *\n * TODO: use createRoot() instead of fake root\n */\nfunction Portal(props) {\n\tconst _this = this;\n\tlet container = props._container;\n\n\t_this.componentWillUnmount = function() {\n\t\trender(null, _this._temp);\n\t\t_this._temp = null;\n\t\t_this._container = null;\n\t};\n\n\t// When we change container we should clear our old container and\n\t// indicate a new mount.\n\tif (_this._container && _this._container !== container) {\n\t\t_this.componentWillUnmount();\n\t}\n\n\t// When props.vnode is undefined/false/null we are dealing with some kind of\n\t// conditional vnode. This should not trigger a render.\n\tif (props._vnode) {\n\t\tif (!_this._temp) {\n\t\t\t_this._container = container;\n\n\t\t\t// Create a fake DOM parent node that manages a subset of `container`'s children:\n\t\t\t_this._temp = {\n\t\t\t\tnodeType: 1,\n\t\t\t\tparentNode: container,\n\t\t\t\tchildNodes: [],\n\t\t\t\tappendChild(child) {\n\t\t\t\t\tthis.childNodes.push(child);\n\t\t\t\t\t_this._container.appendChild(child);\n\t\t\t\t},\n\t\t\t\tinsertBefore(child, before) {\n\t\t\t\t\tthis.childNodes.push(child);\n\t\t\t\t\t_this._container.appendChild(child);\n\t\t\t\t},\n\t\t\t\tremoveChild(child) {\n\t\t\t\t\tthis.childNodes.splice(this.childNodes.indexOf(child) >>> 1, 1);\n\t\t\t\t\t_this._container.removeChild(child);\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\n\t\t// Render our wrapping element into temp.\n\t\trender(\n\t\t\tcreateElement(ContextProvider, { context: _this.context }, props._vnode),\n\t\t\t_this._temp\n\t\t);\n\t}\n\t// When we come from a conditional render, on a mounted\n\t// portal we should clear the DOM.\n\telse if (_this._temp) {\n\t\t_this.componentWillUnmount();\n\t}\n}\n\n/**\n * Create a `Portal` to continue rendering the vnode tree at a different DOM node\n * @param {import('./internal').VNode} vnode The vnode to render\n * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.\n */\nexport function createPortal(vnode, container) {\n\treturn createElement(Portal, { _vnode: vnode, _container: container });\n}\n", "// This file includes experimental React APIs exported from the \"scheduler\"\n// npm package. Despite being explicitely marked as unstable some libraries\n// already make use of them. This file is not a full replacement for the\n// scheduler package, but includes the necessary shims to make those libraries\n// work with Preact.\n\nexport const unstable_ImmediatePriority = 1;\nexport const unstable_UserBlockingPriority = 2;\nexport const unstable_NormalPriority = 3;\nexport const unstable_LowPriority = 4;\nexport const unstable_IdlePriority = 5;\n\n/**\n * @param {number} priority\n * @param {() => void} callback\n */\nexport function unstable_runWithPriority(priority, callback) {\n\treturn callback();\n}\n\nexport const unstable_now =\n\ttypeof performance === 'object' && typeof performance.now === 'function'\n\t\t? performance.now.bind(performance)\n\t\t: () => Date.now();\n", "import { createElement } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Memoize a component, so that it only updates when the props actually have\n * changed. This was previously known as `React.pure`.\n * @param {import('./internal').FunctionComponent} c functional component\n * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function\n * @returns {import('./internal').FunctionComponent}\n */\nexport function memo(c, comparer) {\n\tfunction shouldUpdate(nextProps) {\n\t\tlet ref = this.props.ref;\n\t\tlet updateRef = ref == nextProps.ref;\n\t\tif (!updateRef && ref) {\n\t\t\tref.call ? ref(null) : (ref.current = null);\n\t\t}\n\n\t\tif (!comparer) {\n\t\t\treturn shallowDiffers(this.props, nextProps);\n\t\t}\n\n\t\treturn !comparer(this.props, nextProps) || !updateRef;\n\t}\n\n\tfunction Memoed(props) {\n\t\tthis.shouldComponentUpdate = shouldUpdate;\n\t\treturn createElement(c, props);\n\t}\n\tMemoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';\n\tMemoed.prototype.isReactComponent = true;\n\tMemoed._forwarded = true;\n\treturn Memoed;\n}\n", "export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}", "import arrayWithHoles from \"@babel/runtime/helpers/esm/arrayWithHoles\";\nimport iterableToArrayLimit from \"@babel/runtime/helpers/esm/iterableToArrayLimit\";\nimport unsupportedIterableToArray from \"@babel/runtime/helpers/esm/unsupportedIterableToArray\";\nimport nonIterableRest from \"@babel/runtime/helpers/esm/nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}", "export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}", "export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}", "import arrayLikeToArray from \"@babel/runtime/helpers/esm/arrayLikeToArray\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}", "export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}", "import * as cookie from 'cookie';\r\nexport function hasDocumentCookie() {\r\n    // Can we get/set cookies on document.cookie?\r\n    return typeof document === 'object' && typeof document.cookie === 'string';\r\n}\r\nexport function cleanCookies() {\r\n    document.cookie.split(';').forEach(function (c) {\r\n        document.cookie = c\r\n            .replace(/^ +/, '')\r\n            .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/');\r\n    });\r\n}\r\nexport function parseCookies(cookies, options) {\r\n    if (typeof cookies === 'string') {\r\n        return cookie.parse(cookies, options);\r\n    }\r\n    else if (typeof cookies === 'object' && cookies !== null) {\r\n        return cookies;\r\n    }\r\n    else {\r\n        return {};\r\n    }\r\n}\r\nexport function isParsingCookie(value, doNotParse) {\r\n    if (typeof doNotParse === 'undefined') {\r\n        // We guess if the cookie start with { or [, it has been serialized\r\n        doNotParse =\r\n            !value || (value[0] !== '{' && value[0] !== '[' && value[0] !== '\"');\r\n    }\r\n    return !doNotParse;\r\n}\r\nexport function readCookie(value, options) {\r\n    if (options === void 0) { options = {}; }\r\n    var cleanValue = cleanupCookieValue(value);\r\n    if (isParsingCookie(cleanValue, options.doNotParse)) {\r\n        try {\r\n            return JSON.parse(cleanValue);\r\n        }\r\n        catch (e) {\r\n            // At least we tried\r\n        }\r\n    }\r\n    // Ignore clean value if we failed the deserialization\r\n    // It is not relevant anymore to trim those values\r\n    return value;\r\n}\r\nfunction cleanupCookieValue(value) {\r\n    // express prepend j: before serializing a cookie\r\n    if (value && value[0] === 'j' && value[1] === ':') {\r\n        return value.substr(2);\r\n    }\r\n    return value;\r\n}\r\n", "var __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nimport * as cookie from 'cookie';\r\nimport { hasDocumentCookie, parseCookies, readCookie } from './utils';\r\nvar Cookies = /** @class */ (function () {\r\n    function Cookies(cookies, options) {\r\n        var _this = this;\r\n        this.changeListeners = [];\r\n        this.HAS_DOCUMENT_COOKIE = false;\r\n        this.cookies = parseCookies(cookies, options);\r\n        new Promise(function () {\r\n            _this.HAS_DOCUMENT_COOKIE = hasDocumentCookie();\r\n        }).catch(function () { });\r\n    }\r\n    Cookies.prototype._updateBrowserValues = function (parseOptions) {\r\n        if (!this.HAS_DOCUMENT_COOKIE) {\r\n            return;\r\n        }\r\n        this.cookies = cookie.parse(document.cookie, parseOptions);\r\n    };\r\n    Cookies.prototype._emitChange = function (params) {\r\n        for (var i = 0; i < this.changeListeners.length; ++i) {\r\n            this.changeListeners[i](params);\r\n        }\r\n    };\r\n    Cookies.prototype.get = function (name, options, parseOptions) {\r\n        if (options === void 0) { options = {}; }\r\n        this._updateBrowserValues(parseOptions);\r\n        return readCookie(this.cookies[name], options);\r\n    };\r\n    Cookies.prototype.getAll = function (options, parseOptions) {\r\n        if (options === void 0) { options = {}; }\r\n        this._updateBrowserValues(parseOptions);\r\n        var result = {};\r\n        for (var name_1 in this.cookies) {\r\n            result[name_1] = readCookie(this.cookies[name_1], options);\r\n        }\r\n        return result;\r\n    };\r\n    Cookies.prototype.set = function (name, value, options) {\r\n        var _a;\r\n        if (typeof value === 'object') {\r\n            value = JSON.stringify(value);\r\n        }\r\n        this.cookies = __assign(__assign({}, this.cookies), (_a = {}, _a[name] = value, _a));\r\n        if (this.HAS_DOCUMENT_COOKIE) {\r\n            document.cookie = cookie.serialize(name, value, options);\r\n        }\r\n        this._emitChange({ name: name, value: value, options: options });\r\n    };\r\n    Cookies.prototype.remove = function (name, options) {\r\n        var finalOptions = (options = __assign(__assign({}, options), { expires: new Date(1970, 1, 1, 0, 0, 1), maxAge: 0 }));\r\n        this.cookies = __assign({}, this.cookies);\r\n        delete this.cookies[name];\r\n        if (this.HAS_DOCUMENT_COOKIE) {\r\n            document.cookie = cookie.serialize(name, '', finalOptions);\r\n        }\r\n        this._emitChange({ name: name, value: undefined, options: options });\r\n    };\r\n    Cookies.prototype.addChangeListener = function (callback) {\r\n        this.changeListeners.push(callback);\r\n    };\r\n    Cookies.prototype.removeChangeListener = function (callback) {\r\n        var idx = this.changeListeners.indexOf(callback);\r\n        if (idx >= 0) {\r\n            this.changeListeners.splice(idx, 1);\r\n        }\r\n    };\r\n    return Cookies;\r\n}());\r\nexport default Cookies;\r\n", "import Cookies from 'universal-cookie';\r\nexport default Cookies;\r\n", "import * as React from 'react';\r\nimport Cookies from './Cookies';\r\nvar CookiesContext = React.createContext(new Cookies());\r\nexport var Provider = CookiesContext.Provider, Consumer = CookiesContext.Consumer;\r\nexport default CookiesContext;\r\n", "import { useCookies } from 'react-cookie';\nimport {useEffect} from 'react';\n\nexport function UserNav(props) {\n\n  const [cookies, setCookie] = useCookies();\n  const hostname = window.location.host;\n\n\n  useEffect(() => {\n    const params = new URLSearchParams(window.location.search);\n    \n    const utm_campaign = params.get(\"utm_campaign\");\n    const utm_source = params.get(\"utm_source\");\n    const utm_medium = params.get(\"utm_medium\");\n    const utm_term = params.get(\"utm_term\");\n\n    //utm_data cookie\n    if (utm_campaign && cookies.utm_data?.utm_campaign !== utm_campaign) {\n      setCookie(`utm_data`, {\n        \"utm_campaign\": utm_campaign,\n        \"utm_source\": utm_source,\n        \"utm_medium\": utm_medium,\n        \"utm_term\": utm_term,\n        \"Referrer\":document.referrer\n      }, {\n        maxAge: 7889400\n      });\n    } else if(!cookies.utm_data){\n      setCookie(`utm_data`, {\n        \"Referrer\":document.referrer|| \"N/A\"\n      }, {\n        maxAge: 7889400\n      });\n    }\n  });\n\nreturn (\n  <ul className={`user-nav`}>\n    <li class=\"searchform\">\n      <form className=\"search-all\" action={`//${hostname}/search/main_menu_search`} method=\"POST\">\n        <input type=\"text\" placeholder=\"Search GrapeCity\" name=\"term\" id=\"nav-search\" />\n        <input type=\"submit\" value=\"Search\" />\n      </form>\n    </li>\n    <li class=\"search\">\n      <i class=\"fa fa-search\" aria-hidden=\"true\"><span>Search</span></i>\n    </li>\n    <li className={`cart`}>\n      <a href={`//${hostname}/cart`}>\n        <i class=\"fa fa-shopping-cart\" aria-hidden=\"true\"><span>Cart</span></i>\n        {cookies.user_nav?.cart_items &&\n          <div className={`cart-items-count`}>\n            {cookies.user_nav.cart_items}\n          </div>\n        }\n      </a>\n    </li>\n    {(() => {\n      if (cookies.user_nav?.avatar) {\n        return (\n          <li class={`user rnav-inner-drop-trigger user`}>\n            <a href={`//${hostname}/my-account`}>\n              <img src={cookies.user_nav.avatar} alt=\"\" className={`gravatar`} ></img>\n            </a>\n            <ul class=\"rnav-inner-drop user\">\n              <li><a href={`//${hostname}/my-account`}>My Account</a></li>\n              <li><a href={`//${hostname}/my-account/my-profile`}>My Profile</a></li>\n              <li><a href={`//${hostname}/my-account/my-licenses`}>My Licenses</a></li>\n              <li><a href={`//${hostname}/my-account/my-quotes`}>My Quotes</a></li>\n              <li><a href={`//${hostname}/logout`}>Logout</a></li>\n            </ul>\n          </li>\n        )\n\n      } else {\n        return (\n          <li className={`user`}>\n            <a href={`//${hostname}/my-account`}>\n              <i class=\"fa fa-user-circle-o\" aria-hidden=\"true\"><span>My Account</span></i>\n            </a>\n          </li>\n        )\n      }\n\n    })()}\n\n  </ul>\n);\n}\n\nexport default UserNav;\n", "import { useContext, useEffect, useState, useRef, useMemo } from 'react';\r\nimport CookiesContext from './CookiesContext';\r\nexport default function useCookies(dependencies) {\r\n    var cookies = useContext(CookiesContext);\r\n    if (!cookies) {\r\n        throw new Error('Missing <CookiesProvider>');\r\n    }\r\n    var initialCookies = cookies.getAll();\r\n    var _a = useState(initialCookies), allCookies = _a[0], setCookies = _a[1];\r\n    var previousCookiesRef = useRef(allCookies);\r\n    useEffect(function () {\r\n        function onChange() {\r\n            var newCookies = cookies.getAll();\r\n            if (shouldUpdate(dependencies || null, newCookies, previousCookiesRef.current)) {\r\n                setCookies(newCookies);\r\n            }\r\n            previousCookiesRef.current = newCookies;\r\n        }\r\n        cookies.addChangeListener(onChange);\r\n        return function () {\r\n            cookies.removeChangeListener(onChange);\r\n        };\r\n    }, [cookies]);\r\n    var setCookie = useMemo(function () { return cookies.set.bind(cookies); }, [cookies]);\r\n    var removeCookie = useMemo(function () { return cookies.remove.bind(cookies); }, [cookies]);\r\n    return [allCookies, setCookie, removeCookie];\r\n}\r\nfunction shouldUpdate(dependencies, newCookies, oldCookies) {\r\n    if (!dependencies) {\r\n        return true;\r\n    }\r\n    for (var _i = 0, dependencies_1 = dependencies; _i < dependencies_1.length; _i++) {\r\n        var dependency = dependencies_1[_i];\r\n        if (newCookies[dependency] !== oldCookies[dependency]) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n", "import React from 'react';\nimport ReactDOM from 'react-dom';\nimport UserNav from './components/user-nav'\n\n\ndocument.querySelectorAll('#gc-usernav').forEach(domContainer => {\n   ReactDOM.render(\n    <React.StrictMode>\n      <UserNav/>\n    </React.StrictMode>,\n    domContainer\n  );\n\n});\n\n" ],
  "sourceRoot": ""
}