) {\r\n normalized[normalizedKey] = EMPTY_OBJ;\r\n }\r\n else {\r\n warn(`Invalid prop name: \"${normalizedKey}\" is a reserved property.`);\r\n }\r\n }\r\n }\r\n else {\r\n if ( !isObject(raw)) {\r\n warn(`invalid props options`, raw);\r\n }\r\n for (const key in raw) {\r\n const normalizedKey = camelize(key);\r\n if (normalizedKey[0] !== '

) {\r\n const opt = raw[key];\r\n const prop = (normalized[normalizedKey] =\r\n isArray(opt) || isFunction(opt) ? { type: opt } : opt);\r\n if (prop != null) {\r\n const booleanIndex = getTypeIndex(Boolean, prop.type);\r\n const stringIndex = getTypeIndex(String, prop.type);\r\n prop[\"1\" \u002F* shouldCast *\u002F] = booleanIndex \u003E -1;\r\n prop[\"2\" \u002F* shouldCastTrue *\u002F] = booleanIndex \u003C stringIndex;\r\n }\r\n }\r\n else {\r\n warn(`Invalid prop name: \"${normalizedKey}\" is a reserved property.`);\r\n }\r\n }\r\n }\r\n return normalized;\r\n}\r\n\u002F\u002F use function string name to check type constructors\r\n\u002F\u002F so that it works across vms \u002F iframes.\r\nfunction getType(ctor) {\r\n const match = ctor && ctor.toString().match(\u002F^\\s*function (\\w+)\u002F);\r\n return match ? match[1] : '';\r\n}\r\nfunction isSameType(a, b) {\r\n return getType(a) === getType(b);\r\n}\r\nfunction getTypeIndex(type, expectedTypes) {\r\n if (isArray(expectedTypes)) {\r\n for (let i = 0, len = expectedTypes.length; i \u003C len; i++) {\r\n if (isSameType(expectedTypes[i], type)) {\r\n return i;\r\n }\r\n }\r\n }\r\n else if (isObject(expectedTypes)) {\r\n return isSameType(expectedTypes, type) ? 0 : -1;\r\n }\r\n return -1;\r\n}\r\nfunction validateProp(name, value, prop, isAbsent) {\r\n const { type, required, validator } = prop;\r\n \u002F\u002F required!\r\n if (required && isAbsent) {\r\n warn('Missing required prop: \"' + name + '\"');\r\n return;\r\n }\r\n \u002F\u002F missing but optional\r\n if (value == null && !prop.required) {\r\n return;\r\n }\r\n \u002F\u002F type check\r\n if (type != null && type !== true) {\r\n let isValid = false;\r\n const types = isArray(type) ? type : [type];\r\n const expectedTypes = [];\r\n \u002F\u002F value is valid as long as one of the specified types match\r\n for (let i = 0; i \u003C types.length && !isValid; i++) {\r\n const { valid, expectedType } = assertType(value, types[i]);\r\n expectedTypes.push(expectedType || '');\r\n isValid = valid;\r\n }\r\n if (!isValid) {\r\n warn(getInvalidTypeMessage(name, value, expectedTypes));\r\n return;\r\n }\r\n }\r\n \u002F\u002F custom validator\r\n if (validator && !validator(value)) {\r\n warn('Invalid prop: custom validator check failed for prop \"' + name + '\".');\r\n }\r\n}\r\nconst isSimpleType = \u002F*#__PURE__*\u002F makeMap('String,Number,Boolean,Function,Symbol');\r\nfunction assertType(value, type) {\r\n let valid;\r\n const expectedType = getType(type);\r\n if (isSimpleType(expectedType)) {\r\n const t = typeof value;\r\n valid = t === expectedType.toLowerCase();\r\n \u002F\u002F for primitive wrapper objects\r\n if (!valid && t === 'object') {\r\n valid = value instanceof type;\r\n }\r\n }\r\n else if (expectedType === 'Object') {\r\n valid = toRawType(value) === 'Object';\r\n }\r\n else if (expectedType === 'Array') {\r\n valid = isArray(value);\r\n }\r\n else {\r\n valid = value instanceof type;\r\n }\r\n return {\r\n valid,\r\n expectedType\r\n };\r\n}\r\nfunction getInvalidTypeMessage(name, value, expectedTypes) {\r\n let message = `Invalid prop: type check failed for prop \"${name}\".` +\r\n ` Expected ${expectedTypes.map(capitalize).join(', ')}`;\r\n const expectedType = expectedTypes[0];\r\n const receivedType = toRawType(value);\r\n const expectedValue = styleValue(value, expectedType);\r\n const receivedValue = styleValue(value, receivedType);\r\n \u002F\u002F check if we need to specify expected value\r\n if (expectedTypes.length === 1 &&\r\n isExplicable(expectedType) &&\r\n !isBoolean(expectedType, receivedType)) {\r\n message += ` with value ${expectedValue}`;\r\n }\r\n message += `, got ${receivedType} `;\r\n \u002F\u002F check if we need to specify received value\r\n if (isExplicable(receivedType)) {\r\n message += `with value ${receivedValue}.`;\r\n }\r\n return message;\r\n}\r\nfunction styleValue(value, type) {\r\n if (type === 'String') {\r\n return `\"${value}\"`;\r\n }\r\n else if (type === 'Number') {\r\n return `${Number(value)}`;\r\n }\r\n else {\r\n return `${value}`;\r\n }\r\n}\r\nfunction isExplicable(type) {\r\n const explicitTypes = ['string', 'number', 'boolean'];\r\n return explicitTypes.some(elem =\u003E type.toLowerCase() === elem);\r\n}\r\nfunction isBoolean(...args) {\r\n return args.some(elem =\u003E elem.toLowerCase() === 'boolean');\r\n}\r\n\r\nconst normalizeSlotValue = (value) =\u003E isArray(value)\r\n ? value.map(normalizeVNode)\r\n : [normalizeVNode(value)];\r\nconst normalizeSlot = (key, rawSlot) =\u003E (props) =\u003E {\r\n if ( currentInstance != null) {\r\n warn(`Slot \"${key}\" invoked outside of the render function: ` +\r\n `this will not track dependencies used in the slot. ` +\r\n `Invoke the slot function inside the render function instead.`);\r\n }\r\n return normalizeSlotValue(rawSlot(props));\r\n};\r\nfunction resolveSlots(instance, children) {\r\n let slots;\r\n if (instance.vnode.shapeFlag & 32 \u002F* SLOTS_CHILDREN *\u002F) {\r\n const rawSlots = children;\r\n if (rawSlots._compiled) {\r\n \u002F\u002F pre-normalized slots object generated by compiler\r\n slots = children;\r\n }\r\n else {\r\n slots = {};\r\n for (const key in rawSlots) {\r\n const value = rawSlots[key];\r\n if (isFunction(value)) {\r\n slots[key] = normalizeSlot(key, value);\r\n }\r\n else if (value != null) {\r\n {\r\n warn(`Non-function value encountered for slot \"${key}\". ` +\r\n `Prefer function slots for better performance.`);\r\n }\r\n const normalized = normalizeSlotValue(value);\r\n slots[key] = () =\u003E normalized;\r\n }\r\n }\r\n }\r\n }\r\n else if (children !== null) {\r\n \u002F\u002F non slot object children (direct value) passed to a component\r\n {\r\n warn(`Non-function value encountered for default slot. ` +\r\n `Prefer function slots for better performance.`);\r\n }\r\n const normalized = normalizeSlotValue(children);\r\n slots = { default: () =\u003E normalized };\r\n }\r\n if (slots !== void 0) {\r\n instance.slots = slots;\r\n }\r\n}\r\n\r\n\u002F**\r\nRuntime helper for applying directives to a vnode. Example usage:\r\n\r\nconst comp = resolveComponent('comp')\r\nconst foo = resolveDirective('foo')\r\nconst bar = resolveDirective('bar')\r\n\r\nreturn withDirectives(h(comp), [\r\n [foo, this.x],\r\n [bar, this.y]\r\n])\r\n*\u002F\r\nconst isBuiltInDirective = \u002F*#__PURE__*\u002F makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');\r\nfunction validateDirectiveName(name) {\r\n if (isBuiltInDirective(name)) {\r\n warn('Do not use built-in directive ids as custom directive id: ' + name);\r\n }\r\n}\r\nconst directiveToVnodeHooksMap = \u002F*#__PURE__*\u002F [\r\n 'beforeMount',\r\n 'mounted',\r\n 'beforeUpdate',\r\n 'updated',\r\n 'beforeUnmount',\r\n 'unmounted'\r\n].reduce((map, key) =\u003E {\r\n const vnodeKey = `onVnode` + key[0].toUpperCase() + key.slice(1);\r\n const vnodeHook = (vnode, prevVnode) =\u003E {\r\n const bindings = vnode.dirs;\r\n const prevBindings = prevVnode ? prevVnode.dirs : EMPTY_ARR;\r\n for (let i = 0; i \u003C bindings.length; i++) {\r\n const binding = bindings[i];\r\n const hook = binding.dir[key];\r\n if (hook != null) {\r\n if (prevVnode != null) {\r\n binding.oldValue = prevBindings[i].value;\r\n }\r\n hook(vnode.el, binding, vnode, prevVnode);\r\n }\r\n }\r\n };\r\n map[key] = [vnodeKey, vnodeHook];\r\n return map;\r\n}, {});\r\nfunction withDirectives(vnode, directives) {\r\n const internalInstance = currentRenderingInstance;\r\n if (internalInstance === null) {\r\n warn(`withDirectives can only be used inside render functions.`);\r\n return vnode;\r\n }\r\n const instance = internalInstance.renderProxy;\r\n const props = vnode.props || (vnode.props = {});\r\n const bindings = vnode.dirs || (vnode.dirs = new Array(directives.length));\r\n const injected = {};\r\n for (let i = 0; i \u003C directives.length; i++) {\r\n let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];\r\n if (isFunction(dir)) {\r\n dir = {\r\n mounted: dir,\r\n updated: dir\r\n };\r\n }\r\n bindings[i] = {\r\n dir,\r\n instance,\r\n value,\r\n oldValue: void 0,\r\n arg,\r\n modifiers\r\n };\r\n \u002F\u002F inject onVnodeXXX hooks\r\n for (const key in dir) {\r\n if (!injected[key]) {\r\n const { 0: hookName, 1: hook } = directiveToVnodeHooksMap[key];\r\n const existing = props[hookName];\r\n props[hookName] = existing ? [].concat(existing, hook) : hook;\r\n injected[key] = true;\r\n }\r\n }\r\n }\r\n return vnode;\r\n}\r\nfunction invokeDirectiveHook(hook, instance, vnode, prevVNode = null) {\r\n callWithAsyncErrorHandling(hook, instance, 7 \u002F* DIRECTIVE_HOOK *\u002F, [\r\n vnode,\r\n prevVNode\r\n ]);\r\n}\r\n\r\nfunction createAppContext() {\r\n return {\r\n config: {\r\n devtools: true,\r\n performance: false,\r\n isNativeTag: NO,\r\n isCustomElement: NO,\r\n errorHandler: undefined,\r\n warnHandler: undefined\r\n },\r\n mixins: [],\r\n components: {},\r\n directives: {},\r\n provides: {}\r\n };\r\n}\r\nfunction createAppAPI(render) {\r\n return function createApp() {\r\n const context = createAppContext();\r\n const installedPlugins = new Set();\r\n let isMounted = false;\r\n const app = {\r\n get config() {\r\n return context.config;\r\n },\r\n set config(v) {\r\n {\r\n warn(`app.config cannot be replaced. Modify individual options instead.`);\r\n }\r\n },\r\n use(plugin) {\r\n if (installedPlugins.has(plugin)) {\r\n warn(`Plugin has already been applied to target app.`);\r\n }\r\n else if (isFunction(plugin)) {\r\n installedPlugins.add(plugin);\r\n plugin(app);\r\n }\r\n else if (isFunction(plugin.install)) {\r\n installedPlugins.add(plugin);\r\n plugin.install(app);\r\n }\r\n else {\r\n warn(`A plugin must either be a function or an object with an \"install\" ` +\r\n `function.`);\r\n }\r\n return app;\r\n },\r\n mixin(mixin) {\r\n if (!context.mixins.includes(mixin)) {\r\n context.mixins.push(mixin);\r\n }\r\n else {\r\n warn('Mixin has already been applied to target app' +\r\n (mixin.name ? `: ${mixin.name}` : ''));\r\n }\r\n return app;\r\n },\r\n component(name, component) {\r\n {\r\n validateComponentName(name, context.config);\r\n }\r\n if (!component) {\r\n return context.components[name];\r\n }\r\n else {\r\n if ( context.components[name]) {\r\n warn(`Component \"${name}\" has already been registered in target app.`);\r\n }\r\n context.components[name] = component;\r\n return app;\r\n }\r\n },\r\n directive(name, directive) {\r\n {\r\n validateDirectiveName(name);\r\n }\r\n if (!directive) {\r\n return context.directives[name];\r\n }\r\n else {\r\n if ( context.directives[name]) {\r\n warn(`Directive \"${name}\" has already been registered in target app.`);\r\n }\r\n context.directives[name] = directive;\r\n return app;\r\n }\r\n },\r\n mount(rootComponent, rootContainer, rootProps) {\r\n if (!isMounted) {\r\n const vnode = createVNode(rootComponent, rootProps);\r\n \u002F\u002F store app context on the root VNode.\r\n \u002F\u002F this will be set on the root instance on initial mount.\r\n vnode.appContext = context;\r\n render(vnode, rootContainer);\r\n isMounted = true;\r\n return vnode.component.renderProxy;\r\n }\r\n else {\r\n warn(`App has already been mounted. Create a new app instance instead.`);\r\n }\r\n },\r\n provide(key, value) {\r\n if ( key in context.provides) {\r\n warn(`App already provides property with key \"${key}\". ` +\r\n `It will be overwritten with the new value.`);\r\n }\r\n \u002F\u002F TypeScript doesn't allow symbols as index type\r\n \u002F\u002F https:\u002F\u002Fgithub.com\u002FMicrosoft\u002FTypeScript\u002Fissues\u002F24587\r\n context.provides[key] = value;\r\n return app;\r\n }\r\n };\r\n return app;\r\n };\r\n}\r\n\r\n\u002F\u002F Suspense exposes a component-like API, and is treated like a component\r\n\u002F\u002F in the compiler, but internally it's a special built-in type that hooks\r\n\u002F\u002F directly into the renderer.\r\nconst SuspenseImpl = {\r\n \u002F\u002F In order to make Suspense tree-shakable, we need to avoid importing it\r\n \u002F\u002F directly in the renderer. The renderer checks for the __isSuspense flag\r\n \u002F\u002F on a vnode's type and calls the `process` method, passing in renderer\r\n \u002F\u002F internals.\r\n __isSuspense: true,\r\n process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, \r\n \u002F\u002F platform-specific impl passed from renderer\r\n rendererInternals) {\r\n if (n1 == null) {\r\n mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals);\r\n }\r\n else {\r\n patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, rendererInternals);\r\n }\r\n }\r\n};\r\n\u002F\u002F Force-casted public typing for h and TSX props inference\r\nconst Suspense = ( SuspenseImpl\r\n );\r\nfunction mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals) {\r\n const { patch, options: { createElement } } = rendererInternals;\r\n const hiddenContainer = createElement('div');\r\n const suspense = (n2.suspense = createSuspenseBoundary(n2, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals));\r\n const { content, fallback } = normalizeSuspenseChildren(n2);\r\n suspense.subTree = content;\r\n suspense.fallbackTree = fallback;\r\n \u002F\u002F start mounting the content subtree in an off-dom container\r\n patch(null, content, hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n \u002F\u002F now check if we have encountered any async deps\r\n if (suspense.deps \u003E 0) {\r\n \u002F\u002F mount the fallback tree\r\n patch(null, fallback, container, anchor, parentComponent, null, \u002F\u002F fallback tree will not have suspense context\r\n isSVG, optimized);\r\n n2.el = fallback.el;\r\n }\r\n else {\r\n \u002F\u002F Suspense has no async deps. Just resolve.\r\n suspense.resolve();\r\n }\r\n}\r\nfunction patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, { patch }) {\r\n const suspense = (n2.suspense = n1.suspense);\r\n suspense.vnode = n2;\r\n const { content, fallback } = normalizeSuspenseChildren(n2);\r\n const oldSubTree = suspense.subTree;\r\n const oldFallbackTree = suspense.fallbackTree;\r\n if (!suspense.isResolved) {\r\n patch(oldSubTree, content, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, optimized);\r\n if (suspense.deps \u003E 0) {\r\n \u002F\u002F still pending. patch the fallback tree.\r\n patch(oldFallbackTree, fallback, container, anchor, parentComponent, null, \u002F\u002F fallback tree will not have suspense context\r\n isSVG, optimized);\r\n n2.el = fallback.el;\r\n }\r\n \u002F\u002F If deps somehow becomes 0 after the patch it means the patch caused an\r\n \u002F\u002F async dep component to unmount and removed its dep. It will cause the\r\n \u002F\u002F suspense to resolve and we don't need to do anything here.\r\n }\r\n else {\r\n \u002F\u002F just normal patch inner content as a fragment\r\n patch(oldSubTree, content, container, anchor, parentComponent, suspense, isSVG, optimized);\r\n n2.el = content.el;\r\n }\r\n suspense.subTree = content;\r\n suspense.fallbackTree = fallback;\r\n}\r\nfunction createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals) {\r\n const { patch, move, unmount, next, options: { parentNode } } = rendererInternals;\r\n const suspense = {\r\n vnode,\r\n parent,\r\n parentComponent,\r\n isSVG,\r\n optimized,\r\n container,\r\n hiddenContainer,\r\n anchor,\r\n deps: 0,\r\n subTree: null,\r\n fallbackTree: null,\r\n isResolved: false,\r\n isUnmounted: false,\r\n effects: [],\r\n resolve() {\r\n {\r\n if (suspense.isResolved) {\r\n throw new Error(`resolveSuspense() is called on an already resolved suspense boundary.`);\r\n }\r\n if (suspense.isUnmounted) {\r\n throw new Error(`resolveSuspense() is called on an already unmounted suspense boundary.`);\r\n }\r\n }\r\n const { vnode, subTree, fallbackTree, effects, parentComponent, container } = suspense;\r\n \u002F\u002F this is initial anchor on mount\r\n let { anchor } = suspense;\r\n \u002F\u002F unmount fallback tree\r\n if (fallbackTree.el) {\r\n \u002F\u002F if the fallback tree was mounted, it may have been moved\r\n \u002F\u002F as part of a parent suspense. get the latest anchor for insertion\r\n anchor = next(fallbackTree);\r\n unmount(fallbackTree, parentComponent, suspense, true);\r\n }\r\n \u002F\u002F move content from off-dom container to actual container\r\n move(subTree, container, anchor);\r\n const el = (vnode.el = subTree.el);\r\n \u002F\u002F suspense as the root node of a component...\r\n if (parentComponent && parentComponent.subTree === vnode) {\r\n parentComponent.vnode.el = el;\r\n updateHOCHostEl(parentComponent, el);\r\n }\r\n \u002F\u002F check if there is a pending parent suspense\r\n let parent = suspense.parent;\r\n let hasUnresolvedAncestor = false;\r\n while (parent) {\r\n if (!parent.isResolved) {\r\n \u002F\u002F found a pending parent suspense, merge buffered post jobs\r\n \u002F\u002F into that parent\r\n parent.effects.push(...effects);\r\n hasUnresolvedAncestor = true;\r\n break;\r\n }\r\n parent = parent.parent;\r\n }\r\n \u002F\u002F no pending parent suspense, flush all jobs\r\n if (!hasUnresolvedAncestor) {\r\n queuePostFlushCb(effects);\r\n }\r\n suspense.isResolved = true;\r\n \u002F\u002F invoke @resolve event\r\n const onResolve = vnode.props && vnode.props.onResolve;\r\n if (isFunction(onResolve)) {\r\n onResolve();\r\n }\r\n },\r\n recede() {\r\n suspense.isResolved = false;\r\n const { vnode, subTree, fallbackTree, parentComponent, container, hiddenContainer, isSVG, optimized } = suspense;\r\n \u002F\u002F move content tree back to the off-dom container\r\n const anchor = next(subTree);\r\n move(subTree, hiddenContainer, null);\r\n \u002F\u002F remount the fallback tree\r\n patch(null, fallbackTree, container, anchor, parentComponent, null, \u002F\u002F fallback tree will not have suspense context\r\n isSVG, optimized);\r\n const el = (vnode.el = fallbackTree.el);\r\n \u002F\u002F suspense as the root node of a component...\r\n if (parentComponent && parentComponent.subTree === vnode) {\r\n parentComponent.vnode.el = el;\r\n updateHOCHostEl(parentComponent, el);\r\n }\r\n \u002F\u002F invoke @recede event\r\n const onRecede = vnode.props && vnode.props.onRecede;\r\n if (isFunction(onRecede)) {\r\n onRecede();\r\n }\r\n },\r\n move(container, anchor) {\r\n move(suspense.isResolved ? suspense.subTree : suspense.fallbackTree, container, anchor);\r\n suspense.container = container;\r\n },\r\n next() {\r\n return next(suspense.isResolved ? suspense.subTree : suspense.fallbackTree);\r\n },\r\n registerDep(instance, setupRenderEffect) {\r\n \u002F\u002F suspense is already resolved, need to recede.\r\n \u002F\u002F use queueJob so it's handled synchronously after patching the current\r\n \u002F\u002F suspense tree\r\n if (suspense.isResolved) {\r\n queueJob(() =\u003E {\r\n suspense.recede();\r\n });\r\n }\r\n suspense.deps++;\r\n instance\r\n .asyncDep.catch(err =\u003E {\r\n handleError(err, instance, 0 \u002F* SETUP_FUNCTION *\u002F);\r\n })\r\n .then(asyncSetupResult =\u003E {\r\n \u002F\u002F retry when the setup() promise resolves.\r\n \u002F\u002F component may have been unmounted before resolve.\r\n if (instance.isUnmounted || suspense.isUnmounted) {\r\n return;\r\n }\r\n suspense.deps--;\r\n \u002F\u002F retry from this component\r\n instance.asyncResolved = true;\r\n const { vnode } = instance;\r\n {\r\n pushWarningContext(vnode);\r\n }\r\n handleSetupResult(instance, asyncSetupResult, suspense);\r\n setupRenderEffect(instance, parentComponent, suspense, vnode, \r\n \u002F\u002F component may have been moved before resolve\r\n parentNode(instance.subTree.el), next(instance.subTree), isSVG);\r\n updateHOCHostEl(instance, vnode.el);\r\n {\r\n popWarningContext();\r\n }\r\n if (suspense.deps === 0) {\r\n suspense.resolve();\r\n }\r\n });\r\n },\r\n unmount(parentSuspense, doRemove) {\r\n suspense.isUnmounted = true;\r\n unmount(suspense.subTree, parentComponent, parentSuspense, doRemove);\r\n if (!suspense.isResolved) {\r\n unmount(suspense.fallbackTree, parentComponent, parentSuspense, doRemove);\r\n }\r\n }\r\n };\r\n return suspense;\r\n}\r\nfunction normalizeSuspenseChildren(vnode) {\r\n const { shapeFlag, children } = vnode;\r\n if (shapeFlag & 32 \u002F* SLOTS_CHILDREN *\u002F) {\r\n const { default: d, fallback } = children;\r\n return {\r\n content: normalizeVNode(isFunction(d) ? d() : d),\r\n fallback: normalizeVNode(isFunction(fallback) ? fallback() : fallback)\r\n };\r\n }\r\n else {\r\n return {\r\n content: normalizeVNode(children),\r\n fallback: normalizeVNode(null)\r\n };\r\n }\r\n}\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n if (suspense !== null && !suspense.isResolved) {\r\n if (isArray(fn)) {\r\n suspense.effects.push(...fn);\r\n }\r\n else {\r\n suspense.effects.push(fn);\r\n }\r\n }\r\n else {\r\n queuePostFlushCb(fn);\r\n }\r\n}\r\n\r\nfunction createDevEffectOptions(instance) {\r\n return {\r\n scheduler: queueJob,\r\n onTrack: instance.rtc ? e =\u003E invokeHooks(instance.rtc, e) : void 0,\r\n onTrigger: instance.rtg ? e =\u003E invokeHooks(instance.rtg, e) : void 0\r\n };\r\n}\r\nfunction isSameType$1(n1, n2) {\r\n return n1.type === n2.type && n1.key === n2.key;\r\n}\r\nfunction invokeHooks(hooks, arg) {\r\n for (let i = 0; i \u003C hooks.length; i++) {\r\n hooks[i](arg);\r\n }\r\n}\r\nconst queuePostRenderEffect = queueEffectWithSuspense\r\n ;\r\n\u002F**\r\n * The createRenderer function accepts two generic arguments:\r\n * HostNode and HostElement, corresponding to Node and Element types in the\r\n * host environment. For example, for runtime-dom, HostNode would be the DOM\r\n * `Node` interface and HostElement would be the DOM `Element` interface.\r\n *\r\n * Custom renderers can pass in the platform specific types like this:\r\n *\r\n * ``` js\r\n * const { render, createApp } = createRenderer\u003CNode, Element\u003E({\r\n * patchProp,\r\n * ...nodeOps\r\n * })\r\n * ```\r\n *\u002F\r\nfunction createRenderer(options) {\r\n const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, querySelector: hostQuerySelector } = options;\r\n const internals = {\r\n patch,\r\n unmount,\r\n move,\r\n next: getNextHostNode,\r\n options\r\n };\r\n function patch(n1, \u002F\u002F null means this is a mount\r\n n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) {\r\n \u002F\u002F patching & not same type, unmount old tree\r\n if (n1 != null && !isSameType$1(n1, n2)) {\r\n anchor = getNextHostNode(n1);\r\n unmount(n1, parentComponent, parentSuspense, true);\r\n n1 = null;\r\n }\r\n const { type, shapeFlag } = n2;\r\n switch (type) {\r\n case Text:\r\n processText(n1, n2, container, anchor);\r\n break;\r\n case Comment:\r\n processCommentNode(n1, n2, container, anchor);\r\n break;\r\n case Fragment:\r\n processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n break;\r\n case Portal:\r\n processPortal(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n break;\r\n default:\r\n if (shapeFlag & 1 \u002F* ELEMENT *\u002F) {\r\n processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else if (shapeFlag & 6 \u002F* COMPONENT *\u002F) {\r\n processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else if ( shapeFlag & 64 \u002F* SUSPENSE *\u002F) {\r\n type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);\r\n }\r\n else {\r\n warn('Invalid HostVNode type:', n2.type, `(${typeof n2.type})`);\r\n }\r\n }\r\n }\r\n function processText(n1, n2, container, anchor) {\r\n if (n1 == null) {\r\n hostInsert((n2.el = hostCreateText(n2.children)), container, anchor);\r\n }\r\n else {\r\n const el = (n2.el = n1.el);\r\n if (n2.children !== n1.children) {\r\n hostSetText(el, n2.children);\r\n }\r\n }\r\n }\r\n function processCommentNode(n1, n2, container, anchor) {\r\n if (n1 == null) {\r\n hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor);\r\n }\r\n else {\r\n \u002F\u002F there's no support for dynamic comments\r\n n2.el = n1.el;\r\n }\r\n }\r\n function processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n if (n1 == null) {\r\n mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else {\r\n patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n if (n2.ref !== null && parentComponent !== null) {\r\n setRef(n2.ref, n1 && n1.ref, parentComponent, n2.el);\r\n }\r\n }\r\n function mountElement(vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n const tag = vnode.type;\r\n isSVG = isSVG || tag === 'svg';\r\n const el = (vnode.el = hostCreateElement(tag, isSVG));\r\n const { props, shapeFlag } = vnode;\r\n if (props != null) {\r\n for (const key in props) {\r\n if (isReservedProp(key))\r\n continue;\r\n hostPatchProp(el, key, props[key], null, isSVG);\r\n }\r\n if (props.onVnodeBeforeMount != null) {\r\n invokeDirectiveHook(props.onVnodeBeforeMount, parentComponent, vnode);\r\n }\r\n }\r\n if (shapeFlag & 8 \u002F* TEXT_CHILDREN *\u002F) {\r\n hostSetElementText(el, vnode.children);\r\n }\r\n else if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG, optimized || vnode.dynamicChildren !== null);\r\n }\r\n hostInsert(el, container, anchor);\r\n if (props != null && props.onVnodeMounted != null) {\r\n queuePostRenderEffect(() =\u003E {\r\n invokeDirectiveHook(props.onVnodeMounted, parentComponent, vnode);\r\n }, parentSuspense);\r\n }\r\n }\r\n function mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, start = 0) {\r\n for (let i = start; i \u003C children.length; i++) {\r\n const child = optimized\r\n ? children[i]\r\n : (children[i] = normalizeVNode(children[i]));\r\n patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n }\r\n function patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized) {\r\n const el = (n2.el = n1.el);\r\n const { patchFlag, dynamicChildren } = n2;\r\n const oldProps = (n1 && n1.props) || EMPTY_OBJ;\r\n const newProps = n2.props || EMPTY_OBJ;\r\n if (newProps.onVnodeBeforeUpdate != null) {\r\n invokeDirectiveHook(newProps.onVnodeBeforeUpdate, parentComponent, n2, n1);\r\n }\r\n if (patchFlag \u003E 0) {\r\n \u002F\u002F the presence of a patchFlag means this element's render code was\r\n \u002F\u002F generated by the compiler and can take the fast path.\r\n \u002F\u002F in this path old node and new node are guaranteed to have the same shape\r\n \u002F\u002F (i.e. at the exact same position in the source template)\r\n if (patchFlag & 16 \u002F* FULL_PROPS *\u002F) {\r\n \u002F\u002F element props contain dynamic keys, full diff needed\r\n patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n }\r\n else {\r\n \u002F\u002F class\r\n \u002F\u002F this flag is matched when the element has dynamic class bindings.\r\n if (patchFlag & 2 \u002F* CLASS *\u002F) {\r\n if (oldProps.class !== newProps.class) {\r\n hostPatchProp(el, 'class', newProps.class, null, isSVG);\r\n }\r\n }\r\n \u002F\u002F style\r\n \u002F\u002F this flag is matched when the element has dynamic style bindings\r\n if (patchFlag & 4 \u002F* STYLE *\u002F) {\r\n hostPatchProp(el, 'style', newProps.style, oldProps.style, isSVG);\r\n }\r\n \u002F\u002F props\r\n \u002F\u002F This flag is matched when the element has dynamic prop\u002Fattr bindings\r\n \u002F\u002F other than class and style. The keys of dynamic prop\u002Fattrs are saved for\r\n \u002F\u002F faster iteration.\r\n \u002F\u002F Note dynamic keys like :[foo]=\"bar\" will cause this optimization to\r\n \u002F\u002F bail out and go through a full diff because we need to unset the old key\r\n if (patchFlag & 8 \u002F* PROPS *\u002F) {\r\n \u002F\u002F if the flag is present then dynamicProps must be non-null\r\n const propsToUpdate = n2.dynamicProps;\r\n for (let i = 0; i \u003C propsToUpdate.length; i++) {\r\n const key = propsToUpdate[i];\r\n const prev = oldProps[key];\r\n const next = newProps[key];\r\n if (prev !== next) {\r\n hostPatchProp(el, key, next, prev, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);\r\n }\r\n }\r\n }\r\n }\r\n \u002F\u002F text\r\n \u002F\u002F This flag is matched when the element has only dynamic text children.\r\n \u002F\u002F this flag is terminal (i.e. skips children diffing).\r\n if (patchFlag & 1 \u002F* TEXT *\u002F) {\r\n if (n1.children !== n2.children) {\r\n hostSetElementText(el, n2.children);\r\n }\r\n return; \u002F\u002F terminal\r\n }\r\n }\r\n else if (!optimized && dynamicChildren == null) {\r\n \u002F\u002F unoptimized, full diff\r\n patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);\r\n }\r\n if (dynamicChildren != null) {\r\n patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, isSVG);\r\n }\r\n else if (!optimized) {\r\n \u002F\u002F full diff\r\n patchChildren(n1, n2, el, null, parentComponent, parentSuspense, isSVG);\r\n }\r\n if (newProps.onVnodeUpdated != null) {\r\n queuePostRenderEffect(() =\u003E {\r\n invokeDirectiveHook(newProps.onVnodeUpdated, parentComponent, n2, n1);\r\n }, parentSuspense);\r\n }\r\n }\r\n \u002F\u002F The fast path for blocks.\r\n function patchBlockChildren(oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) {\r\n for (let i = 0; i \u003C newChildren.length; i++) {\r\n const oldVNode = oldChildren[i];\r\n patch(oldVNode, newChildren[i], \r\n \u002F\u002F in the case of a Fragment, we need to provide the actual parent\r\n \u002F\u002F of the Fragment itself so it can move its children. In other cases,\r\n \u002F\u002F the parent container is not actually used so we just pass the\r\n \u002F\u002F block element here to avoid a DOM parentNode call.\r\n oldVNode.type === Fragment\r\n ? hostParentNode(oldVNode.el)\r\n : fallbackContainer, null, parentComponent, parentSuspense, isSVG, true);\r\n }\r\n }\r\n function patchProps(el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) {\r\n if (oldProps !== newProps) {\r\n for (const key in newProps) {\r\n if (isReservedProp(key))\r\n continue;\r\n const next = newProps[key];\r\n const prev = oldProps[key];\r\n if (next !== prev) {\r\n hostPatchProp(el, key, next, prev, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n }\r\n }\r\n if (oldProps !== EMPTY_OBJ) {\r\n for (const key in oldProps) {\r\n if (isReservedProp(key))\r\n continue;\r\n if (!(key in newProps)) {\r\n hostPatchProp(el, key, null, null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);\r\n }\r\n }\r\n }\r\n }\r\n }\r\n let devFragmentID = 0;\r\n function processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n const fragmentStartAnchor = (n2.el = n1\r\n ? n1.el\r\n : hostCreateComment( `fragment-${devFragmentID}-start` ));\r\n const fragmentEndAnchor = (n2.anchor = n1\r\n ? n1.anchor\r\n : hostCreateComment( `fragment-${devFragmentID}-end` ));\r\n {\r\n devFragmentID++;\r\n }\r\n if (n1 == null) {\r\n hostInsert(fragmentStartAnchor, container, anchor);\r\n hostInsert(fragmentEndAnchor, container, anchor);\r\n \u002F\u002F a fragment can only have array children\r\n \u002F\u002F since they are either generated by the compiler, or implicitly created\r\n \u002F\u002F from arrays.\r\n mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else {\r\n patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n }\r\n function processPortal(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n const targetSelector = n2.props && n2.props.target;\r\n const { patchFlag, shapeFlag, children } = n2;\r\n if (n1 == null) {\r\n const target = (n2.target = isString(targetSelector)\r\n ? hostQuerySelector(targetSelector)\r\n : targetSelector);\r\n if (target != null) {\r\n if (shapeFlag & 8 \u002F* TEXT_CHILDREN *\u002F) {\r\n hostSetElementText(target, children);\r\n }\r\n else if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n mountChildren(children, target, null, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n }\r\n else {\r\n warn('Invalid Portal target on mount:', target, `(${typeof target})`);\r\n }\r\n }\r\n else {\r\n \u002F\u002F update content\r\n const target = (n2.target = n1.target);\r\n if (patchFlag === 1 \u002F* TEXT *\u002F) {\r\n hostSetElementText(target, children);\r\n }\r\n else if (n2.dynamicChildren) {\r\n \u002F\u002F fast path when the portal happens to be a block root\r\n patchBlockChildren(n1.dynamicChildren, n2.dynamicChildren, container, parentComponent, parentSuspense, isSVG);\r\n }\r\n else if (!optimized) {\r\n patchChildren(n1, n2, target, null, parentComponent, parentSuspense, isSVG);\r\n }\r\n \u002F\u002F target changed\r\n if (targetSelector !== (n1.props && n1.props.target)) {\r\n const nextTarget = (n2.target = isString(targetSelector)\r\n ? hostQuerySelector(targetSelector)\r\n : targetSelector);\r\n if (nextTarget != null) {\r\n \u002F\u002F move content\r\n if (shapeFlag & 8 \u002F* TEXT_CHILDREN *\u002F) {\r\n hostSetElementText(target, '');\r\n hostSetElementText(nextTarget, children);\r\n }\r\n else if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n for (let i = 0; i \u003C children.length; i++) {\r\n move(children[i], nextTarget, null);\r\n }\r\n }\r\n }\r\n else {\r\n warn('Invalid Portal target on update:', target, `(${typeof target})`);\r\n }\r\n }\r\n }\r\n \u002F\u002F insert an empty node as the placeholder for the portal\r\n processCommentNode(n1, n2, container, anchor);\r\n }\r\n function processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n if (n1 == null) {\r\n if (n2.shapeFlag & 256 \u002F* COMPONENT_KEPT_ALIVE *\u002F) {\r\n parentComponent.sink.activate(n2, container, anchor);\r\n }\r\n else {\r\n mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG);\r\n }\r\n }\r\n else {\r\n const instance = (n2.component = n1.component);\r\n if (shouldUpdateComponent(n1, n2, optimized)) {\r\n if (\r\n instance.asyncDep &&\r\n !instance.asyncResolved) {\r\n \u002F\u002F async & still pending - just update props and slots\r\n \u002F\u002F since the component's reactive effect for render isn't set-up yet\r\n {\r\n pushWarningContext(n2);\r\n }\r\n updateComponentPreRender(instance, n2);\r\n {\r\n popWarningContext();\r\n }\r\n return;\r\n }\r\n else {\r\n \u002F\u002F normal update\r\n instance.next = n2;\r\n \u002F\u002F instance.update is the reactive effect runner.\r\n instance.update();\r\n }\r\n }\r\n else {\r\n \u002F\u002F no update needed. just copy over properties\r\n n2.component = n1.component;\r\n n2.el = n1.el;\r\n }\r\n }\r\n if (n2.ref !== null && parentComponent !== null) {\r\n if ( !(n2.shapeFlag & 4 \u002F* STATEFUL_COMPONENT *\u002F)) {\r\n pushWarningContext(n2);\r\n warn(`Functional components do not support \"ref\" because they do not ` +\r\n `have instances.`);\r\n popWarningContext();\r\n }\r\n setRef(n2.ref, n1 && n1.ref, parentComponent, n2.component.renderProxy);\r\n }\r\n }\r\n function mountComponent(initialVNode, container, anchor, parentComponent, parentSuspense, isSVG) {\r\n const instance = (initialVNode.component = createComponentInstance(initialVNode, parentComponent));\r\n {\r\n pushWarningContext(initialVNode);\r\n }\r\n const Comp = initialVNode.type;\r\n \u002F\u002F inject renderer internals for keepAlive\r\n if (Comp.__isKeepAlive) {\r\n const sink = instance.sink;\r\n sink.renderer = internals;\r\n sink.parentSuspense = parentSuspense;\r\n }\r\n \u002F\u002F resolve props and slots for setup context\r\n const propsOptions = Comp.props;\r\n resolveProps(instance, initialVNode.props, propsOptions);\r\n resolveSlots(instance, initialVNode.children);\r\n \u002F\u002F setup stateful logic\r\n if (initialVNode.shapeFlag & 4 \u002F* STATEFUL_COMPONENT *\u002F) {\r\n setupStatefulComponent(instance, parentSuspense);\r\n }\r\n \u002F\u002F setup() is async. This component relies on async logic to be resolved\r\n \u002F\u002F before proceeding\r\n if ( instance.asyncDep) {\r\n if (!parentSuspense) {\r\n warn('async setup() is used without a suspense boundary!');\r\n return;\r\n }\r\n parentSuspense.registerDep(instance, setupRenderEffect);\r\n \u002F\u002F give it a placeholder\r\n const placeholder = (instance.subTree = createVNode(Comment));\r\n processCommentNode(null, placeholder, container, anchor);\r\n initialVNode.el = placeholder.el;\r\n return;\r\n }\r\n setupRenderEffect(instance, parentComponent, parentSuspense, initialVNode, container, anchor, isSVG);\r\n {\r\n popWarningContext();\r\n }\r\n }\r\n function setupRenderEffect(instance, parentComponent, parentSuspense, initialVNode, container, anchor, isSVG) {\r\n \u002F\u002F create reactive effect for rendering\r\n let mounted = false;\r\n instance.update = effect(function componentEffect() {\r\n if (!mounted) {\r\n const subTree = (instance.subTree = renderComponentRoot(instance));\r\n \u002F\u002F beforeMount hook\r\n if (instance.bm !== null) {\r\n invokeHooks(instance.bm);\r\n }\r\n patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);\r\n initialVNode.el = subTree.el;\r\n \u002F\u002F mounted hook\r\n if (instance.m !== null) {\r\n queuePostRenderEffect(instance.m, parentSuspense);\r\n }\r\n \u002F\u002F activated hook for keep-alive roots.\r\n if (instance.a !== null &&\r\n instance.vnode.shapeFlag & 128 \u002F* COMPONENT_SHOULD_KEEP_ALIVE *\u002F) {\r\n queuePostRenderEffect(instance.a, parentSuspense);\r\n }\r\n mounted = true;\r\n }\r\n else {\r\n \u002F\u002F updateComponent\r\n \u002F\u002F This is triggered by mutation of component's own state (next: null)\r\n \u002F\u002F OR parent calling processComponent (next: HostVNode)\r\n const { next } = instance;\r\n {\r\n pushWarningContext(next || instance.vnode);\r\n }\r\n if (next !== null) {\r\n updateComponentPreRender(instance, next);\r\n }\r\n const prevTree = instance.subTree;\r\n const nextTree = (instance.subTree = renderComponentRoot(instance));\r\n \u002F\u002F beforeUpdate hook\r\n if (instance.bu !== null) {\r\n invokeHooks(instance.bu);\r\n }\r\n \u002F\u002F reset refs\r\n \u002F\u002F only needed if previous patch had refs\r\n if (instance.refs !== EMPTY_OBJ) {\r\n instance.refs = {};\r\n }\r\n patch(prevTree, nextTree, \r\n \u002F\u002F parent may have changed if it's in a portal\r\n hostParentNode(prevTree.el), \r\n \u002F\u002F anchor may have changed if it's in a fragment\r\n getNextHostNode(prevTree), instance, parentSuspense, isSVG);\r\n instance.vnode.el = nextTree.el;\r\n if (next === null) {\r\n \u002F\u002F self-triggered update. In case of HOC, update parent component\r\n \u002F\u002F vnode el. HOC is indicated by parent instance's subTree pointing\r\n \u002F\u002F to child component's vnode\r\n updateHOCHostEl(instance, nextTree.el);\r\n }\r\n \u002F\u002F updated hook\r\n if (instance.u !== null) {\r\n queuePostRenderEffect(instance.u, parentSuspense);\r\n }\r\n {\r\n popWarningContext();\r\n }\r\n }\r\n }, createDevEffectOptions(instance) );\r\n }\r\n function updateComponentPreRender(instance, nextVNode) {\r\n nextVNode.component = instance;\r\n instance.vnode = nextVNode;\r\n instance.next = null;\r\n resolveProps(instance, nextVNode.props, nextVNode.type.props);\r\n resolveSlots(instance, nextVNode.children);\r\n }\r\n function patchChildren(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) {\r\n const c1 = n1 && n1.children;\r\n const prevShapeFlag = n1 ? n1.shapeFlag : 0;\r\n const c2 = n2.children;\r\n const { patchFlag, shapeFlag } = n2;\r\n if (patchFlag === -1 \u002F* BAIL *\u002F) {\r\n optimized = false;\r\n }\r\n \u002F\u002F fast path\r\n if (patchFlag \u003E 0) {\r\n if (patchFlag & 64 \u002F* KEYED_FRAGMENT *\u002F) {\r\n \u002F\u002F this could be either fully-keyed or mixed (some keyed some not)\r\n \u002F\u002F presence of patchFlag means children are guaranteed to be arrays\r\n patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n return;\r\n }\r\n else if (patchFlag & 128 \u002F* UNKEYED_FRAGMENT *\u002F) {\r\n \u002F\u002F unkeyed\r\n patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n return;\r\n }\r\n }\r\n \u002F\u002F children has 3 possibilities: text, array or no children.\r\n if (shapeFlag & 8 \u002F* TEXT_CHILDREN *\u002F) {\r\n \u002F\u002F text children fast path\r\n if (prevShapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n unmountChildren(c1, parentComponent, parentSuspense);\r\n }\r\n if (c2 !== c1) {\r\n hostSetElementText(container, c2);\r\n }\r\n }\r\n else {\r\n if (prevShapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n \u002F\u002F prev children was array\r\n if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n \u002F\u002F two arrays, cannot assume anything, do full diff\r\n patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else {\r\n \u002F\u002F no new children, just unmount old\r\n unmountChildren(c1, parentComponent, parentSuspense, true);\r\n }\r\n }\r\n else {\r\n \u002F\u002F prev children was text OR null\r\n \u002F\u002F new children is array OR null\r\n if (prevShapeFlag & 8 \u002F* TEXT_CHILDREN *\u002F) {\r\n hostSetElementText(container, '');\r\n }\r\n \u002F\u002F mount new if array\r\n if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n }\r\n }\r\n }\r\n function patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n c1 = c1 || EMPTY_ARR;\r\n c2 = c2 || EMPTY_ARR;\r\n const oldLength = c1.length;\r\n const newLength = c2.length;\r\n const commonLength = Math.min(oldLength, newLength);\r\n let i;\r\n for (i = 0; i \u003C commonLength; i++) {\r\n const nextChild = optimized\r\n ? c2[i]\r\n : (c2[i] = normalizeVNode(c2[i]));\r\n patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n if (oldLength \u003E newLength) {\r\n \u002F\u002F remove old\r\n unmountChildren(c1, parentComponent, parentSuspense, true, commonLength);\r\n }\r\n else {\r\n \u002F\u002F mount new\r\n mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);\r\n }\r\n }\r\n \u002F\u002F can be all-keyed or mixed\r\n function patchKeyedChildren(c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) {\r\n let i = 0;\r\n const l2 = c2.length;\r\n let e1 = c1.length - 1; \u002F\u002F prev ending index\r\n let e2 = l2 - 1; \u002F\u002F next ending index\r\n \u002F\u002F 1. sync from start\r\n \u002F\u002F (a b) c\r\n \u002F\u002F (a b) d e\r\n while (i \u003C= e1 && i \u003C= e2) {\r\n const n1 = c1[i];\r\n const n2 = optimized\r\n ? c2[i]\r\n : (c2[i] = normalizeVNode(c2[i]));\r\n if (isSameType$1(n1, n2)) {\r\n patch(n1, n2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else {\r\n break;\r\n }\r\n i++;\r\n }\r\n \u002F\u002F 2. sync from end\r\n \u002F\u002F a (b c)\r\n \u002F\u002F d e (b c)\r\n while (i \u003C= e1 && i \u003C= e2) {\r\n const n1 = c1[e1];\r\n const n2 = optimized\r\n ? c2[i]\r\n : (c2[e2] = normalizeVNode(c2[e2]));\r\n if (isSameType$1(n1, n2)) {\r\n patch(n1, n2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized);\r\n }\r\n else {\r\n break;\r\n }\r\n e1--;\r\n e2--;\r\n }\r\n \u002F\u002F 3. common sequence + mount\r\n \u002F\u002F (a b)\r\n \u002F\u002F (a b) c\r\n \u002F\u002F i = 2, e1 = 1, e2 = 2\r\n \u002F\u002F (a b)\r\n \u002F\u002F c (a b)\r\n \u002F\u002F i = 0, e1 = -1, e2 = 0\r\n if (i \u003E e1) {\r\n if (i \u003C= e2) {\r\n const nextPos = e2 + 1;\r\n const anchor = nextPos \u003C l2 ? c2[nextPos].el : parentAnchor;\r\n while (i \u003C= e2) {\r\n patch(null, optimized ? c2[i] : (c2[i] = normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG);\r\n i++;\r\n }\r\n }\r\n }\r\n \u002F\u002F 4. common sequence + unmount\r\n \u002F\u002F (a b) c\r\n \u002F\u002F (a b)\r\n \u002F\u002F i = 2, e1 = 2, e2 = 1\r\n \u002F\u002F a (b c)\r\n \u002F\u002F (b c)\r\n \u002F\u002F i = 0, e1 = 0, e2 = -1\r\n else if (i \u003E e2) {\r\n while (i \u003C= e1) {\r\n unmount(c1[i], parentComponent, parentSuspense, true);\r\n i++;\r\n }\r\n }\r\n \u002F\u002F 5. unknown sequence\r\n \u002F\u002F [i ... e1 + 1]: a b [c d e] f g\r\n \u002F\u002F [i ... e2 + 1]: a b [e d c h] f g\r\n \u002F\u002F i = 2, e1 = 4, e2 = 5\r\n else {\r\n const s1 = i; \u002F\u002F prev starting index\r\n const s2 = i; \u002F\u002F next starting index\r\n \u002F\u002F 5.1 build key:index map for newChildren\r\n const keyToNewIndexMap = new Map();\r\n for (i = s2; i \u003C= e2; i++) {\r\n const nextChild = optimized\r\n ? c2[i]\r\n : (c2[i] = normalizeVNode(c2[i]));\r\n if (nextChild.key != null) {\r\n if ( keyToNewIndexMap.has(nextChild.key)) {\r\n warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`);\r\n }\r\n keyToNewIndexMap.set(nextChild.key, i);\r\n }\r\n }\r\n \u002F\u002F 5.2 loop through old children left to be patched and try to patch\r\n \u002F\u002F matching nodes & remove nodes that are no longer present\r\n let j;\r\n let patched = 0;\r\n const toBePatched = e2 - s2 + 1;\r\n let moved = false;\r\n \u002F\u002F used to track whether any node has moved\r\n let maxNewIndexSoFar = 0;\r\n \u002F\u002F works as Map\u003CnewIndex, oldIndex\u003E\r\n \u002F\u002F Note that oldIndex is offset by +1\r\n \u002F\u002F and oldIndex = 0 is a special value indicating the new node has\r\n \u002F\u002F no corresponding old node.\r\n \u002F\u002F used for determining longest stable subsequence\r\n const newIndexToOldIndexMap = new Array(toBePatched);\r\n for (i = 0; i \u003C toBePatched; i++)\r\n newIndexToOldIndexMap[i] = 0;\r\n for (i = s1; i \u003C= e1; i++) {\r\n const prevChild = c1[i];\r\n if (patched \u003E= toBePatched) {\r\n \u002F\u002F all new children have been patched so this can only be a removal\r\n unmount(prevChild, parentComponent, parentSuspense, true);\r\n continue;\r\n }\r\n let newIndex;\r\n if (prevChild.key != null) {\r\n newIndex = keyToNewIndexMap.get(prevChild.key);\r\n }\r\n else {\r\n \u002F\u002F key-less node, try to locate a key-less node of the same type\r\n for (j = s2; j \u003C= e2; j++) {\r\n if (newIndexToOldIndexMap[j - s2] === 0 &&\r\n isSameType$1(prevChild, c2[j])) {\r\n newIndex = j;\r\n break;\r\n }\r\n }\r\n }\r\n if (newIndex === undefined) {\r\n unmount(prevChild, parentComponent, parentSuspense, true);\r\n }\r\n else {\r\n newIndexToOldIndexMap[newIndex - s2] = i + 1;\r\n if (newIndex \u003E= maxNewIndexSoFar) {\r\n maxNewIndexSoFar = newIndex;\r\n }\r\n else {\r\n moved = true;\r\n }\r\n patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);\r\n patched++;\r\n }\r\n }\r\n \u002F\u002F 5.3 move and mount\r\n \u002F\u002F generate longest stable subsequence only when nodes have moved\r\n const increasingNewIndexSequence = moved\r\n ? getSequence(newIndexToOldIndexMap)\r\n : EMPTY_ARR;\r\n j = increasingNewIndexSequence.length - 1;\r\n \u002F\u002F looping backwards so that we can use last patched node as anchor\r\n for (i = toBePatched - 1; i \u003E= 0; i--) {\r\n const nextIndex = s2 + i;\r\n const nextChild = c2[nextIndex];\r\n const anchor = nextIndex + 1 \u003C l2\r\n ? c2[nextIndex + 1].el\r\n : parentAnchor;\r\n if (newIndexToOldIndexMap[i] === 0) {\r\n \u002F\u002F mount new\r\n patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);\r\n }\r\n else if (moved) {\r\n \u002F\u002F move if:\r\n \u002F\u002F There is no stable subsequence (e.g. a reverse)\r\n \u002F\u002F OR current node is not among the stable sequence\r\n if (j \u003C 0 || i !== increasingNewIndexSequence[j]) {\r\n move(nextChild, container, anchor);\r\n }\r\n else {\r\n j--;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n function move(vnode, container, anchor) {\r\n if (vnode.shapeFlag & 6 \u002F* COMPONENT *\u002F) {\r\n move(vnode.component.subTree, container, anchor);\r\n return;\r\n }\r\n if ( vnode.shapeFlag & 64 \u002F* SUSPENSE *\u002F) {\r\n vnode.suspense.move(container, anchor);\r\n return;\r\n }\r\n if (vnode.type === Fragment) {\r\n hostInsert(vnode.el, container, anchor);\r\n const children = vnode.children;\r\n for (let i = 0; i \u003C children.length; i++) {\r\n move(children[i], container, anchor);\r\n }\r\n hostInsert(vnode.anchor, container, anchor);\r\n }\r\n else {\r\n hostInsert(vnode.el, container, anchor);\r\n }\r\n }\r\n function unmount(vnode, parentComponent, parentSuspense, doRemove) {\r\n const { props, ref, type, children, dynamicChildren, shapeFlag, anchor } = vnode;\r\n \u002F\u002F unset ref\r\n if (ref !== null && parentComponent !== null) {\r\n setRef(ref, null, parentComponent, null);\r\n }\r\n if (shapeFlag & 6 \u002F* COMPONENT *\u002F) {\r\n if (shapeFlag & 128 \u002F* COMPONENT_SHOULD_KEEP_ALIVE *\u002F) {\r\n parentComponent.sink.deactivate(vnode);\r\n }\r\n else {\r\n unmountComponent(vnode.component, parentSuspense, doRemove);\r\n }\r\n return;\r\n }\r\n if ( shapeFlag & 64 \u002F* SUSPENSE *\u002F) {\r\n vnode.suspense.unmount(parentSuspense, doRemove);\r\n return;\r\n }\r\n if (props != null && props.onVnodeBeforeUnmount != null) {\r\n invokeDirectiveHook(props.onVnodeBeforeUnmount, parentComponent, vnode);\r\n }\r\n const shouldRemoveChildren = type === Fragment && doRemove;\r\n if (dynamicChildren != null) {\r\n unmountChildren(dynamicChildren, parentComponent, parentSuspense, shouldRemoveChildren);\r\n }\r\n else if (shapeFlag & 16 \u002F* ARRAY_CHILDREN *\u002F) {\r\n unmountChildren(children, parentComponent, parentSuspense, shouldRemoveChildren);\r\n }\r\n if (doRemove) {\r\n hostRemove(vnode.el);\r\n if (anchor != null)\r\n hostRemove(anchor);\r\n }\r\n if (props != null && props.onVnodeUnmounted != null) {\r\n queuePostRenderEffect(() =\u003E {\r\n invokeDirectiveHook(props.onVnodeUnmounted, parentComponent, vnode);\r\n }, parentSuspense);\r\n }\r\n }\r\n function unmountComponent(instance, parentSuspense, doRemove) {\r\n const { bum, effects, update, subTree, um, da, isDeactivated } = instance;\r\n \u002F\u002F beforeUnmount hook\r\n if (bum !== null) {\r\n invokeHooks(bum);\r\n }\r\n if (effects !== null) {\r\n for (let i = 0; i \u003C effects.length; i++) {\r\n stop(effects[i]);\r\n }\r\n }\r\n \u002F\u002F update may be null if a component is unmounted before its async\r\n \u002F\u002F setup has resolved.\r\n if (update !== null) {\r\n stop(update);\r\n unmount(subTree, instance, parentSuspense, doRemove);\r\n }\r\n \u002F\u002F unmounted hook\r\n if (um !== null) {\r\n queuePostRenderEffect(um, parentSuspense);\r\n }\r\n \u002F\u002F deactivated hook\r\n if (da !== null &&\r\n !isDeactivated &&\r\n instance.vnode.shapeFlag & 128 \u002F* COMPONENT_SHOULD_KEEP_ALIVE *\u002F) {\r\n queuePostRenderEffect(da, parentSuspense);\r\n }\r\n queuePostFlushCb(() =\u003E {\r\n instance.isUnmounted = true;\r\n });\r\n \u002F\u002F A component with async dep inside a pending suspense is unmounted before\r\n \u002F\u002F its async dep resolves. This should remove the dep from the suspense, and\r\n \u002F\u002F cause the suspense to resolve immediately if that was the last dep.\r\n if (\r\n parentSuspense !== null &&\r\n !parentSuspense.isResolved &&\r\n !parentSuspense.isUnmounted &&\r\n instance.asyncDep !== null &&\r\n !instance.asyncResolved) {\r\n parentSuspense.deps--;\r\n if (parentSuspense.deps === 0) {\r\n parentSuspense.resolve();\r\n }\r\n }\r\n }\r\n function unmountChildren(children, parentComponent, parentSuspense, doRemove, start = 0) {\r\n for (let i = start; i \u003C children.length; i++) {\r\n unmount(children[i], parentComponent, parentSuspense, doRemove);\r\n }\r\n }\r\n function getNextHostNode(vnode) {\r\n if (vnode.shapeFlag & 6 \u002F* COMPONENT *\u002F) {\r\n return getNextHostNode(vnode.component.subTree);\r\n }\r\n if ( vnode.shapeFlag & 64 \u002F* SUSPENSE *\u002F) {\r\n return vnode.suspense.next();\r\n }\r\n return hostNextSibling((vnode.anchor || vnode.el));\r\n }\r\n function setRef(ref, oldRef, parent, value) {\r\n const refs = parent.refs === EMPTY_OBJ ? (parent.refs = {}) : parent.refs;\r\n const renderContext = toRaw(parent.renderContext);\r\n \u002F\u002F unset old ref\r\n if (oldRef !== null && oldRef !== ref) {\r\n if (isString(oldRef)) {\r\n refs[oldRef] = null;\r\n const oldSetupRef = renderContext[oldRef];\r\n if (isRef(oldSetupRef)) {\r\n oldSetupRef.value = null;\r\n }\r\n }\r\n else if (isRef(oldRef)) {\r\n oldRef.value = null;\r\n }\r\n }\r\n if (isString(ref)) {\r\n const setupRef = renderContext[ref];\r\n if (isRef(setupRef)) {\r\n setupRef.value = value;\r\n }\r\n refs[ref] = value;\r\n }\r\n else if (isRef(ref)) {\r\n ref.value = value;\r\n }\r\n else if (isFunction(ref)) {\r\n callWithErrorHandling(ref, parent, 10 \u002F* FUNCTION_REF *\u002F, [value, refs]);\r\n }\r\n else {\r\n warn('Invalid template ref type:', value, `(${typeof value})`);\r\n }\r\n }\r\n const render = (vnode, container) =\u003E {\r\n if (vnode == null) {\r\n if (container._vnode) {\r\n unmount(container._vnode, null, null, true);\r\n }\r\n }\r\n else {\r\n patch(container._vnode || null, vnode, container);\r\n }\r\n flushPostFlushCbs();\r\n container._vnode = vnode;\r\n };\r\n return {\r\n render,\r\n createApp: createAppAPI(render)\r\n };\r\n}\r\n\u002F\u002F https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FLongest_increasing_subsequence\r\nfunction getSequence(arr) {\r\n const p = arr.slice();\r\n const result = [0];\r\n let i, j, u, v, c;\r\n const len = arr.length;\r\n for (i = 0; i \u003C len; i++) {\r\n const arrI = arr[i];\r\n if (arrI !== 0) {\r\n j = result[result.length - 1];\r\n if (arr[j] \u003C arrI) {\r\n p[i] = j;\r\n result.push(i);\r\n continue;\r\n }\r\n u = 0;\r\n v = result.length - 1;\r\n while (u \u003C v) {\r\n c = ((u + v) \u002F 2) | 0;\r\n if (arr[result[c]] \u003C arrI) {\r\n u = c + 1;\r\n }\r\n else {\r\n v = c;\r\n }\r\n }\r\n if (arrI \u003C arr[result[u]]) {\r\n if (u \u003E 0) {\r\n p[i] = result[u - 1];\r\n }\r\n result[u] = i;\r\n }\r\n }\r\n }\r\n u = result.length;\r\n v = result[u - 1];\r\n while (u-- \u003E 0) {\r\n result[u] = v;\r\n v = p[v];\r\n }\r\n return result;\r\n}\r\n\r\nconst KeepAliveImpl = {\r\n name: `KeepAlive`,\r\n \u002F\u002F Marker for special handling inside the renderer. We are not using a ===\r\n \u002F\u002F check directly on KeepAlive in the renderer, because importing it directly\r\n \u002F\u002F would prevent it from being tree-shaken.\r\n __isKeepAlive: true,\r\n setup(props, { slots }) {\r\n const cache = new Map();\r\n const keys = new Set();\r\n let current = null;\r\n const instance = getCurrentInstance();\r\n \u002F\u002F KeepAlive communicates with the instantiated renderer via the \"sink\"\r\n \u002F\u002F where the renderer passes in platform-specific functions, and the\r\n \u002F\u002F KeepAlivei instance expses activcate\u002Fdecativate implementations.\r\n \u002F\u002F The whole point of this is to avoid importing KeepAlive directly in the\r\n \u002F\u002F renderer to facilitate tree-shaking.\r\n const sink = instance.sink;\r\n const { renderer: { move, unmount: _unmount, options: { createElement } }, parentSuspense } = sink;\r\n const storageContainer = createElement('div');\r\n sink.activate = (vnode, container, anchor) =\u003E {\r\n move(vnode, container, anchor);\r\n queuePostRenderEffect(() =\u003E {\r\n const component = vnode.component;\r\n component.isDeactivated = false;\r\n if (component.a !== null) {\r\n invokeHooks(component.a);\r\n }\r\n }, parentSuspense);\r\n };\r\n sink.deactivate = (vnode) =\u003E {\r\n move(vnode, storageContainer, null);\r\n queuePostRenderEffect(() =\u003E {\r\n const component = vnode.component;\r\n if (component.da !== null) {\r\n invokeHooks(component.da);\r\n }\r\n component.isDeactivated = true;\r\n }, parentSuspense);\r\n };\r\n function unmount(vnode) {\r\n \u002F\u002F reset the shapeFlag so it can be properly unmounted\r\n vnode.shapeFlag = 4 \u002F* STATEFUL_COMPONENT *\u002F;\r\n _unmount(vnode, instance, parentSuspense);\r\n }\r\n function pruneCache(filter) {\r\n cache.forEach((vnode, key) =\u003E {\r\n const name = getName(vnode.type);\r\n if (name && (!filter || !filter(name))) {\r\n pruneCacheEntry(key);\r\n }\r\n });\r\n }\r\n function pruneCacheEntry(key) {\r\n const cached = cache.get(key);\r\n if (!current || cached.type !== current.type) {\r\n unmount(cached);\r\n }\r\n else if (current) {\r\n \u002F\u002F current active instance should no longer be kept-alive.\r\n \u002F\u002F we can't unmount it now but it might be later, so reset its flag now.\r\n current.shapeFlag = 4 \u002F* STATEFUL_COMPONENT *\u002F;\r\n }\r\n cache.delete(key);\r\n keys.delete(key);\r\n }\r\n watch(() =\u003E [props.include, props.exclude], ([include, exclude]) =\u003E {\r\n include && pruneCache(name =\u003E matches(include, name));\r\n exclude && pruneCache(name =\u003E matches(exclude, name));\r\n }, { lazy: true });\r\n onBeforeUnmount(() =\u003E {\r\n cache.forEach(unmount);\r\n });\r\n return () =\u003E {\r\n if (!slots.default) {\r\n return null;\r\n }\r\n const children = slots.default();\r\n let vnode = children[0];\r\n if (children.length \u003E 1) {\r\n {\r\n warn(`KeepAlive should contain exactly one component child.`);\r\n }\r\n current = null;\r\n return children;\r\n }\r\n else if (!isVNode(vnode) ||\r\n !(vnode.shapeFlag & 4 \u002F* STATEFUL_COMPONENT *\u002F)) {\r\n current = null;\r\n return vnode;\r\n }\r\n const comp = vnode.type;\r\n const name = getName(comp);\r\n const { include, exclude, max } = props;\r\n if ((include && (!name || !matches(include, name))) ||\r\n (exclude && name && matches(exclude, name))) {\r\n return vnode;\r\n }\r\n const key = vnode.key == null ? comp : vnode.key;\r\n const cached = cache.get(key);\r\n \u002F\u002F clone vnode if it's reused because we are going to mutate it\r\n if (vnode.el) {\r\n vnode = cloneVNode(vnode);\r\n }\r\n cache.set(key, vnode);\r\n if (cached) {\r\n \u002F\u002F copy over mounted state\r\n vnode.el = cached.el;\r\n vnode.anchor = cached.anchor;\r\n vnode.component = cached.component;\r\n \u002F\u002F avoid vnode being mounted as fresh\r\n vnode.shapeFlag |= 256 \u002F* COMPONENT_KEPT_ALIVE *\u002F;\r\n \u002F\u002F make this key the freshest\r\n keys.delete(key);\r\n keys.add(key);\r\n }\r\n else {\r\n keys.add(key);\r\n \u002F\u002F prune oldest entry\r\n if (max && keys.size \u003E parseInt(max, 10)) {\r\n pruneCacheEntry(Array.from(keys)[0]);\r\n }\r\n }\r\n \u002F\u002F avoid vnode being unmounted\r\n vnode.shapeFlag |= 128 \u002F* COMPONENT_SHOULD_KEEP_ALIVE *\u002F;\r\n current = vnode;\r\n return vnode;\r\n };\r\n }\r\n};\r\n{\r\n KeepAliveImpl.props = {\r\n include: [String, RegExp, Array],\r\n exclude: [String, RegExp, Array],\r\n max: [String, Number]\r\n };\r\n}\r\n\u002F\u002F export the public type for h\u002Ftsx inference\r\nconst KeepAlive = KeepAliveImpl;\r\nfunction getName(comp) {\r\n return comp.displayName || comp.name;\r\n}\r\nfunction matches(pattern, name) {\r\n if (isArray(pattern)) {\r\n return pattern.some((p) =\u003E matches(p, name));\r\n }\r\n else if (isString(pattern)) {\r\n return pattern.split(',').indexOf(name) \u003E -1;\r\n }\r\n else if (pattern.test) {\r\n return pattern.test(name);\r\n }\r\n \u002F* istanbul ignore next *\u002F\r\n return false;\r\n}\r\nfunction onActivated(hook, target) {\r\n registerKeepAliveHook(hook, \"a\" \u002F* ACTIVATED *\u002F, target);\r\n}\r\nfunction onDeactivated(hook, target) {\r\n registerKeepAliveHook(hook, \"da\" \u002F* DEACTIVATED *\u002F, target);\r\n}\r\nfunction registerKeepAliveHook(hook, type, target = currentInstance) {\r\n \u002F\u002F cache the deactivate branch check wrapper for injected hooks so the same\r\n \u002F\u002F hook can be properly deduped by the scheduler. \"__wdc\" stands for \"with\r\n \u002F\u002F deactivation check\".\r\n const wrappedHook = hook.__wdc ||\r\n (hook.__wdc = () =\u003E {\r\n \u002F\u002F only fire the hook if the target instance is NOT in a deactivated branch.\r\n let current = target;\r\n while (current) {\r\n if (current.isDeactivated) {\r\n return;\r\n }\r\n current = current.parent;\r\n }\r\n hook();\r\n });\r\n injectHook(type, wrappedHook, target);\r\n \u002F\u002F In addition to registering it on the target instance, we walk up the parent\r\n \u002F\u002F chain and register it on all ancestor instances that are keep-alive roots.\r\n \u002F\u002F This avoids the need to walk the entire component tree when invoking these\r\n \u002F\u002F hooks, and more importantly, avoids the need to track child components in\r\n \u002F\u002F arrays.\r\n if (target) {\r\n let current = target.parent;\r\n while (current && current.parent) {\r\n if (current.parent.type === KeepAliveImpl) {\r\n injectToKeepAliveRoot(wrappedHook, type, target, current);\r\n }\r\n current = current.parent;\r\n }\r\n }\r\n}\r\nfunction injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {\r\n injectHook(type, hook, keepAliveRoot, true \u002F* prepend *\u002F);\r\n onUnmounted(() =\u003E {\r\n const hooks = keepAliveRoot[type];\r\n hooks.splice(hooks.indexOf(hook), 1);\r\n }, target);\r\n}\r\n\r\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\r\n if (target) {\r\n const hooks = target[type] || (target[type] = []);\r\n \u002F\u002F cache the error handling wrapper for injected hooks so the same hook\r\n \u002F\u002F can be properly deduped by the scheduler. \"__weh\" stands for \"with error\r\n \u002F\u002F handling\".\r\n const wrappedHook = hook.__weh ||\r\n (hook.__weh = (...args) =\u003E {\r\n if (target.isUnmounted) {\r\n return;\r\n }\r\n \u002F\u002F disable tracking inside all lifecycle hooks\r\n \u002F\u002F since they can potentially be called inside effects.\r\n pauseTracking();\r\n \u002F\u002F Set currentInstance during hook invocation.\r\n \u002F\u002F This assumes the hook does not synchronously trigger other hooks, which\r\n \u002F\u002F can only be false when the user does something really funky.\r\n setCurrentInstance(target);\r\n const res = callWithAsyncErrorHandling(hook, target, type, args);\r\n setCurrentInstance(null);\r\n resumeTracking();\r\n return res;\r\n });\r\n if (prepend) {\r\n hooks.unshift(wrappedHook);\r\n }\r\n else {\r\n hooks.push(wrappedHook);\r\n }\r\n }\r\n else {\r\n const apiName = `on${capitalize(ErrorTypeStrings[type].replace(\u002F hook$\u002F, ''))}`;\r\n warn(`${apiName} is called when there is no active component instance to be ` +\r\n `associated with. ` +\r\n `Lifecycle injection APIs can only be used during execution of setup().` +\r\n ( ` If you are using async setup(), make sure to register lifecycle ` +\r\n `hooks before the first await statement.`\r\n ));\r\n }\r\n}\r\nconst createHook = (lifecycle) =\u003E (hook, target = currentInstance) =\u003E injectHook(lifecycle, hook, target);\r\nconst onBeforeMount = createHook(\"bm\" \u002F* BEFORE_MOUNT *\u002F);\r\nconst onMounted = createHook(\"m\" \u002F* MOUNTED *\u002F);\r\nconst onBeforeUpdate = createHook(\"bu\" \u002F* BEFORE_UPDATE *\u002F);\r\nconst onUpdated = createHook(\"u\" \u002F* UPDATED *\u002F);\r\nconst onBeforeUnmount = createHook(\"bum\" \u002F* BEFORE_UNMOUNT *\u002F);\r\nconst onUnmounted = createHook(\"um\" \u002F* UNMOUNTED *\u002F);\r\nconst onRenderTriggered = createHook(\"rtg\" \u002F* RENDER_TRIGGERED *\u002F);\r\nconst onRenderTracked = createHook(\"rtc\" \u002F* RENDER_TRACKED *\u002F);\r\nconst onErrorCaptured = createHook(\"ec\" \u002F* ERROR_CAPTURED *\u002F);\r\n\r\nconst invoke = (fn) =\u003E fn();\r\n\u002F\u002F implementation\r\nfunction watch(effectOrSource, cbOrOptions, options) {\r\n if (isFunction(cbOrOptions)) {\r\n \u002F\u002F effect callback as 2nd argument - this is a source watcher\r\n return doWatch(effectOrSource, cbOrOptions, options);\r\n }\r\n else {\r\n \u002F\u002F 2nd argument is either missing or an options object\r\n \u002F\u002F - this is a simple effect watcher\r\n return doWatch(effectOrSource, null, cbOrOptions);\r\n }\r\n}\r\nfunction doWatch(source, cb, { lazy, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {\r\n const instance = currentInstance;\r\n const suspense = currentSuspense;\r\n let getter;\r\n if (isArray(source)) {\r\n getter = () =\u003E source.map(s =\u003E isRef(s)\r\n ? s.value\r\n : callWithErrorHandling(s, instance, 2 \u002F* WATCH_GETTER *\u002F));\r\n }\r\n else if (isRef(source)) {\r\n getter = () =\u003E source.value;\r\n }\r\n else if (cb) {\r\n \u002F\u002F getter with cb\r\n getter = () =\u003E callWithErrorHandling(source, instance, 2 \u002F* WATCH_GETTER *\u002F);\r\n }\r\n else {\r\n \u002F\u002F no cb -\u003E simple effect\r\n getter = () =\u003E {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n return callWithErrorHandling(source, instance, 3 \u002F* WATCH_CALLBACK *\u002F, [registerCleanup]);\r\n };\r\n }\r\n if (deep) {\r\n const baseGetter = getter;\r\n getter = () =\u003E traverse(baseGetter());\r\n }\r\n let cleanup;\r\n const registerCleanup = (fn) =\u003E {\r\n cleanup = runner.options.onStop = () =\u003E {\r\n callWithErrorHandling(fn, instance, 4 \u002F* WATCH_CLEANUP *\u002F);\r\n };\r\n };\r\n let oldValue = isArray(source) ? [] : undefined;\r\n const applyCb = cb\r\n ? () =\u003E {\r\n if (instance && instance.isUnmounted) {\r\n return;\r\n }\r\n const newValue = runner();\r\n if (deep || hasChanged(newValue, oldValue)) {\r\n \u002F\u002F cleanup before running cb again\r\n if (cleanup) {\r\n cleanup();\r\n }\r\n callWithAsyncErrorHandling(cb, instance, 3 \u002F* WATCH_CALLBACK *\u002F, [\r\n newValue,\r\n oldValue,\r\n registerCleanup\r\n ]);\r\n oldValue = newValue;\r\n }\r\n }\r\n : void 0;\r\n let scheduler;\r\n if (flush === 'sync') {\r\n scheduler = invoke;\r\n }\r\n else if (flush === 'pre') {\r\n scheduler = job =\u003E {\r\n if (!instance || instance.vnode.el != null) {\r\n queueJob(job);\r\n }\r\n else {\r\n \u002F\u002F with 'pre' option, the first call must happen before\r\n \u002F\u002F the component is mounted so it is called synchronously.\r\n job();\r\n }\r\n };\r\n }\r\n else {\r\n scheduler = job =\u003E {\r\n queuePostRenderEffect(job, suspense);\r\n };\r\n }\r\n const runner = effect(getter, {\r\n lazy: true,\r\n \u002F\u002F so it runs before component update effects in pre flush mode\r\n computed: true,\r\n onTrack,\r\n onTrigger,\r\n scheduler: applyCb ? () =\u003E scheduler(applyCb) : scheduler\r\n });\r\n if (!lazy) {\r\n if (applyCb) {\r\n scheduler(applyCb);\r\n }\r\n else {\r\n scheduler(runner);\r\n }\r\n }\r\n else {\r\n oldValue = runner();\r\n }\r\n recordEffect(runner);\r\n return () =\u003E {\r\n stop(runner);\r\n };\r\n}\r\n\u002F\u002F this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n const ctx = this.renderProxy;\r\n const getter = isString(source) ? () =\u003E ctx[source] : source.bind(ctx);\r\n const stop = watch(getter, cb.bind(ctx), options);\r\n onBeforeUnmount(stop, this);\r\n return stop;\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n if (!isObject(value) || seen.has(value)) {\r\n return;\r\n }\r\n seen.add(value);\r\n if (isArray(value)) {\r\n for (let i = 0; i \u003C value.length; i++) {\r\n traverse(value[i], seen);\r\n }\r\n }\r\n else if (value instanceof Map) {\r\n value.forEach((v, key) =\u003E {\r\n \u002F\u002F to register mutation dep for existing keys\r\n traverse(value.get(key), seen);\r\n });\r\n }\r\n else if (value instanceof Set) {\r\n value.forEach(v =\u003E {\r\n traverse(v, seen);\r\n });\r\n }\r\n else {\r\n for (const key in value) {\r\n traverse(value[key], seen);\r\n }\r\n }\r\n return value;\r\n}\r\n\r\nconst publicPropertiesMap = {\r\n $data: 'data',\r\n $props: 'propsProxy',\r\n $attrs: 'attrs',\r\n $slots: 'slots',\r\n $refs: 'refs',\r\n $parent: 'parent',\r\n $root: 'root',\r\n $emit: 'emit',\r\n $options: 'type'\r\n};\r\nconst PublicInstanceProxyHandlers = {\r\n get(target, key) {\r\n \u002F\u002F fast path for unscopables when using `with` block\r\n if ( key === Symbol.unscopables) {\r\n return;\r\n }\r\n const { renderContext, data, props, propsProxy, accessCache, type, sink } = target;\r\n \u002F\u002F This getter gets called for every property access on the render context\r\n \u002F\u002F during render and is a major hotspot. The most expensive part of this\r\n \u002F\u002F is the multiple hasOwn() calls. It's much faster to do a simple property\r\n \u002F\u002F access on a plain object, so we use an accessCache object (with null\r\n \u002F\u002F prototype) to memoize what access type a key corresponds to.\r\n const n = accessCache[key];\r\n if (n !== undefined) {\r\n switch (n) {\r\n case 0 \u002F* DATA *\u002F:\r\n return data[key];\r\n case 1 \u002F* CONTEXT *\u002F:\r\n return renderContext[key];\r\n case 2 \u002F* PROPS *\u002F:\r\n return propsProxy[key];\r\n }\r\n }\r\n else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n accessCache[key] = 0 \u002F* DATA *\u002F;\r\n return data[key];\r\n }\r\n else if (hasOwn(renderContext, key)) {\r\n accessCache[key] = 1 \u002F* CONTEXT *\u002F;\r\n return renderContext[key];\r\n }\r\n else if (hasOwn(props, key)) {\r\n \u002F\u002F only cache props access if component has declared (thus stable) props\r\n if (type.props != null) {\r\n accessCache[key] = 2 \u002F* PROPS *\u002F;\r\n }\r\n \u002F\u002F return the value from propsProxy for ref unwrapping and readonly\r\n return propsProxy[key];\r\n }\r\n else if (key === '$cache') {\r\n return target.renderCache || (target.renderCache = []);\r\n }\r\n else if (key === '$el') {\r\n return target.vnode.el;\r\n }\r\n else if (hasOwn(publicPropertiesMap, key)) {\r\n if ( key === '$attrs') {\r\n markAttrsAccessed();\r\n }\r\n return target[publicPropertiesMap[key]];\r\n }\r\n \u002F\u002F methods are only exposed when options are supported\r\n {\r\n switch (key) {\r\n case '$forceUpdate':\r\n return target.update;\r\n case '$nextTick':\r\n return nextTick;\r\n case '$watch':\r\n return instanceWatch.bind(target);\r\n }\r\n }\r\n if (hasOwn(sink, key)) {\r\n return sink[key];\r\n }\r\n else if ( currentRenderingInstance != null) {\r\n warn(`Property ${JSON.stringify(key)} was accessed during render ` +\r\n `but is not defined on instance.`);\r\n }\r\n },\r\n set(target, key, value) {\r\n const { data, renderContext } = target;\r\n if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n data[key] = value;\r\n }\r\n else if (hasOwn(renderContext, key)) {\r\n renderContext[key] = value;\r\n }\r\n else if (key[0] === '

&& key.slice(1) in target) {\r\n \r\n warn(`Attempting to mutate public property \"${key}\". ` +\r\n `Properties starting with $ are reserved and readonly.`, target);\r\n return false;\r\n }\r\n else if (key in target.props) {\r\n \r\n warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, target);\r\n return false;\r\n }\r\n else {\r\n target.sink[key] = value;\r\n }\r\n return true;\r\n }\r\n};\r\n{\r\n \u002F\u002F this trap is only called in browser-compiled render functions that use\r\n \u002F\u002F `with (this) {}`\r\n PublicInstanceProxyHandlers.has = (_, key) =\u003E {\r\n return key[0] !== '_' && !isGloballyWhitelisted(key);\r\n };\r\n}\r\n\r\nfunction provide(key, value) {\r\n if (!currentInstance) {\r\n {\r\n warn(`provide() can only be used inside setup().`);\r\n }\r\n }\r\n else {\r\n let provides = currentInstance.provides;\r\n \u002F\u002F by default an instance inherits its parent's provides object\r\n \u002F\u002F but when it needs to provide values of its own, it creates its\r\n \u002F\u002F own provides object using parent provides object as prototype.\r\n \u002F\u002F this way in `inject` we can simply look up injections from direct\r\n \u002F\u002F parent and let the prototype chain do the work.\r\n const parentProvides = currentInstance.parent && currentInstance.parent.provides;\r\n if (parentProvides === provides) {\r\n provides = currentInstance.provides = Object.create(parentProvides);\r\n }\r\n \u002F\u002F TS doesn't allow symbol as index type\r\n provides[key] = value;\r\n }\r\n}\r\nfunction inject(key, defaultValue) {\r\n \u002F\u002F fallback to `currentRenderingInstance` so that this can be called in\r\n \u002F\u002F a functional component\r\n const instance = currentInstance || currentRenderingInstance;\r\n if (instance) {\r\n const provides = instance.provides;\r\n if (key in provides) {\r\n \u002F\u002F TS doesn't allow symbol as index type\r\n return provides[key];\r\n }\r\n else if (defaultValue !== undefined) {\r\n return defaultValue;\r\n }\r\n else {\r\n warn(`injection \"${String(key)}\" not found.`);\r\n }\r\n }\r\n else {\r\n warn(`inject() can only be used inside setup() or functional components.`);\r\n }\r\n}\r\n\r\nfunction createDuplicateChecker() {\r\n const cache = Object.create(null);\r\n return (type, key) =\u003E {\r\n if (cache[key]) {\r\n warn(`${type} property \"${key}\" is already defined in ${cache[key]}.`);\r\n }\r\n else {\r\n cache[key] = type;\r\n }\r\n };\r\n}\r\nfunction applyOptions(instance, options, asMixin = false) {\r\n const renderContext = instance.renderContext === EMPTY_OBJ\r\n ? (instance.renderContext = reactive({}))\r\n : instance.renderContext;\r\n const ctx = instance.renderProxy;\r\n const { \r\n \u002F\u002F composition\r\n mixins, extends: extendsOptions, \r\n \u002F\u002F state\r\n props: propsOptions, data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, \r\n \u002F\u002F assets\r\n components, directives, \r\n \u002F\u002F lifecycle\r\n beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, renderTracked, renderTriggered, errorCaptured } = options;\r\n const globalMixins = instance.appContext.mixins;\r\n \u002F\u002F call it only during dev\r\n const checkDuplicateProperties = createDuplicateChecker() ;\r\n \u002F\u002F applyOptions is called non-as-mixin once per instance\r\n if (!asMixin) {\r\n callSyncHook('beforeCreate', options, ctx, globalMixins);\r\n \u002F\u002F global mixins are applied first\r\n applyMixins(instance, globalMixins);\r\n }\r\n \u002F\u002F extending a base component...\r\n if (extendsOptions) {\r\n applyOptions(instance, extendsOptions, true);\r\n }\r\n \u002F\u002F local mixins\r\n if (mixins) {\r\n applyMixins(instance, mixins);\r\n }\r\n if ( propsOptions) {\r\n for (const key in propsOptions) {\r\n checkDuplicateProperties(\"Props\" \u002F* PROPS *\u002F, key);\r\n }\r\n }\r\n \u002F\u002F state options\r\n if (dataOptions) {\r\n const data = isFunction(dataOptions) ? dataOptions.call(ctx) : dataOptions;\r\n if (!isObject(data)) {\r\n warn(`data() should return an object.`);\r\n }\r\n else if (instance.data === EMPTY_OBJ) {\r\n {\r\n for (const key in data) {\r\n checkDuplicateProperties(\"Data\" \u002F* DATA *\u002F, key);\r\n }\r\n }\r\n instance.data = reactive(data);\r\n }\r\n else {\r\n \u002F\u002F existing data: this is a mixin or extends.\r\n extend(instance.data, data);\r\n }\r\n }\r\n if (computedOptions) {\r\n for (const key in computedOptions) {\r\n const opt = computedOptions[key];\r\n checkDuplicateProperties(\"Computed\" \u002F* COMPUTED *\u002F, key);\r\n if (isFunction(opt)) {\r\n renderContext[key] = computed$1(opt.bind(ctx));\r\n }\r\n else {\r\n const { get, set } = opt;\r\n if (isFunction(get)) {\r\n renderContext[key] = computed$1({\r\n get: get.bind(ctx),\r\n set: isFunction(set)\r\n ? set.bind(ctx)\r\n : () =\u003E {\r\n warn(`Computed property \"${key}\" was assigned to but it has no setter.`);\r\n }\r\n \r\n });\r\n }\r\n else {\r\n warn(`Computed property \"${key}\" has no getter.`);\r\n }\r\n }\r\n }\r\n }\r\n if (methods) {\r\n for (const key in methods) {\r\n const methodHandler = methods[key];\r\n if (isFunction(methodHandler)) {\r\n checkDuplicateProperties(\"Methods\" \u002F* METHODS *\u002F, key);\r\n renderContext[key] = methodHandler.bind(ctx);\r\n }\r\n else {\r\n warn(`Method \"${key}\" has type \"${typeof methodHandler}\" in the component definition. ` +\r\n `Did you reference the function correctly?`);\r\n }\r\n }\r\n }\r\n if (watchOptions) {\r\n for (const key in watchOptions) {\r\n createWatcher(watchOptions[key], renderContext, ctx, key);\r\n }\r\n }\r\n if (provideOptions) {\r\n const provides = isFunction(provideOptions)\r\n ? provideOptions.call(ctx)\r\n : provideOptions;\r\n for (const key in provides) {\r\n provide(key, provides[key]);\r\n }\r\n }\r\n if (injectOptions) {\r\n if (isArray(injectOptions)) {\r\n for (let i = 0; i \u003C injectOptions.length; i++) {\r\n const key = injectOptions[i];\r\n checkDuplicateProperties(\"Inject\" \u002F* INJECT *\u002F, key);\r\n renderContext[key] = inject(key);\r\n }\r\n }\r\n else {\r\n for (const key in injectOptions) {\r\n checkDuplicateProperties(\"Inject\" \u002F* INJECT *\u002F, key);\r\n const opt = injectOptions[key];\r\n if (isObject(opt)) {\r\n renderContext[key] = inject(opt.from, opt.default);\r\n }\r\n else {\r\n renderContext[key] = inject(opt);\r\n }\r\n }\r\n }\r\n }\r\n \u002F\u002F asset options\r\n if (components) {\r\n extend(instance.components, components);\r\n }\r\n if (directives) {\r\n extend(instance.directives, directives);\r\n }\r\n \u002F\u002F lifecycle options\r\n if (!asMixin) {\r\n callSyncHook('created', options, ctx, globalMixins);\r\n }\r\n if (beforeMount) {\r\n onBeforeMount(beforeMount.bind(ctx));\r\n }\r\n if (mounted) {\r\n onMounted(mounted.bind(ctx));\r\n }\r\n if (beforeUpdate) {\r\n onBeforeUpdate(beforeUpdate.bind(ctx));\r\n }\r\n if (updated) {\r\n onUpdated(updated.bind(ctx));\r\n }\r\n if (activated) {\r\n onActivated(activated.bind(ctx));\r\n }\r\n if (deactivated) {\r\n onDeactivated(deactivated.bind(ctx));\r\n }\r\n if (errorCaptured) {\r\n onErrorCaptured(errorCaptured.bind(ctx));\r\n }\r\n if (renderTracked) {\r\n onRenderTracked(renderTracked.bind(ctx));\r\n }\r\n if (renderTriggered) {\r\n onRenderTriggered(renderTriggered.bind(ctx));\r\n }\r\n if (beforeUnmount) {\r\n onBeforeUnmount(beforeUnmount.bind(ctx));\r\n }\r\n if (unmounted) {\r\n onUnmounted(unmounted.bind(ctx));\r\n }\r\n}\r\nfunction callSyncHook(name, options, ctx, globalMixins) {\r\n callHookFromMixins(name, globalMixins, ctx);\r\n const baseHook = options.extends && options.extends[name];\r\n if (baseHook) {\r\n baseHook.call(ctx);\r\n }\r\n const mixins = options.mixins;\r\n if (mixins) {\r\n callHookFromMixins(name, mixins, ctx);\r\n }\r\n const selfHook = options[name];\r\n if (selfHook) {\r\n selfHook.call(ctx);\r\n }\r\n}\r\nfunction callHookFromMixins(name, mixins, ctx) {\r\n for (let i = 0; i \u003C mixins.length; i++) {\r\n const fn = mixins[i][name];\r\n if (fn) {\r\n fn.call(ctx);\r\n }\r\n }\r\n}\r\nfunction applyMixins(instance, mixins) {\r\n for (let i = 0; i \u003C mixins.length; i++) {\r\n applyOptions(instance, mixins[i], true);\r\n }\r\n}\r\nfunction createWatcher(raw, renderContext, ctx, key) {\r\n const getter = () =\u003E ctx[key];\r\n if (isString(raw)) {\r\n const handler = renderContext[raw];\r\n if (isFunction(handler)) {\r\n watch(getter, handler);\r\n }\r\n else {\r\n warn(`Invalid watch handler specified by key \"${raw}\"`, handler);\r\n }\r\n }\r\n else if (isFunction(raw)) {\r\n watch(getter, raw.bind(ctx));\r\n }\r\n else if (isObject(raw)) {\r\n if (isArray(raw)) {\r\n raw.forEach(r =\u003E createWatcher(r, renderContext, ctx, key));\r\n }\r\n else {\r\n watch(getter, raw.handler.bind(ctx), raw);\r\n }\r\n }\r\n else {\r\n warn(`Invalid watch option: \"${key}\"`);\r\n }\r\n}\r\n\r\nconst emptyAppContext = createAppContext();\r\nfunction createComponentInstance(vnode, parent) {\r\n \u002F\u002F inherit parent app context - or - if root, adopt from root vnode\r\n const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;\r\n const instance = {\r\n vnode,\r\n parent,\r\n appContext,\r\n type: vnode.type,\r\n root: null,\r\n next: null,\r\n subTree: null,\r\n update: null,\r\n render: null,\r\n renderProxy: null,\r\n propsProxy: null,\r\n setupContext: null,\r\n effects: null,\r\n provides: parent ? parent.provides : Object.create(appContext.provides),\r\n accessCache: null,\r\n renderCache: null,\r\n \u002F\u002F setup context properties\r\n renderContext: EMPTY_OBJ,\r\n data: EMPTY_OBJ,\r\n props: EMPTY_OBJ,\r\n attrs: EMPTY_OBJ,\r\n slots: EMPTY_OBJ,\r\n refs: EMPTY_OBJ,\r\n \u002F\u002F per-instance asset storage (mutable during options resolution)\r\n components: Object.create(appContext.components),\r\n directives: Object.create(appContext.directives),\r\n \u002F\u002F async dependency management\r\n asyncDep: null,\r\n asyncResult: null,\r\n asyncResolved: false,\r\n \u002F\u002F user namespace for storing whatever the user assigns to `this`\r\n \u002F\u002F can also be used as a wildcard storage for ad-hoc injections internally\r\n sink: {},\r\n \u002F\u002F lifecycle hooks\r\n \u002F\u002F not using enums here because it results in computed properties\r\n isUnmounted: false,\r\n isDeactivated: false,\r\n bc: null,\r\n c: null,\r\n bm: null,\r\n m: null,\r\n bu: null,\r\n u: null,\r\n um: null,\r\n bum: null,\r\n da: null,\r\n a: null,\r\n rtg: null,\r\n rtc: null,\r\n ec: null,\r\n emit: (event, ...args) =\u003E {\r\n const props = instance.vnode.props || EMPTY_OBJ;\r\n const handler = props[`on${event}`] || props[`on${capitalize(event)}`];\r\n if (handler) {\r\n callWithAsyncErrorHandling(handler, instance, 6 \u002F* COMPONENT_EVENT_HANDLER *\u002F, args);\r\n }\r\n }\r\n };\r\n instance.root = parent ? parent.root : instance;\r\n return instance;\r\n}\r\nlet currentInstance = null;\r\nlet currentSuspense = null;\r\nconst getCurrentInstance = () =\u003E currentInstance;\r\nconst setCurrentInstance = (instance) =\u003E {\r\n currentInstance = instance;\r\n};\r\nconst isBuiltInTag = \u002F*#__PURE__*\u002F makeMap('slot,component');\r\nfunction validateComponentName(name, config) {\r\n const appIsNativeTag = config.isNativeTag || NO;\r\n if (isBuiltInTag(name) || appIsNativeTag(name)) {\r\n warn('Do not use built-in or reserved HTML elements as component id: ' + name);\r\n }\r\n}\r\nfunction setupStatefulComponent(instance, parentSuspense) {\r\n const Component = instance.type;\r\n {\r\n if (Component.name) {\r\n validateComponentName(Component.name, instance.appContext.config);\r\n }\r\n if (Component.components) {\r\n const names = Object.keys(Component.components);\r\n for (let i = 0; i \u003C names.length; i++) {\r\n validateComponentName(names[i], instance.appContext.config);\r\n }\r\n }\r\n if (Component.directives) {\r\n const names = Object.keys(Component.directives);\r\n for (let i = 0; i \u003C names.length; i++) {\r\n validateDirectiveName(names[i]);\r\n }\r\n }\r\n }\r\n \u002F\u002F 0. create render proxy property access cache\r\n instance.accessCache = {};\r\n \u002F\u002F 1. create render proxy\r\n instance.renderProxy = new Proxy(instance, PublicInstanceProxyHandlers);\r\n \u002F\u002F 2. create props proxy\r\n \u002F\u002F the propsProxy is a reactive AND readonly proxy to the actual props.\r\n \u002F\u002F it will be updated in resolveProps() on updates before render\r\n const propsProxy = (instance.propsProxy = readonlyProps(instance.props));\r\n \u002F\u002F 3. call setup()\r\n const { setup } = Component;\r\n if (setup) {\r\n const setupContext = (instance.setupContext =\r\n setup.length \u003E 1 ? createSetupContext(instance) : null);\r\n currentInstance = instance;\r\n currentSuspense = parentSuspense;\r\n const setupResult = callWithErrorHandling(setup, instance, 0 \u002F* SETUP_FUNCTION *\u002F, [propsProxy, setupContext]);\r\n currentInstance = null;\r\n currentSuspense = null;\r\n if (isPromise(setupResult)) {\r\n {\r\n \u002F\u002F async setup returned Promise.\r\n \u002F\u002F bail here and wait for re-entry.\r\n instance.asyncDep = setupResult;\r\n }\r\n }\r\n else {\r\n handleSetupResult(instance, setupResult, parentSuspense);\r\n }\r\n }\r\n else {\r\n finishComponentSetup(instance, parentSuspense);\r\n }\r\n}\r\nfunction handleSetupResult(instance, setupResult, parentSuspense) {\r\n if (isFunction(setupResult)) {\r\n \u002F\u002F setup returned an inline render function\r\n instance.render = setupResult;\r\n }\r\n else if (isObject(setupResult)) {\r\n if ( isVNode(setupResult)) {\r\n warn(`setup() should not return VNodes directly - ` +\r\n `return a render function instead.`);\r\n }\r\n \u002F\u002F setup returned bindings.\r\n \u002F\u002F assuming a render function compiled from template is present.\r\n instance.renderContext = reactive(setupResult);\r\n }\r\n else if ( setupResult !== undefined) {\r\n warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);\r\n }\r\n finishComponentSetup(instance, parentSuspense);\r\n}\r\nlet compile$1;\r\n\u002F\u002F exported method uses any to avoid d.ts relying on the compiler types.\r\nfunction registerRuntimeCompiler(_compile) {\r\n compile$1 = _compile;\r\n}\r\nfunction finishComponentSetup(instance, parentSuspense) {\r\n const Component = instance.type;\r\n if (!instance.render) {\r\n if ( Component.template && !Component.render) {\r\n \u002F\u002F true ensures `compile` is provided\r\n Component.render = compile$1(Component.template, {\r\n isCustomElement: instance.appContext.config.isCustomElement || NO,\r\n onError(err) {\r\n {\r\n const message = `Template compilation error: ${err.message}`;\r\n const codeFrame = err.loc &&\r\n generateCodeFrame(Component.template, err.loc.start.offset, err.loc.end.offset);\r\n warn(codeFrame ? `${message}\\n${codeFrame}` : message);\r\n }\r\n }\r\n });\r\n }\r\n if ( !Component.render) {\r\n \u002F* istanbul ignore if *\u002F\r\n {\r\n warn(`Component is missing${ ` template or` } render function.`);\r\n }\r\n }\r\n instance.render = (Component.render || NOOP);\r\n }\r\n \u002F\u002F support for 2.x options\r\n {\r\n currentInstance = instance;\r\n currentSuspense = parentSuspense;\r\n applyOptions(instance, Component);\r\n currentInstance = null;\r\n currentSuspense = null;\r\n }\r\n if (instance.renderContext === EMPTY_OBJ) {\r\n instance.renderContext = reactive({});\r\n }\r\n}\r\n\u002F\u002F used to identify a setup context proxy\r\nconst SetupProxySymbol = Symbol();\r\nconst SetupProxyHandlers = {};\r\n['attrs', 'slots'].forEach((type) =\u003E {\r\n SetupProxyHandlers[type] = {\r\n get: (instance, key) =\u003E instance[type][key],\r\n has: (instance, key) =\u003E key === SetupProxySymbol || key in instance[type],\r\n ownKeys: instance =\u003E Reflect.ownKeys(instance[type]),\r\n \u002F\u002F this is necessary for ownKeys to work properly\r\n getOwnPropertyDescriptor: (instance, key) =\u003E Reflect.getOwnPropertyDescriptor(instance[type], key),\r\n set: () =\u003E false,\r\n deleteProperty: () =\u003E false\r\n };\r\n});\r\nfunction createSetupContext(instance) {\r\n const context = {\r\n \u002F\u002F attrs & slots are non-reactive, but they need to always expose\r\n \u002F\u002F the latest values (instance.xxx may get replaced during updates) so we\r\n \u002F\u002F need to expose them through a proxy\r\n attrs: new Proxy(instance, SetupProxyHandlers.attrs),\r\n slots: new Proxy(instance, SetupProxyHandlers.slots),\r\n emit: instance.emit\r\n };\r\n return Object.freeze(context) ;\r\n}\r\n\r\n\u002F\u002F record effects created during a component's setup() so that they can be\r\n\u002F\u002F stopped when the component unmounts\r\nfunction recordEffect(effect) {\r\n if (currentInstance) {\r\n (currentInstance.effects || (currentInstance.effects = [])).push(effect);\r\n }\r\n}\r\nfunction computed$1(getterOrOptions) {\r\n const c = computed(getterOrOptions);\r\n recordEffect(c.effect);\r\n return c;\r\n}\r\n\r\n\u002F\u002F implementation, close to no-op\r\nfunction createComponent(options) {\r\n return isFunction(options) ? { setup: options } : options;\r\n}\r\n\r\n\u002F\u002F Actual implementation\r\nfunction h(type, propsOrChildren, children) {\r\n if (arguments.length === 2) {\r\n if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {\r\n \u002F\u002F single vnode without props\r\n if (isVNode(propsOrChildren)) {\r\n return createVNode(type, null, [propsOrChildren]);\r\n }\r\n \u002F\u002F props without children\r\n return createVNode(type, propsOrChildren);\r\n }\r\n else {\r\n \u002F\u002F omit props\r\n return createVNode(type, null, propsOrChildren);\r\n }\r\n }\r\n else {\r\n if (isVNode(children)) {\r\n children = [children];\r\n }\r\n return createVNode(type, propsOrChildren, children);\r\n }\r\n}\r\n\r\n\u002F\u002F For runtime consumption\r\nconst PublicShapeFlags = {\r\n ELEMENT: 1 \u002F* ELEMENT *\u002F,\r\n FUNCTIONAL_COMPONENT: 2 \u002F* FUNCTIONAL_COMPONENT *\u002F,\r\n STATEFUL_COMPONENT: 4 \u002F* STATEFUL_COMPONENT *\u002F,\r\n TEXT_CHILDREN: 8 \u002F* TEXT_CHILDREN *\u002F,\r\n ARRAY_CHILDREN: 16 \u002F* ARRAY_CHILDREN *\u002F,\r\n SLOTS_CHILDREN: 32 \u002F* SLOTS_CHILDREN *\u002F,\r\n SUSPENSE: 64 \u002F* SUSPENSE *\u002F,\r\n COMPONENT_SHOULD_KEEP_ALIVE: 128 \u002F* COMPONENT_SHOULD_KEEP_ALIVE *\u002F,\r\n COMPONENT_KEPT_ALIVE: 256 \u002F* COMPONENT_KEPT_ALIVE *\u002F,\r\n COMPONENT: 6 \u002F* COMPONENT *\u002F\r\n};\r\n\r\nfunction resolveComponent(name) {\r\n return resolveAsset('components', name);\r\n}\r\nfunction resolveDynamicComponent(component) {\r\n if (!component)\r\n return;\r\n if (isString(component)) {\r\n return resolveAsset('components', component);\r\n }\r\n else if (isFunction(component) || isObject(component)) {\r\n return component;\r\n }\r\n}\r\nfunction resolveDirective(name) {\r\n return resolveAsset('directives', name);\r\n}\r\nfunction resolveAsset(type, name) {\r\n const instance = currentRenderingInstance || currentInstance;\r\n if (instance) {\r\n let camelized;\r\n const registry = instance[type];\r\n const res = registry[name] ||\r\n registry[(camelized = camelize(name))] ||\r\n registry[capitalize(camelized)];\r\n if ( !res) {\r\n warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`);\r\n }\r\n return res;\r\n }\r\n else {\r\n warn(`resolve${capitalize(type.slice(0, -1))} ` +\r\n `can only be used in render() or setup().`);\r\n }\r\n}\r\n\r\nfunction renderList(source, renderItem) {\r\n let ret;\r\n if (isArray(source) || isString(source)) {\r\n ret = new Array(source.length);\r\n for (let i = 0, l = source.length; i \u003C l; i++) {\r\n ret[i] = renderItem(source[i], i);\r\n }\r\n }\r\n else if (typeof source === 'number') {\r\n ret = new Array(source);\r\n for (let i = 0; i \u003C source; i++) {\r\n ret[i] = renderItem(i + 1, i);\r\n }\r\n }\r\n else if (isObject(source)) {\r\n if (source[Symbol.iterator]) {\r\n ret = Array.from(source, renderItem);\r\n }\r\n else {\r\n const keys = Object.keys(source);\r\n ret = new Array(keys.length);\r\n for (let i = 0, l = keys.length; i \u003C l; i++) {\r\n const key = keys[i];\r\n ret[i] = renderItem(source[key], key, i);\r\n }\r\n }\r\n }\r\n return ret;\r\n}\r\n\r\n\u002F\u002F for converting {{ interpolation }} values to displayed strings.\r\nfunction toString(val) {\r\n return val == null\r\n ? ''\r\n : isArray(val) || (isPlainObject(val) && val.toString === objectToString)\r\n ? JSON.stringify(val, null, 2)\r\n : String(val);\r\n}\r\n\r\n\u002F\u002F For prefixing keys in v-on=\"obj\" with \"on\"\r\nfunction toHandlers(obj) {\r\n const ret = {};\r\n if ( !isObject(obj)) {\r\n warn(`v-on with no argument expects an object value.`);\r\n return ret;\r\n }\r\n for (const key in obj) {\r\n ret[`on${key}`] = obj[key];\r\n }\r\n return ret;\r\n}\r\n\r\nfunction renderSlot(slots, name, props = {}, \r\n\u002F\u002F this is not a user-facing function, so the fallback is always generated by\r\n\u002F\u002F the compiler and guaranteed to be an array\r\nfallback) {\r\n const slot = slots[name];\r\n return (openBlock(),\r\n createBlock(Fragment, { key: props.key }, slot ? slot(props) : fallback || [], slots._compiled ? 0 : -1 \u002F* BAIL *\u002F));\r\n}\r\n\r\nfunction createSlots(slots, dynamicSlots) {\r\n for (let i = 0; i \u003C dynamicSlots.length; i++) {\r\n const slot = dynamicSlots[i];\r\n \u002F\u002F array of dynamic slot generated by \u003Ctemplate v-for=\"...\" #[...]\u003E\r\n if (isArray(slot)) {\r\n for (let j = 0; j \u003C slot.length; j++) {\r\n slots[slot[j].name] = slot[j].fn;\r\n }\r\n }\r\n else {\r\n \u002F\u002F conditional single slot generated by \u003Ctemplate v-if=\"...\" #foo\u003E\r\n slots[slot.name] = slot.fn;\r\n }\r\n }\r\n return slots;\r\n}\r\n\r\n\u002F\u002F Public API ------------------------------------------------------------------\r\nconst version = \"3.0.0-alpha.1\";\r\nconst PatchFlags = PublicPatchFlags;\r\nconst capitalize$1 = capitalize;\r\nconst camelize$1 = camelize;\r\n\r\nconst doc = document;\r\nconst svgNS = 'http:\u002F\u002Fwww.w3.org\u002F2000\u002Fsvg';\r\nconst nodeOps = {\r\n insert: (child, parent, anchor) =\u003E {\r\n if (anchor != null) {\r\n parent.insertBefore(child, anchor);\r\n }\r\n else {\r\n parent.appendChild(child);\r\n }\r\n },\r\n remove: (child) =\u003E {\r\n const parent = child.parentNode;\r\n if (parent != null) {\r\n parent.removeChild(child);\r\n }\r\n },\r\n createElement: (tag, isSVG) =\u003E isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag),\r\n createText: (text) =\u003E doc.createTextNode(text),\r\n createComment: (text) =\u003E doc.createComment(text),\r\n setText: (node, text) =\u003E {\r\n node.nodeValue = text;\r\n },\r\n setElementText: (el, text) =\u003E {\r\n el.textContent = text;\r\n },\r\n parentNode: (node) =\u003E node.parentNode,\r\n nextSibling: (node) =\u003E node.nextSibling,\r\n querySelector: (selector) =\u003E doc.querySelector(selector)\r\n};\r\n\r\n\u002F\u002F compiler should normalize class + :class bindings on the same element\r\n\u002F\u002F into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n \u002F\u002F directly setting className should be faster than setAttribute in theory\r\n if (isSVG) {\r\n el.setAttribute('class', value);\r\n }\r\n else {\r\n el.className = value;\r\n }\r\n}\r\n\r\nfunction patchStyle(el, prev, next) {\r\n const style = el.style;\r\n if (!next) {\r\n el.removeAttribute('style');\r\n }\r\n else if (isString(next)) {\r\n style.cssText = next;\r\n }\r\n else {\r\n for (const key in next) {\r\n setStyle(style, key, next[key]);\r\n }\r\n if (prev && !isString(prev)) {\r\n for (const key in prev) {\r\n if (!next[key]) {\r\n setStyle(style, key, '');\r\n }\r\n }\r\n }\r\n }\r\n}\r\nconst importantRE = \u002F\\s*!important$\u002F;\r\nfunction setStyle(style, name, val) {\r\n if (name.startsWith('--')) {\r\n \u002F\u002F custom property definition\r\n style.setProperty(name, val);\r\n }\r\n else {\r\n const prefixed = autoPrefix(style, name);\r\n if (importantRE.test(val)) {\r\n \u002F\u002F !important\r\n style.setProperty(hyphenate(prefixed), val.replace(importantRE, ''), 'important');\r\n }\r\n else {\r\n style[prefixed] = val;\r\n }\r\n }\r\n}\r\nconst prefixes = ['Webkit', 'Moz', 'ms'];\r\nconst prefixCache = {};\r\nfunction autoPrefix(style, rawName) {\r\n const cached = prefixCache[rawName];\r\n if (cached) {\r\n return cached;\r\n }\r\n let name = camelize$1(rawName);\r\n if (name !== 'filter' && name in style) {\r\n return (prefixCache[rawName] = name);\r\n }\r\n name = capitalize(name);\r\n for (let i = 0; i \u003C prefixes.length; i++) {\r\n const prefixed = prefixes[i] + name;\r\n if (prefixed in style) {\r\n return (prefixCache[rawName] = prefixed);\r\n }\r\n }\r\n return rawName;\r\n}\r\n\r\nfunction patchAttr(el, key, value) {\r\n if (value == null) {\r\n el.removeAttribute(key);\r\n }\r\n else {\r\n el.setAttribute(key, value);\r\n }\r\n}\r\n\r\nfunction patchDOMProp(el, key, value, \r\n\u002F\u002F the following args are passed only due to potential innerHTML\u002FtextContent\r\n\u002F\u002F overriding existing VNodes, in which case the old tree must be properly\r\n\u002F\u002F unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n if ((key === 'innerHTML' || key === 'textContent') && prevChildren != null) {\r\n unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n el[key] = value == null ? '' : value;\r\n return;\r\n }\r\n if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n \u002F\u002F store value as _value as well since\r\n \u002F\u002F non-string values will be stringified.\r\n el._value = value;\r\n el.value = value == null ? '' : value;\r\n return;\r\n }\r\n if (value === '' && typeof el[key] === 'boolean') {\r\n \u002F\u002F e.g. \u003Cselect multiple\u003E compiles to { multiple: '' }\r\n el[key] = true;\r\n }\r\n else {\r\n el[key] = value == null ? '' : value;\r\n }\r\n}\r\n\r\n\u002F\u002F Async edge case fix requires storing an event listener's attach timestamp.\r\nlet _getNow = Date.now;\r\n\u002F\u002F Determine what event timestamp the browser is using. Annoyingly, the\r\n\u002F\u002F timestamp can either be hi-res ( relative to page load) or low-res\r\n\u002F\u002F (relative to UNIX epoch), so in order to compare time we have to use the\r\n\u002F\u002F same timestamp type when saving the flush timestamp.\r\nif (typeof document !== 'undefined' &&\r\n _getNow() \u003E document.createEvent('Event').timeStamp) {\r\n \u002F\u002F if the low-res timestamp which is bigger than the event timestamp\r\n \u002F\u002F (which is evaluated AFTER) it means the event is using a hi-res timestamp,\r\n \u002F\u002F and we need to use the hi-res version for event listeners as well.\r\n _getNow = () =\u003E performance.now();\r\n}\r\n\u002F\u002F To avoid the overhead of repeatedly calling performance.now(), we cache\r\n\u002F\u002F and use the same timestamp for all event listeners attached in the same tick.\r\nlet cachedNow = 0;\r\nconst p$1 = Promise.resolve();\r\nconst reset = () =\u003E {\r\n cachedNow = 0;\r\n};\r\nconst getNow = () =\u003E cachedNow || (p$1.then(reset), (cachedNow = _getNow()));\r\nfunction addEventListener(el, event, handler, options) {\r\n el.addEventListener(event, handler, options);\r\n}\r\nfunction removeEventListener(el, event, handler, options) {\r\n el.removeEventListener(event, handler, options);\r\n}\r\nfunction patchEvent(el, name, prevValue, nextValue, instance = null) {\r\n const prevOptions = prevValue && 'options' in prevValue && prevValue.options;\r\n const nextOptions = nextValue && 'options' in nextValue && nextValue.options;\r\n const invoker = prevValue && prevValue.invoker;\r\n const value = nextValue && 'handler' in nextValue ? nextValue.handler : nextValue;\r\n if (prevOptions || nextOptions) {\r\n const prev = prevOptions || EMPTY_OBJ;\r\n const next = nextOptions || EMPTY_OBJ;\r\n if (prev.capture !== next.capture ||\r\n prev.passive !== next.passive ||\r\n prev.once !== next.once) {\r\n if (invoker) {\r\n removeEventListener(el, name, invoker, prev);\r\n }\r\n if (nextValue && value) {\r\n const invoker = createInvoker(value, instance);\r\n nextValue.invoker = invoker;\r\n addEventListener(el, name, invoker, next);\r\n }\r\n return;\r\n }\r\n }\r\n if (nextValue && value) {\r\n if (invoker) {\r\n prevValue.invoker = null;\r\n invoker.value = value;\r\n nextValue.invoker = invoker;\r\n invoker.lastUpdated = getNow();\r\n }\r\n else {\r\n addEventListener(el, name, createInvoker(value, instance), nextOptions || void 0);\r\n }\r\n }\r\n else if (invoker) {\r\n removeEventListener(el, name, invoker, prevOptions || void 0);\r\n }\r\n}\r\nfunction createInvoker(initialValue, instance) {\r\n const invoker = (e) =\u003E {\r\n \u002F\u002F async edge case #6566: inner click event triggers patch, event handler\r\n \u002F\u002F attached to outer element during patch, and triggered again. This\r\n \u002F\u002F happens because browsers fire microtask ticks between event propagation.\r\n \u002F\u002F the solution is simple: we save the timestamp when a handler is attached,\r\n \u002F\u002F and the handler would only fire if the event passed to it was fired\r\n \u002F\u002F AFTER it was attached.\r\n if (e.timeStamp \u003E= invoker.lastUpdated - 1) {\r\n callWithAsyncErrorHandling(invoker.value, instance, 5 \u002F* NATIVE_EVENT_HANDLER *\u002F, [e]);\r\n }\r\n };\r\n invoker.value = initialValue;\r\n initialValue.invoker = invoker;\r\n invoker.lastUpdated = getNow();\r\n return invoker;\r\n}\r\n\r\nfunction patchProp(el, key, nextValue, prevValue, isSVG, prevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n switch (key) {\r\n \u002F\u002F special\r\n case 'class':\r\n patchClass(el, nextValue, isSVG);\r\n break;\r\n case 'style':\r\n patchStyle(el, prevValue, nextValue);\r\n break;\r\n case 'modelValue':\r\n case 'onUpdate:modelValue':\r\n \u002F\u002F Do nothing. This is handled by v-model directives.\r\n break;\r\n default:\r\n if (isOn(key)) {\r\n patchEvent(el, key.slice(2).toLowerCase(), prevValue, nextValue, parentComponent);\r\n }\r\n else if (!isSVG && key in el) {\r\n patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\r\n }\r\n else {\r\n \u002F\u002F special case for \u003Cinput v-model type=\"checkbox\"\u003E with\r\n \u002F\u002F :true-value & :false-value\r\n \u002F\u002F store value as dom properties since non-string values will be\r\n \u002F\u002F stringified.\r\n if (key === 'true-value') {\r\n el._trueValue = nextValue;\r\n }\r\n else if (key === 'false-value') {\r\n el._falseValue = nextValue;\r\n }\r\n patchAttr(el, key, nextValue);\r\n }\r\n break;\r\n }\r\n}\r\n\r\nconst getModelAssigner = (vnode) =\u003E vnode.props['onUpdate:modelValue'];\r\nfunction onCompositionStart(e) {\r\n e.target.composing = true;\r\n}\r\nfunction onCompositionEnd(e) {\r\n const target = e.target;\r\n if (target.composing) {\r\n target.composing = false;\r\n trigger$1(target, 'input');\r\n }\r\n}\r\nfunction trigger$1(el, type) {\r\n const e = document.createEvent('HTMLEvents');\r\n e.initEvent(type, true, true);\r\n el.dispatchEvent(e);\r\n}\r\nfunction toNumber(val) {\r\n const n = parseFloat(val);\r\n return isNaN(n) ? val : n;\r\n}\r\n\u002F\u002F We are exporting the v-model runtime directly as vnode hooks so that it can\r\n\u002F\u002F be tree-shaken in case v-model is never used.\r\nconst vModelText = {\r\n beforeMount(el, { value, modifiers: { lazy, trim, number } }, vnode) {\r\n el.value = value;\r\n const assign = getModelAssigner(vnode);\r\n const castToNumber = number || el.type === 'number';\r\n addEventListener(el, lazy ? 'change' : 'input', () =\u003E {\r\n let domValue = el.value;\r\n if (trim) {\r\n domValue = domValue.trim();\r\n }\r\n else if (castToNumber) {\r\n domValue = toNumber(domValue);\r\n }\r\n assign(domValue);\r\n });\r\n if (trim) {\r\n addEventListener(el, 'change', () =\u003E {\r\n el.value = el.value.trim();\r\n });\r\n }\r\n if (!lazy) {\r\n addEventListener(el, 'compositionstart', onCompositionStart);\r\n addEventListener(el, 'compositionend', onCompositionEnd);\r\n \u002F\u002F Safari \u003C 10.2 & UIWebView doesn't fire compositionend when\r\n \u002F\u002F switching focus before confirming composition choice\r\n \u002F\u002F this also fixes the issue where some browsers e.g. iOS Chrome\r\n \u002F\u002F fires \"change\" instead of \"input\" on autocomplete.\r\n addEventListener(el, 'change', onCompositionEnd);\r\n }\r\n },\r\n beforeUpdate(el, { value, oldValue, modifiers: { trim, number } }) {\r\n if (value === oldValue) {\r\n return;\r\n }\r\n if (document.activeElement === el) {\r\n if (trim && el.value.trim() === value) {\r\n return;\r\n }\r\n if ((number || el.type === 'number') && toNumber(el.value) === value) {\r\n return;\r\n }\r\n }\r\n el.value = value;\r\n }\r\n};\r\nconst vModelCheckbox = {\r\n beforeMount(el, binding, vnode) {\r\n setChecked(el, binding, vnode);\r\n const assign = getModelAssigner(vnode);\r\n addEventListener(el, 'change', () =\u003E {\r\n const modelValue = el._modelValue;\r\n const elementValue = getValue(el);\r\n const checked = el.checked;\r\n if (isArray(modelValue)) {\r\n const index = looseIndexOf(modelValue, elementValue);\r\n const found = index !== -1;\r\n if (checked && !found) {\r\n assign(modelValue.concat(elementValue));\r\n }\r\n else if (!checked && found) {\r\n const filtered = [...modelValue];\r\n filtered.splice(index, 1);\r\n assign(filtered);\r\n }\r\n }\r\n else {\r\n assign(getCheckboxValue(el, checked));\r\n }\r\n });\r\n },\r\n beforeUpdate: setChecked\r\n};\r\nfunction setChecked(el, { value, oldValue }, vnode) {\r\n el._modelValue = value;\r\n if (isArray(value)) {\r\n el.checked = looseIndexOf(value, vnode.props.value) \u003E -1;\r\n }\r\n else if (value !== oldValue) {\r\n el.checked = looseEqual(value, getCheckboxValue(el, true));\r\n }\r\n}\r\nconst vModelRadio = {\r\n beforeMount(el, { value }, vnode) {\r\n el.checked = looseEqual(value, vnode.props.value);\r\n const assign = getModelAssigner(vnode);\r\n addEventListener(el, 'change', () =\u003E {\r\n assign(getValue(el));\r\n });\r\n },\r\n beforeUpdate(el, { value, oldValue }, vnode) {\r\n if (value !== oldValue) {\r\n el.checked = looseEqual(value, vnode.props.value);\r\n }\r\n }\r\n};\r\nconst vModelSelect = {\r\n \u002F\u002F use mounted & updated because \u003Cselect\u003E relies on its children \u003Coption\u003Es.\r\n mounted(el, { value }, vnode) {\r\n setSelected(el, value);\r\n const assign = getModelAssigner(vnode);\r\n addEventListener(el, 'change', () =\u003E {\r\n const selectedVal = Array.prototype.filter\r\n .call(el.options, (o) =\u003E o.selected)\r\n .map(getValue);\r\n assign(el.multiple ? selectedVal : selectedVal[0]);\r\n });\r\n },\r\n updated(el, { value }) {\r\n setSelected(el, value);\r\n }\r\n};\r\nfunction setSelected(el, value) {\r\n const isMultiple = el.multiple;\r\n if (isMultiple && !isArray(value)) {\r\n \r\n warn(`\u003Cselect multiple v-model\u003E expects an Array value for its binding, ` +\r\n `but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);\r\n return;\r\n }\r\n for (let i = 0, l = el.options.length; i \u003C l; i++) {\r\n const option = el.options[i];\r\n const optionValue = getValue(option);\r\n if (isMultiple) {\r\n option.selected = looseIndexOf(value, optionValue) \u003E -1;\r\n }\r\n else {\r\n if (looseEqual(getValue(option), value)) {\r\n el.selectedIndex = i;\r\n return;\r\n }\r\n }\r\n }\r\n if (!isMultiple) {\r\n el.selectedIndex = -1;\r\n }\r\n}\r\nfunction looseEqual(a, b) {\r\n if (a === b)\r\n return true;\r\n const isObjectA = isObject(a);\r\n const isObjectB = isObject(b);\r\n if (isObjectA && isObjectB) {\r\n try {\r\n const isArrayA = isArray(a);\r\n const isArrayB = isArray(b);\r\n if (isArrayA && isArrayB) {\r\n return (a.length === b.length &&\r\n a.every((e, i) =\u003E looseEqual(e, b[i])));\r\n }\r\n else if (a instanceof Date && b instanceof Date) {\r\n return a.getTime() === b.getTime();\r\n }\r\n else if (!isArrayA && !isArrayB) {\r\n const keysA = Object.keys(a);\r\n const keysB = Object.keys(b);\r\n return (keysA.length === keysB.length &&\r\n keysA.every(key =\u003E looseEqual(a[key], b[key])));\r\n }\r\n else {\r\n \u002F* istanbul ignore next *\u002F\r\n return false;\r\n }\r\n }\r\n catch (e) {\r\n \u002F* istanbul ignore next *\u002F\r\n return false;\r\n }\r\n }\r\n else if (!isObjectA && !isObjectB) {\r\n return String(a) === String(b);\r\n }\r\n else {\r\n return false;\r\n }\r\n}\r\nfunction looseIndexOf(arr, val) {\r\n return arr.findIndex(item =\u003E looseEqual(item, val));\r\n}\r\n\u002F\u002F retrieve raw value set via :value bindings\r\nfunction getValue(el) {\r\n return '_value' in el ? el._value : el.value;\r\n}\r\n\u002F\u002F retrieve raw value for true-value and false-value set via :true-value or :false-value bindings\r\nfunction getCheckboxValue(el, checked) {\r\n const key = checked ? '_trueValue' : '_falseValue';\r\n return key in el ? el[key] : checked;\r\n}\r\nconst vModelDynamic = {\r\n beforeMount(el, binding, vnode) {\r\n callModelHook(el, binding, vnode, null, 'beforeMount');\r\n },\r\n mounted(el, binding, vnode) {\r\n callModelHook(el, binding, vnode, null, 'mounted');\r\n },\r\n beforeUpdate(el, binding, vnode, prevVNode) {\r\n callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');\r\n },\r\n updated(el, binding, vnode, prevVNode) {\r\n callModelHook(el, binding, vnode, prevVNode, 'updated');\r\n }\r\n};\r\nfunction callModelHook(el, binding, vnode, prevVNode, hook) {\r\n let modelToUse;\r\n switch (el.tagName) {\r\n case 'SELECT':\r\n modelToUse = vModelSelect;\r\n break;\r\n case 'TEXTAREA':\r\n modelToUse = vModelText;\r\n break;\r\n default:\r\n switch (el.type) {\r\n case 'checkbox':\r\n modelToUse = vModelCheckbox;\r\n break;\r\n case 'radio':\r\n modelToUse = vModelRadio;\r\n break;\r\n default:\r\n modelToUse = vModelText;\r\n }\r\n }\r\n const fn = modelToUse[hook];\r\n fn && fn(el, binding, vnode, prevVNode);\r\n}\r\n\r\nconst systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];\r\nconst modifierGuards = {\r\n stop: e =\u003E e.stopPropagation(),\r\n prevent: e =\u003E e.preventDefault(),\r\n self: e =\u003E e.target !== e.currentTarget,\r\n ctrl: e =\u003E !e.ctrlKey,\r\n shift: e =\u003E !e.shiftKey,\r\n alt: e =\u003E !e.altKey,\r\n meta: e =\u003E !e.metaKey,\r\n left: e =\u003E 'button' in e && e.button !== 0,\r\n middle: e =\u003E 'button' in e && e.button !== 1,\r\n right: e =\u003E 'button' in e && e.button !== 2,\r\n exact: (e, modifiers) =\u003E systemModifiers.some(m =\u003E e[`${m}Key`] && !modifiers.includes(m))\r\n};\r\nconst withModifiers = (fn, modifiers) =\u003E {\r\n return (event) =\u003E {\r\n for (let i = 0; i \u003C modifiers.length; i++) {\r\n const guard = modifierGuards[modifiers[i]];\r\n if (guard && guard(event, modifiers))\r\n return;\r\n }\r\n return fn(event);\r\n };\r\n};\r\n\u002F\u002F Kept for 2.x compat.\r\n\u002F\u002F Note: IE11 compat for `spacebar` and `del` is removed for now.\r\nconst keyNames = {\r\n esc: 'escape',\r\n space: ' ',\r\n up: 'arrow-up',\r\n left: 'arrow-left',\r\n right: 'arrow-right',\r\n down: 'arrow-down',\r\n delete: 'backspace'\r\n};\r\nconst withKeys = (fn, modifiers) =\u003E {\r\n return (event) =\u003E {\r\n if (!('key' in event))\r\n return;\r\n const eventKey = hyphenate(event.key);\r\n if (\r\n \u002F\u002F None of the provided key modifiers match the current event key\r\n !modifiers.some(k =\u003E k === eventKey || keyNames[k] === eventKey)) {\r\n return;\r\n }\r\n return fn(event);\r\n };\r\n};\r\n\r\nconst { render: baseRender, createApp: baseCreateApp } = createRenderer({\r\n patchProp,\r\n ...nodeOps\r\n});\r\n\u002F\u002F use explicit type casts here to avoid import() calls in rolled-up d.ts\r\nconst render = baseRender;\r\nconst createApp = () =\u003E {\r\n const app = baseCreateApp();\r\n {\r\n \u002F\u002F Inject `isNativeTag`\r\n \u002F\u002F this is used for component name validation (dev only)\r\n Object.defineProperty(app.config, 'isNativeTag', {\r\n value: (tag) =\u003E isHTMLTag(tag) || isSVGTag(tag),\r\n writable: false\r\n });\r\n }\r\n const mount = app.mount;\r\n app.mount = (component, container, props) =\u003E {\r\n if (isString(container)) {\r\n container = document.querySelector(container);\r\n if (!container) {\r\n \r\n warn(`Failed to mount app: mount target selector returned null.`);\r\n return;\r\n }\r\n }\r\n if (\r\n !isFunction(component) &&\r\n !component.render &&\r\n !component.template) {\r\n component.template = container.innerHTML;\r\n }\r\n \u002F\u002F clear content before mounting\r\n container.innerHTML = '';\r\n return mount(component, container, props);\r\n };\r\n return app;\r\n};\r\n\r\nvar runtimeDom = \u002F*#__PURE__*\u002FObject.freeze({\r\n __proto__: null,\r\n render: render,\r\n createApp: createApp,\r\n vModelText: vModelText,\r\n vModelCheckbox: vModelCheckbox,\r\n vModelRadio: vModelRadio,\r\n vModelSelect: vModelSelect,\r\n vModelDynamic: vModelDynamic,\r\n withModifiers: withModifiers,\r\n withKeys: withKeys,\r\n version: version,\r\n PatchFlags: PatchFlags,\r\n capitalize: capitalize$1,\r\n camelize: camelize$1,\r\n nextTick: nextTick,\r\n createComponent: createComponent,\r\n getCurrentInstance: getCurrentInstance,\r\n h: h,\r\n createVNode: createVNode,\r\n cloneVNode: cloneVNode,\r\n mergeProps: mergeProps,\r\n openBlock: openBlock,\r\n createBlock: createBlock,\r\n Text: Text,\r\n Comment: Comment,\r\n Fragment: Fragment,\r\n Portal: Portal,\r\n Suspense: Suspense,\r\n KeepAlive: KeepAlive,\r\n ShapeFlags: PublicShapeFlags,\r\n createRenderer: createRenderer,\r\n warn: warn,\r\n handleError: handleError,\r\n callWithErrorHandling: callWithErrorHandling,\r\n callWithAsyncErrorHandling: callWithAsyncErrorHandling,\r\n withDirectives: withDirectives,\r\n resolveComponent: resolveComponent,\r\n resolveDirective: resolveDirective,\r\n resolveDynamicComponent: resolveDynamicComponent,\r\n renderList: renderList,\r\n toString: toString,\r\n toHandlers: toHandlers,\r\n renderSlot: renderSlot,\r\n createSlots: createSlots,\r\n setBlockTracking: setBlockTracking,\r\n createTextVNode: createTextVNode,\r\n createCommentVNode: createCommentVNode,\r\n registerRuntimeCompiler: registerRuntimeCompiler,\r\n recordEffect: recordEffect,\r\n computed: computed$1,\r\n ref: ref,\r\n isRef: isRef,\r\n toRefs: toRefs,\r\n reactive: reactive,\r\n isReactive: isReactive,\r\n readonly: readonly,\r\n isReadonly: isReadonly,\r\n toRaw: toRaw,\r\n markReadonly: markReadonly,\r\n markNonReactive: markNonReactive,\r\n effect: effect,\r\n watch: watch,\r\n instanceWatch: instanceWatch,\r\n injectHook: injectHook,\r\n createHook: createHook,\r\n onBeforeMount: onBeforeMount,\r\n onMounted: onMounted,\r\n onBeforeUpdate: onBeforeUpdate,\r\n onUpdated: onUpdated,\r\n onBeforeUnmount: onBeforeUnmount,\r\n onUnmounted: onUnmounted,\r\n onRenderTriggered: onRenderTriggered,\r\n onRenderTracked: onRenderTracked,\r\n onErrorCaptured: onErrorCaptured,\r\n onActivated: onActivated,\r\n onDeactivated: onDeactivated,\r\n provide: provide,\r\n inject: inject\r\n});\r\n\r\n\u002F\u002F This package is the \"full-build\" that includes both the runtime\r\nfunction compileToFunction(template, options) {\r\n const { code } = compile(template, {\r\n hoistStatic: true,\r\n ...options\r\n });\r\n return new Function('Vue', code)(runtimeDom);\r\n}\r\nregisterRuntimeCompiler(compileToFunction);\r\n{\r\n console[console.info ? 'info' : 'log'](`You are running a development build of Vue.\\n` +\r\n `Make sure to use the production build (*.prod.js) when deploying for production.`);\r\n}\r\n\r\nexport { Comment, Fragment, KeepAlive, PatchFlags, Portal, PublicShapeFlags as ShapeFlags, Suspense, Text, callWithAsyncErrorHandling, callWithErrorHandling, camelize$1 as camelize, capitalize$1 as capitalize, cloneVNode, compileToFunction as compile, computed$1 as computed, createApp, createBlock, createCommentVNode, createComponent, createHook, createRenderer, createSlots, createTextVNode, createVNode, effect, getCurrentInstance, h, handleError, inject, injectHook, instanceWatch, isReactive, isReadonly, isRef, markNonReactive, markReadonly, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, provide, reactive, readonly, recordEffect, ref, registerRuntimeCompiler, render, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, setBlockTracking, toHandlers, toRaw, toRefs, toString, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, version, warn, watch, withDirectives, withKeys, withModifiers };\r\n","id":"5660529b-7611-4280-b7d3-b6f37c2117d5","is_binary":false,"title":"vue.esm-browser.js","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","upload_id":null,"shortid":"SJdcHmFqpH","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":"rygqr7Yc6H"},{"code":"{\n \"compilerOptions\": {\n \"module\": \"commonjs\",\n \"jsx\": \"preserve\",\n \"esModuleInterop\": true,\n \"sourceMap\": true,\n \"allowJs\": true,\n \"lib\": [\n \"es6\",\n \"dom\"\n ],\n \"rootDir\": \"src\",\n \"moduleResolution\": \"node\"\n }\n}","id":"2843c78a-08ea-4a8f-9298-317e3d0dbd77","is_binary":false,"title":"tsconfig.json","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","upload_id":null,"shortid":"r1w9BmF5TB","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"\u003Chtml\u003E\n \u003Chead\u003E\n \u003Ctitle\u003EParcel Sandbox\u003C\u002Ftitle\u003E\n \u003Cmeta charset=\"UTF-8\" \u002F\u003E\n \u003Clink rel=\"stylesheet\" href=\"style.css\" \u002F\u003E\n \u003C\u002Fhead\u003E\n\n \u003Cbody\u003E\n \u003Cdiv id=\"app\"\u003E\u003C\u002Fdiv\u003E\n \u003Cdiv id=\"popup-target\"\u003E\u003C\u002Fdiv\u003E\n \u003Cscript src=\"src\u002Findex.ts\"\u003E\u003C\u002Fscript\u003E\n \u003C\u002Fbody\u003E\n\u003C\u002Fhtml\u003E\n","id":"2839e0c7-c8f1-4157-a724-f72330243e3b","is_binary":false,"title":"index.html","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","upload_id":null,"shortid":"r1X5rQK5aB","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"{\n \"printWidth\": 80,\n \"tabWidth\": 2,\n \"useTabs\": false,\n \"semi\": true,\n \"singleQuote\": false,\n \"trailingComma\": \"none\",\n \"bracketSpacing\": true,\n \"jsxBracketSameLine\": false,\n \"fluid\": false\n}","id":"08a2ae51-de9e-4413-8509-e7713319c42b","is_binary":false,"title":".prettierrc","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","upload_id":null,"shortid":"B1M5Smt9aH","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"{\n \"preview\": [\n {\n \"views\": [\n {\n \"id\": \"codesandbox.browser\"\n },\n {\n \"id\": \"codesandbox.tests\"\n }\n ]\n },\n {\n \"views\": [\n {\n \"id\": \"codesandbox.console\"\n },\n {\n \"id\": \"codesandbox.problems\"\n }\n ]\n }\n ]\n}","id":"883c0adc-b4ba-4ec6-a8db-5bf68af0adc8","is_binary":false,"title":"workspace.json","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","upload_id":null,"shortid":"HyZcBQYcaB","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":"BJcBXF5Tr"},{"code":"{\n \"name\": \"vue-3-portal-example\",\n \"version\": \"1.0.0\",\n \"description\": \"Vue 3 - Portals Example\",\n \"main\": \"index.html\",\n \"scripts\": {\n \"start\": \"parcel index.html --open\",\n \"build\": \"parcel build index.html\"\n },\n \"dependencies\": {},\n \"devDependencies\": {\n \"parcel-bundler\": \"^1.6.1\"\n },\n \"keywords\": []\n}","id":"0470a9de-86d2-4f9b-a53c-3308732cbce6","is_binary":false,"title":"package.json","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:16:10","upload_id":null,"shortid":"BJV9S7t5aH","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"* {\n margin: 0;\n box-sizing: border-box;\n}\n\n#app {\n padding: 15px;\n max-width: 600px;\n margin: 0 auto;\n}\n\nh1 {\n padding-bottom: 15px;\n font-size: 25px;\n}\n\nbody {\n font-family: sans-serif;\n}\n\n.border {\n border: 1px solid red;\n}\n\n.popup {\n margin: 15px;\n padding: 10px;\n max-width: 600px;\n margin: 0 auto;\n box-shadow: 0 2px 5px rgba(0, 0, 0, 0.4);\n}\n\n.twitter {\n position: fixed;\n bottom: 40px;\n width: 100%;\n color: #555;\n}\n.twitter a {\n text-decoration: none;\n color: #333;\n}\n","id":"8cfc5b36-79e7-4c1a-b558-41c2b4d54614","is_binary":false,"title":"style.css","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T20:57:18","upload_id":null,"shortid":"BkLqHmF96B","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"# Vue 3 - Portal example\n\n`src\u002Fvue-esm-browser` is built from [vue-next](https:\u002F\u002Fgithub.com\u002Fvuejs\u002Fvue-next)\n\n`index.html` contains #portal-target element\n\n## Usage\n\n```bash\n# install dependencies\n$ yarn install\n\n# serve\n$ yarn start\n```\n\n## Build\n\n```sh\nyarn build\n```\n","id":"e09b9736-6171-446f-9fc9-392133f8c32f","is_binary":false,"title":"README.md","sha":null,"inserted_at":"2019-12-08T14:09:05","updated_at":"2019-12-08T14:10:52","upload_id":null,"shortid":"8zJ22","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"code":"export default {\n template: `\u003Cdiv class=\"twitter\"\u003E Follow me on \u003Ca target=\"_blank\" href=\"https:\u002F\u002Ftwitter.com\u002Fimesutkoca\"\u003ETwitter\u003C\u002Fa\u003E\u003C\u002Fdiv\u003E`\n};\n","id":"ea36794c-af8d-4a4a-8c6a-389196564196","is_binary":false,"title":"twitter.ts","sha":null,"inserted_at":"2019-12-08T20:58:02","updated_at":"2019-12-08T20:58:56","upload_id":null,"shortid":"kBpL5","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":"rygqr7Yc6H"},{"code":"import { createApp } from \".\u002Fvue.esm-browser\";\nimport Twitter from \".\u002Ftwitter\"; \u002F\u002F @imesutkoca\n\nconst Example = {\n setup() {\n return {\n count: 0\n };\n },\n template: `\n \u003Cdiv\u003E\n \u003Cp\u003Eincrement count inside of popup\u003C\u002Fp\u003E\n \u003Cbutton @click=\"count++\"\u003Eincrement\u003C\u002Fbutton\u003E\n \u003CPortal target=\"#popup-target\"\u003E\n \u003Cdiv class=\"popup\"\u003E\n \u003Ch4\u003E Popup \u003C\u002Fh4\u003E\n \u003Cp\u003Eim inside of #popup-target element not in #app.\u003C\u002Fp\u003E\n \u003Cp\u003Eopen devtools to check.\u003C\u002Fp\u003E\n count: {{ count }}\n \u003C\u002Fdiv\u003E\n \u003C\u002FPortal\u003E\n \u003C\u002Fdiv\u003E\n `\n};\n\nconst App = {\n components: {\n Example\n },\n\n template: `\n \u003Ch1\u003EVue 3 - Portal Example \u003C\u002Fh1\u003E\n \u003CExample \u002F\u003E\n \n \u003CTwitter \u002F\u003E\n `\n};\n\nvar app = createApp();\napp.component(\"Twitter\", Twitter);\napp.mount(App, \"#app\");\n","id":"e58ca85d-b898-4417-be09-9237bac98c40","is_binary":false,"title":"index.ts","sha":null,"inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T21:07:01","upload_id":null,"shortid":"B1r5S7Y9pS","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":"rygqr7Yc6H"}],"authorization":"read","restrictions":{"free_plan_editing_restricted":false,"live_sessions_restricted":false},"collection":false,"version":58,"like_count":0,"user_liked":false,"view_count":5337,"permissions":{"prevent_sandbox_export":false,"prevent_sandbox_leaving":false},"forked_template_sandbox":{"alias":"vue-3-portal-example-gii9z","id":"gii9z","title":"vue-3-portal-example","template":"parcel","inserted_at":"2019-12-08T14:05:53","updated_at":"2019-12-12T19:11:51","git":{"path":"","branch":"master","repo":"vue-3-portal-example","username":"koca","commit_sha":"e88a923926f9b1cf975f7711e32fee5a94170466"},"privacy":0,"custom_template":{"id":"055b5989-1596-4b14-bb3a-220974499be3","title":"vue-3-portal-example","color":"#61DAFB","v2":false,"url":null,"published":false,"icon_url":"github","official":false}},"team":{"id":"c83cdd46-6efc-46ab-b6f1-947d8dfa5a91","name":"koca","settings":{"ai_consent":{"public_sandboxes":true,"private_sandboxes":true}},"subscription_type":null,"avatar_url":"https:\u002F\u002Favatars2.githubusercontent.com\u002Fu\u002F342666?v=4"},"always_on":false,"feature_flags":{"comments":false,"container_lsp":false},"directories":[{"id":"ccd1e071-9ffd-46f0-bbbe-03399357dbbf","title":"src","inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","shortid":"rygqr7Yc6H","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null},{"id":"51ee90f0-6645-40ed-bde5-935db0d6139b","title":".codesandbox","inserted_at":"2019-12-08T14:06:18","updated_at":"2019-12-08T14:05:53","shortid":"BJcBXF5Tr","source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","directory_shortid":null}],"alias":"vue-3-portal-example-cjnb8","npm_dependencies":{},"git":null,"is_frozen":false,"title":"Vue 3 - Portal Example","forked_template":{"id":"055b5989-1596-4b14-bb3a-220974499be3","title":"vue-3-portal-example","color":"#61DAFB","v2":false,"url":null,"published":false,"icon_url":"github","official":false},"template":"parcel","owned":false,"source_id":"7c6c4475-9369-4039-a82c-15d0d1af16fa","picks":[],"external_resources":[],"inserted_at":"2019-12-08T14:06:18","screenshot_url":"https:\u002F\u002Fscreenshots.codesandbox.io\u002Fcjnb8\u002F58.png","room_id":null,"original_git_commit_sha":"e88a923926f9b1cf975f7711e32fee5a94170466","draft":false,"preview_secret":null,"id":"cjnb8","base_git":null,"author":{"id":"1b972514-6f16-481d-8596-610ef242be5c","name":"Mesut","username":"koca","avatar_url":"https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F342666?v=4","personal_workspace_id":"c83cdd46-6efc-46ab-b6f1-947d8dfa5a91","subscription_plan":null,"subscription_since":null},"fork_count":17,"pr_number":null,"updated_at":"2020-01-29T22:10:49","free_plan_editing_restricted":false,"privacy":0,"ai_consent":true,"forked_from_sandbox":null,"settings":{"ai_consent":null},"npm_registries":[],"is_sse":false,"restricted":false,"custom_template":null,"original_git":{"path":"","branch":"master","repo":"vue-3-portal-example","username":"koca","commit_sha":"e88a923926f9b1cf975f7711e32fee5a94170466"}};