{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///./node_modules/@fortawesome/vue-fontawesome/index.es.js","webpack:///./node_modules/@fortawesome/fontawesome-svg-core/index.es.js"],"names":["asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","_asyncToGenerator","fn","self","this","args","arguments","apply","err","undefined","makeMap","str","expectsLowerCase","map","Object","create","list","split","i","length","val","toLowerCase","GLOBALS_WHITE_LISTED","isGloballyWhitelisted","specialBooleanAttrs","isSpecialBooleanAttr","normalizeStyle","isArray","res","item","normalized","isString","parseStringStyle","isObject","listDelimiterRE","propertyDelimiterRE","cssText","ret","forEach","tmp","trim","normalizeClass","name","EMPTY_OBJ","EMPTY_ARR","NOOP","onRE","isOn","test","isModelListener","startsWith","extend","assign","remove","arr","el","indexOf","splice","hasOwnProperty","prototype","hasOwn","call","Array","isFunction","isSymbol","isPromise","catch","objectToString","toString","toTypeString","toRawType","slice","cacheStringFunction","cache","hit","camelizeRE","camelize","replace","_","c","toUpperCase","hyphenateRE","hyphenate","capitalize","charAt","hasChanged","oldValue","def","obj","defineProperty","configurable","enumerable","toNumber","n","parseFloat","isNaN","targetMap","WeakMap","effectStack","activeEffect","ITERATE_KEY","Symbol","MAP_KEY_ITERATE_KEY","isEffect","_isEffect","effect","options","raw","createReactiveEffect","lazy","stop","active","cleanup","onStop","uid","scheduler","includes","enableTracking","push","pop","resetTracking","id","deps","delete","shouldTrack","trackStack","pauseTracking","last","track","target","type","depsMap","get","set","Map","dep","Set","has","add","trigger","newValue","oldTarget","effects","effectsToAdd","isAddOrDelete","run","builtInSymbols","getOwnPropertyNames","filter","createGetter","shallowGet","readonlyGet","shallowReadonlyGet","arrayInstrumentations","isReadonly","shallow","receiver","targetIsArray","Reflect","isRef","readonly","reactive","toRaw","l","createSetter","shallowSet","hadKey","result","deleteProperty","ownKeys","mutableHandlers","readonlyHandlers","toReactive","toReadonly","toShallow","getProto","v","getPrototypeOf","get$1","isShallow","rawTarget","rawKey","wrap","has$1","size","proto","set$1","deleteEntry","del","clear","hadItems","createForEach","callback","thisArg","observed","wrappedCallback","createIterableMethod","method","isMap","isPair","iterator","isKeyOnly","innerIterator","next","createReadonlyMethod","mutableInstrumentations","shallowInstrumentations","readonlyInstrumentations","iteratorMethods","createInstrumentationGetter","instrumentations","mutableCollectionHandlers","readonlyCollectionHandlers","targetTypeMap","rawType","getTargetType","isExtensible","createReactiveObject","baseHandlers","collectionHandlers","reactiveFlag","targetType","Proxy","isReactive","isProxy","r","__v_isRef","callWithErrorHandling","instance","handleError","callWithAsyncErrorHandling","values","contextVNode","vnode","cur","parent","exposedInstance","proxy","errorInfo","errorCapturedHooks","ec","appErrorHandler","appContext","config","errorHandler","logError","console","isFlushing","isFlushPending","queue","flushIndex","pendingPreFlushCbs","activePreFlushCbs","preFlushIndex","pendingPostFlushCbs","activePostFlushCbs","postFlushIndex","resolvedPromise","currentFlushPromise","currentPreFlushParentJob","nextTick","p","queueJob","job","allowRecurse","queueFlush","flushJobs","queueCb","cb","activeQueue","pendingQueue","index","queuePreFlushCb","queuePostFlushCb","flushPreFlushCbs","seen","parentJob","flushPostFlushCbs","sort","a","b","getId","Infinity","currentRenderingInstance","isSuspense","__isSuspense","queueEffectWithSuspense","suspense","isResolved","currentScopeId","isTeleport","__isTeleport","NULL_DYNAMIC_COMPONENT","isRenderingTemplateSlot","Fragment","Text","Comment","currentBlock","shouldTrack$1","isVNode","__v_isVNode","isSameVNodeType","n1","n2","InternalObjectKey","normalizeKey","normalizeRef","ref","ref$$1","createVNode","_createVNode","props","children","patchFlag","dynamicProps","isBlockNode","cloned","cloneVNode","normalizeChildren","__vccOpts","class","klass","style","shapeFlag","__v_skip","scopeId","component","dirs","transition","anchor","targetAnchor","staticCount","dynamicChildren","extraProps","mergedProps","mergeProps","createTextVNode","text$$1","flag","default","slotFlag","_ctx","String","toMerge","existing","incoming","concat","normalizePropsOptions","comp","__props","needCastKeys","hasExtends","extendProps","keys","extends","mixins","normalizedKey","validatePropName","opt","prop","booleanIndex","getTypeIndex","Boolean","stringIndex","normalizedEntry","getType","ctor","match","isSameType","expectedTypes","len","injectHook","hook","currentInstance","prepend","hooks","wrappedHook","__weh","isUnmounted","setCurrentInstance","unshift","createHook","lifecycle","isInSSRComponentSetup","onMounted","onBeforeUnmount","useTransitionState","state","isMounted","isLeaving","isUnmounting","leavingVNodes","TransitionHookValidator","Function","BaseTransitionImpl","mode","appear","persisted","onBeforeEnter","onEnter","onAfterEnter","onEnterCancelled","onBeforeLeave","onLeave","onAfterLeave","onLeaveCancelled","onBeforeAppear","onAppear","onAfterAppear","onAppearCancelled","slots","getCurrentInstance","prevTransitionKey","getTransitionRawChildren","rawProps","child","emptyPlaceholder","innerChild","getKeepAliveChild","enterHooks","resolveTransitionHooks","oldChild","subTree","oldInnerChild","transitionKeyChanged","getTransitionKey","leavingHooks","setTransitionHooks","afterLeave","update","delayLeave","earlyRemove","delayedLeave","leavingVNodesCache","getLeavingNodesForType","_leaveCb","BaseTransition","callHook","leavingVNode","afterHook","cancelHook","called","_enterCb","cancelled","remove$$1","isKeepAlive","keepComment","keyedFragmentCount","__isKeepAlive","queuePostRenderEffect","INITIAL_WATCHER_VALUE","doWatch","source","immediate","deep","flush","onTrack","onTrigger","getter","isRefSource","s","traverse","onInvalidate","baseGetter","runner","recordInstanceBoundEffect","instanceWatch","publicThis","bind","isInBeforeCreate","resolveMergedOptions","__merged","extendsOptions","globalMixins","m","mergeOptions","to","from","strats","optionMergeStrategies","publicPropertiesMap","$","$el","$data","data","$props","$attrs","attrs","$slots","$refs","refs","$parent","$root","root","$emit","emit","$options","$forceUpdate","$nextTick","$watch","PublicInstanceProxyHandlers","ctx","setupState","accessCache","normalizedProps","publicGetter","cssModule","globalProperties","__cssModules","unscopables","effect$$1","defineComponent","setup","h","propsOrChildren","svgNS","doc","document","tempContainer","tempSVGContainer","nodeOps","insert","insertBefore","parentNode","removeChild","createElement","tag","isSVG","is","createElementNS","createText","createTextNode","createComment","setText","node","nodeValue","setElementText","textContent","nextSibling","querySelector","selector","setAttribute","cloneNode","content","temp","innerHTML","first","firstChild","patchClass","transitionClasses","_vtc","join","className","patchStyle","prev","setStyle","removeAttribute","importantRE","setProperty","prefixed","autoPrefix","prefixes","prefixCache","rawName","cached","xlinkNS","patchAttr","removeAttributeNS","setAttributeNS","isBoolean","patchDOMProp","prevChildren","parentComponent","parentSuspense","unmountChildren","tagName","_value","e","_getNow","Date","now","createEvent","timeStamp","performance","cachedNow","reset","getNow","addEventListener","event","handler","removeEventListener","patchEvent","prevValue","nextValue","invokers","_vei","existingInvoker","parseName","invoker","createInvoker","optionsModifierRE","initialValue","attached","patchStopImmediatePropagation","originalStop","stopImmediatePropagation","_stopped","nativeOnRE","forcePatchProp","patchProp","shouldSetAsProp","_trueValue","_falseValue","TRANSITION","ANIMATION","Transition","resolveTransitionProps","displayName","DOMTransitionPropsValidators","css","duration","Number","enterFromClass","enterActiveClass","enterToClass","appearFromClass","appearActiveClass","appearToClass","leaveFromClass","leaveActiveClass","leaveToClass","baseProps","durations","normalizeDuration","enterDuration","leaveDuration","finishEnter","isAppear","removeTransitionClass","finishLeave","makeEnterHook","nextFrame","addTransitionClass","setTimeout","whenTransitionEnds","NumberOf","enter","leave","cls","classList","requestAnimationFrame","expectedType","timeout","propCount","getTransitionInfo","endEvent","ended","end","onEnd","styles","window","getComputedStyle","getStyleProperties","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","Math","max","hasTransform","delays","d","toMs","commonjsGlobal","globalThis","global","createCommonjsModule","module","exports","humps","_processKeys","convert","_isObject","_isDate","_isRegExp","_isBoolean","_isFunction","output","_isArray","separateWords","string","separator","_isNumerical","chr","substr","pascalize","camelized","decamelize","_processor","process","depascalize","camelizeKeys","object","decamelizeKeys","pascalizeKeys","depascalizeKeys","_typeof","constructor","writable","_extends","objectWithoutProperties","toConsumableArray","arr2","styleToObject","reduce","pair","idx","classToObject","classes","convert$1","abstractElement","renderFn","attributes","_attrs$style","aStyle","otherAttrs","PRODUCTION","log","_console","objectWithKey","_classes","spin","pulse","fixedWidth","border","listItem","inverse","flip","rotation","pull","swapOpacity","normalizeIconArgs","icon$$1","prefix","iconName","FontAwesomeIcon","validator","icon","required","mask","parseInt","transform","symbol","title","_ref","renderedIcon","abstract","familyPrefix","counter","position","renderedText","_classCallCheck","Constructor","TypeError","_defineProperties","descriptor","_createClass","protoProps","staticProps","_defineProperty","_objectSpread","getOwnPropertySymbols","sym","getOwnPropertyDescriptor","_slicedToArray","_arrayWithHoles","_iterableToArrayLimit","_nonIterableRest","_toConsumableArray","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","iter","_arr","_n","_d","_e","_s","_i","noop","_WINDOW","_DOCUMENT","_PERFORMANCE","mark","measure","MutationObserver","navigator","_ref$userAgent","userAgent","WINDOW","DOCUMENT","PERFORMANCE","IS_DOM","documentElement","head","IS_IE","NAMESPACE_IDENTIFIER","UNITS_IN_GRID","DEFAULT_FAMILY_PREFIX","DEFAULT_REPLACEMENT_CLASS","DATA_FA_I2SVG","oneToTen","oneToTwenty","DUOTONE_CLASSES","GROUP","SWAP_OPACITY","PRIMARY","SECONDARY","initial","FontAwesomeConfig","getAttrConfig","attr","element","getAttribute","coerce","_ref2","_default","replacementClass","autoReplaceSvg","autoAddCss","autoA11y","searchPseudoElements","observeMutations","mutateApproach","keepOriginalSource","measurePerformance","showMissingIcons","_config","w","shims","namespace","functions","listener","loaded","doScroll","readyState","asyncTimer","PENDING","SETTLED","FULFILLED","REJECTED","isNode","asyncSetTimer","setImmediate","asyncQueue","asyncFlush","asyncCall","invokeResolver","resolver","promise","resolvePromise","rejectPromise","reason","invokeCallback","subscriber","owner","settled","_state","_data","handleThenable","resolved","fulfill","publishFulfillment","publishRejection","publish","_then","_handled","notifyRejectionHandled","P","onFulfillment","onRejection","fulfilled","rejected","all","promises","results","remaining","race","meaninglessTransform","x","y","rotate","flipX","flipY","insertCss","headChildren","childNodes","beforeChild","idPool","nextUniqueId","random","htmlEscape","joinAttributes","acc","attributeName","joinStyles","styleName","transformIsMeaningful","transformForSvg","containerWidth","iconWidth","outer","innerTranslate","innerScale","innerRotate","inner","path","transformForCss","_ref2$width","width","_ref2$height","height","_ref2$startCentered","startCentered","ALL_SPACE","fillBlack","force","fill","deGroup","makeIconMasking","main","explicitMaskId","maskId","mainWidth","mainPath","maskWidth","maskPath","trans","maskRect","maskInnerGroupChildrenMixin","maskInnerGroup","maskOuterGroup","clipId","maskTag","maskUnits","maskContentUnits","defs","makeIconStandard","styleString","asIcon","found","offset","asSymbol","makeInlineSvgAbstract","params","_params$icons","icons","titleId","extra","_params$watchable","watchable","isUploadedIcon","widthClass","ceil","attrClass","role","uploadedIconWidthStyle","makeLayersTextAbstract","_params$watchable2","noop$1","bindInternal4","func","thisContext","subject","defineIcons","_params$skipHooks","skipHooks","expanded","addPack","build","lookup","reducer","o","ligatures","ligature","hasRegular","shim","oldName","iconFromMapping","mapping","toHtml","abstractNodes","_abstractNodes$attrib","_abstractNodes$childr","parseTransformString","transformString","parts","rest","MissingIcon","message","stack","Error","FILL","ANIMATION_BASE","attributeType","repeatCount","dur","OPACITY_ANIMATE","cx","cy","opacity","asFoundIcon","_icon$slice","_icon$slice2","vectorData","baseStyles","dfp","drc","fp","rc","dPatt","RegExp","customPropPatt","rPatt","Library","definitions","_this","_len","_key","additions","_pullDefinitions","definition","0","_normalized$key","ensureCss","_cssInserted","apiObject","abstractCreator","container","html","findIconDefinition","iconLookup","_iconLookup$prefix","library","resolveIcons","maybeIconDefinition","iconDefinition","parse","_params$transform","_params$symbol","_params$mask","_params$maskId","_params$title","_params$titleId","_params$classes","_params$attributes","_params$styles","text","_params$transform2","_params$title2","_params$classes2","_params$attributes2","_params$styles2"],"mappings":"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","file":"js/chunk-vendors~0f485567.660cd90b.js","sourcesContent":["function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","import { parse, icon, config, text } from '@fortawesome/fontawesome-svg-core';\n\n/**\r\n * Make a map and return a function for checking if a key\r\n * is in that map.\r\n * IMPORTANT: all calls of this function must be prefixed with\r\n * \\/\\*#\\_\\_PURE\\_\\_\\*\\/\r\n * So that rollup can tree-shake them if necessary.\r\n */\r\nfunction makeMap(str, expectsLowerCase) {\r\n    const map = Object.create(null);\r\n    const list = str.split(',');\r\n    for (let i = 0; i < list.length; i++) {\r\n        map[list[i]] = true;\r\n    }\r\n    return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];\r\n}\n\nconst GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +\r\n    'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +\r\n    'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';\r\nconst isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);\n\n/**\r\n * On the client we only need to offer special cases for boolean attributes that\r\n * have different names from their corresponding dom properties:\r\n * - itemscope -> N/A\r\n * - allowfullscreen -> allowFullscreen\r\n * - formnovalidate -> formNoValidate\r\n * - ismap -> isMap\r\n * - nomodule -> noModule\r\n * - novalidate -> noValidate\r\n * - readonly -> readOnly\r\n */\r\nconst specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;\r\nconst isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);\r\n/**\r\n * The full list is needed during SSR to produce the correct initial markup.\r\n */\r\nconst isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +\r\n    `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +\r\n    `loop,open,required,reversed,scoped,seamless,` +\r\n    `checked,muted,multiple,selected`);\r\n/**\r\n * CSS properties that accept plain numbers\r\n */\r\nconst isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +\r\n    `border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +\r\n    `columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +\r\n    `grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +\r\n    `grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +\r\n    `line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +\r\n    // SVG\r\n    `fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +\r\n    `stroke-miterlimit,stroke-opacity,stroke-width`);\r\n/**\r\n * Known attributes, this is used for stringification of runtime static nodes\r\n * so that we don't stringify bindings that cannot be set from HTML.\r\n * Don't also forget to allow `data-*` and `aria-*`!\r\n * Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes\r\n */\r\nconst isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +\r\n    `autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +\r\n    `border,buffered,capture,challenge,charset,checked,cite,class,code,` +\r\n    `codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +\r\n    `coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +\r\n    `disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +\r\n    `formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +\r\n    `height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +\r\n    `ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +\r\n    `manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +\r\n    `open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +\r\n    `referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +\r\n    `selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +\r\n    `start,step,style,summary,tabindex,target,title,translate,type,usemap,` +\r\n    `value,width,wrap`);\n\nfunction normalizeStyle(value) {\r\n    if (isArray(value)) {\r\n        const res = {};\r\n        for (let i = 0; i < value.length; i++) {\r\n            const item = value[i];\r\n            const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);\r\n            if (normalized) {\r\n                for (const key in normalized) {\r\n                    res[key] = normalized[key];\r\n                }\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    else if (isObject(value)) {\r\n        return value;\r\n    }\r\n}\r\nconst listDelimiterRE = /;(?![^(]*\\))/g;\r\nconst propertyDelimiterRE = /:(.+)/;\r\nfunction parseStringStyle(cssText) {\r\n    const ret = {};\r\n    cssText.split(listDelimiterRE).forEach(item => {\r\n        if (item) {\r\n            const tmp = item.split(propertyDelimiterRE);\r\n            tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());\r\n        }\r\n    });\r\n    return ret;\r\n}\r\nfunction normalizeClass(value) {\r\n    let res = '';\r\n    if (isString(value)) {\r\n        res = value;\r\n    }\r\n    else if (isArray(value)) {\r\n        for (let i = 0; i < value.length; i++) {\r\n            res += normalizeClass(value[i]) + ' ';\r\n        }\r\n    }\r\n    else if (isObject(value)) {\r\n        for (const name in value) {\r\n            if (value[name]) {\r\n                res += name + ' ';\r\n            }\r\n        }\r\n    }\r\n    return res.trim();\r\n}\n\n// These tag configs are shared between compiler-dom and runtime-dom, so they\r\n// https://developer.mozilla.org/en-US/docs/Web/HTML/Element\r\nconst HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +\r\n    'header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,' +\r\n    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +\r\n    'data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,' +\r\n    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +\r\n    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +\r\n    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +\r\n    'option,output,progress,select,textarea,details,dialog,menu,' +\r\n    'summary,template,blockquote,iframe,tfoot';\r\n// https://developer.mozilla.org/en-US/docs/Web/SVG/Element\r\nconst SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +\r\n    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +\r\n    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +\r\n    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +\r\n    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +\r\n    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +\r\n    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +\r\n    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +\r\n    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +\r\n    'text,textPath,title,tspan,unknown,use,view';\r\nconst VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';\r\nconst isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);\r\nconst isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);\r\nconst isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);\nconst EMPTY_OBJ = (process.env.NODE_ENV !== 'production')\r\n    ? Object.freeze({})\r\n    : {};\r\nconst EMPTY_ARR = [];\r\nconst NOOP = () => { };\r\nconst onRE = /^on[^a-z]/;\r\nconst isOn = (key) => onRE.test(key);\r\nconst isModelListener = (key) => key.startsWith('onUpdate:');\r\nconst extend = Object.assign;\r\nconst remove = (arr, el) => {\r\n    const i = arr.indexOf(el);\r\n    if (i > -1) {\r\n        arr.splice(i, 1);\r\n    }\r\n};\r\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\r\nconst hasOwn = (val, key) => hasOwnProperty.call(val, key);\r\nconst isArray = Array.isArray;\r\nconst isFunction = (val) => typeof val === 'function';\r\nconst isString = (val) => typeof val === 'string';\r\nconst isSymbol = (val) => typeof val === 'symbol';\r\nconst isObject = (val) => val !== null && typeof val === 'object';\r\nconst isPromise = (val) => {\r\n    return isObject(val) && isFunction(val.then) && isFunction(val.catch);\r\n};\r\nconst objectToString = Object.prototype.toString;\r\nconst toTypeString = (value) => objectToString.call(value);\r\nconst toRawType = (value) => {\r\n    return toTypeString(value).slice(8, -1);\r\n};\r\nconst isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +\r\n    'onVnodeBeforeMount,onVnodeMounted,' +\r\n    'onVnodeBeforeUpdate,onVnodeUpdated,' +\r\n    'onVnodeBeforeUnmount,onVnodeUnmounted');\r\nconst cacheStringFunction = (fn) => {\r\n    const cache = Object.create(null);\r\n    return ((str) => {\r\n        const hit = cache[str];\r\n        return hit || (cache[str] = fn(str));\r\n    });\r\n};\r\nconst camelizeRE = /-(\\w)/g;\r\n/**\r\n * @private\r\n */\r\nconst camelize = cacheStringFunction((str) => {\r\n    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));\r\n});\r\nconst hyphenateRE = /\\B([A-Z])/g;\r\n/**\r\n * @private\r\n */\r\nconst hyphenate = cacheStringFunction((str) => {\r\n    return str.replace(hyphenateRE, '-$1').toLowerCase();\r\n});\r\n/**\r\n * @private\r\n */\r\nconst capitalize = cacheStringFunction((str) => {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n});\r\n// compare whether a value has changed, accounting for NaN.\r\nconst hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);\r\nconst def = (obj, key, value) => {\r\n    Object.defineProperty(obj, key, {\r\n        configurable: true,\r\n        enumerable: false,\r\n        value\r\n    });\r\n};\r\nconst toNumber = (val) => {\r\n    const n = parseFloat(val);\r\n    return isNaN(n) ? val : n;\r\n};\r\nlet _globalThis;\r\nconst getGlobalThis = () => {\r\n    return (_globalThis ||\r\n        (_globalThis =\r\n            typeof globalThis !== 'undefined'\r\n                ? globalThis\r\n                : typeof self !== 'undefined'\r\n                    ? self\r\n                    : typeof window !== 'undefined'\r\n                        ? window\r\n                        : typeof global !== 'undefined'\r\n                            ? global\r\n                            : {}));\r\n};\n\nconst targetMap = new WeakMap();\r\nconst effectStack = [];\r\nlet activeEffect;\r\nconst ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');\r\nconst MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');\r\nfunction isEffect(fn) {\r\n    return fn && fn._isEffect === true;\r\n}\r\nfunction effect(fn, options = EMPTY_OBJ) {\r\n    if (isEffect(fn)) {\r\n        fn = fn.raw;\r\n    }\r\n    const effect = createReactiveEffect(fn, options);\r\n    if (!options.lazy) {\r\n        effect();\r\n    }\r\n    return effect;\r\n}\r\nfunction stop(effect) {\r\n    if (effect.active) {\r\n        cleanup(effect);\r\n        if (effect.options.onStop) {\r\n            effect.options.onStop();\r\n        }\r\n        effect.active = false;\r\n    }\r\n}\r\nlet uid = 0;\r\nfunction createReactiveEffect(fn, options) {\r\n    const effect = function reactiveEffect() {\r\n        if (!effect.active) {\r\n            return options.scheduler ? undefined : fn();\r\n        }\r\n        if (!effectStack.includes(effect)) {\r\n            cleanup(effect);\r\n            try {\r\n                enableTracking();\r\n                effectStack.push(effect);\r\n                activeEffect = effect;\r\n                return fn();\r\n            }\r\n            finally {\r\n                effectStack.pop();\r\n                resetTracking();\r\n                activeEffect = effectStack[effectStack.length - 1];\r\n            }\r\n        }\r\n    };\r\n    effect.id = uid++;\r\n    effect._isEffect = true;\r\n    effect.active = true;\r\n    effect.raw = fn;\r\n    effect.deps = [];\r\n    effect.options = options;\r\n    return effect;\r\n}\r\nfunction cleanup(effect) {\r\n    const { deps } = effect;\r\n    if (deps.length) {\r\n        for (let i = 0; i < deps.length; i++) {\r\n            deps[i].delete(effect);\r\n        }\r\n        deps.length = 0;\r\n    }\r\n}\r\nlet shouldTrack = true;\r\nconst trackStack = [];\r\nfunction pauseTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = false;\r\n}\r\nfunction enableTracking() {\r\n    trackStack.push(shouldTrack);\r\n    shouldTrack = true;\r\n}\r\nfunction resetTracking() {\r\n    const last = trackStack.pop();\r\n    shouldTrack = last === undefined ? true : last;\r\n}\r\nfunction track(target, type, key) {\r\n    if (!shouldTrack || activeEffect === undefined) {\r\n        return;\r\n    }\r\n    let depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        targetMap.set(target, (depsMap = new Map()));\r\n    }\r\n    let dep = depsMap.get(key);\r\n    if (!dep) {\r\n        depsMap.set(key, (dep = new Set()));\r\n    }\r\n    if (!dep.has(activeEffect)) {\r\n        dep.add(activeEffect);\r\n        activeEffect.deps.push(dep);\r\n        if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {\r\n            activeEffect.options.onTrack({\r\n                effect: activeEffect,\r\n                target,\r\n                type,\r\n                key\r\n            });\r\n        }\r\n    }\r\n}\r\nfunction trigger(target, type, key, newValue, oldValue, oldTarget) {\r\n    const depsMap = targetMap.get(target);\r\n    if (!depsMap) {\r\n        // never been tracked\r\n        return;\r\n    }\r\n    const effects = new Set();\r\n    const add = (effectsToAdd) => {\r\n        if (effectsToAdd) {\r\n            effectsToAdd.forEach(effect => {\r\n                if (effect !== activeEffect) {\r\n                    effects.add(effect);\r\n                }\r\n            });\r\n        }\r\n    };\r\n    if (type === \"clear\" /* CLEAR */) {\r\n        // collection being cleared\r\n        // trigger all effects for target\r\n        depsMap.forEach(add);\r\n    }\r\n    else if (key === 'length' && isArray(target)) {\r\n        depsMap.forEach((dep, key) => {\r\n            if (key === 'length' || key >= newValue) {\r\n                add(dep);\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        // schedule runs for SET | ADD | DELETE\r\n        if (key !== void 0) {\r\n            add(depsMap.get(key));\r\n        }\r\n        // also run for iteration key on ADD | DELETE | Map.SET\r\n        const isAddOrDelete = type === \"add\" /* ADD */ ||\r\n            (type === \"delete\" /* DELETE */ && !isArray(target));\r\n        if (isAddOrDelete ||\r\n            (type === \"set\" /* SET */ && target instanceof Map)) {\r\n            add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));\r\n        }\r\n        if (isAddOrDelete && target instanceof Map) {\r\n            add(depsMap.get(MAP_KEY_ITERATE_KEY));\r\n        }\r\n    }\r\n    const run = (effect) => {\r\n        if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {\r\n            effect.options.onTrigger({\r\n                effect,\r\n                target,\r\n                key,\r\n                type,\r\n                newValue,\r\n                oldValue,\r\n                oldTarget\r\n            });\r\n        }\r\n        if (effect.options.scheduler) {\r\n            effect.options.scheduler(effect);\r\n        }\r\n        else {\r\n            effect();\r\n        }\r\n    };\r\n    effects.forEach(run);\r\n}\n\nconst builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)\r\n    .map(key => Symbol[key])\r\n    .filter(isSymbol));\r\nconst get = /*#__PURE__*/ createGetter();\r\nconst shallowGet = /*#__PURE__*/ createGetter(false, true);\r\nconst readonlyGet = /*#__PURE__*/ createGetter(true);\r\nconst shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);\r\nconst arrayInstrumentations = {};\r\n['includes', 'indexOf', 'lastIndexOf'].forEach(key => {\r\n    arrayInstrumentations[key] = function (...args) {\r\n        const arr = toRaw(this);\r\n        for (let i = 0, l = this.length; i < l; i++) {\r\n            track(arr, \"get\" /* GET */, i + '');\r\n        }\r\n        // we run the method using the original args first (which may be reactive)\r\n        const res = arr[key](...args);\r\n        if (res === -1 || res === false) {\r\n            // if that didn't work, run it again using raw values.\r\n            return arr[key](...args.map(toRaw));\r\n        }\r\n        else {\r\n            return res;\r\n        }\r\n    };\r\n});\r\nfunction createGetter(isReadonly = false, shallow = false) {\r\n    return function get(target, key, receiver) {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */ &&\r\n            receiver ===\r\n                (isReadonly\r\n                    ? target[\"__v_readonly\" /* READONLY */]\r\n                    : target[\"__v_reactive\" /* REACTIVE */])) {\r\n            return target;\r\n        }\r\n        const targetIsArray = isArray(target);\r\n        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {\r\n            return Reflect.get(arrayInstrumentations, key, receiver);\r\n        }\r\n        const res = Reflect.get(target, key, receiver);\r\n        if (isSymbol(key)\r\n            ? builtInSymbols.has(key)\r\n            : key === `__proto__` || key === `__v_isRef`) {\r\n            return res;\r\n        }\r\n        if (!isReadonly) {\r\n            track(target, \"get\" /* GET */, key);\r\n        }\r\n        if (shallow) {\r\n            return res;\r\n        }\r\n        if (isRef(res)) {\r\n            // ref unwrapping, only for Objects, not for Arrays.\r\n            return targetIsArray ? res : res.value;\r\n        }\r\n        if (isObject(res)) {\r\n            // Convert returned value into a proxy as well. we do the isObject check\r\n            // here to avoid invalid value warning. Also need to lazy access readonly\r\n            // and reactive here to avoid circular dependency.\r\n            return isReadonly ? readonly(res) : reactive(res);\r\n        }\r\n        return res;\r\n    };\r\n}\r\nconst set = /*#__PURE__*/ createSetter();\r\nconst shallowSet = /*#__PURE__*/ createSetter(true);\r\nfunction createSetter(shallow = false) {\r\n    return function set(target, key, value, receiver) {\r\n        const oldValue = target[key];\r\n        if (!shallow) {\r\n            value = toRaw(value);\r\n            if (!isArray(target) && isRef(oldValue) && !isRef(value)) {\r\n                oldValue.value = value;\r\n                return true;\r\n            }\r\n        }\r\n        const hadKey = hasOwn(target, key);\r\n        const result = Reflect.set(target, key, value, receiver);\r\n        // don't trigger if target is something up in the prototype chain of original\r\n        if (target === toRaw(receiver)) {\r\n            if (!hadKey) {\r\n                trigger(target, \"add\" /* ADD */, key, value);\r\n            }\r\n            else if (hasChanged(value, oldValue)) {\r\n                trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n            }\r\n        }\r\n        return result;\r\n    };\r\n}\r\nfunction deleteProperty(target, key) {\r\n    const hadKey = hasOwn(target, key);\r\n    const oldValue = target[key];\r\n    const result = Reflect.deleteProperty(target, key);\r\n    if (result && hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction has(target, key) {\r\n    const result = Reflect.has(target, key);\r\n    if (!isSymbol(key) || !builtInSymbols.has(key)) {\r\n        track(target, \"has\" /* HAS */, key);\r\n    }\r\n    return result;\r\n}\r\nfunction ownKeys(target) {\r\n    track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.ownKeys(target);\r\n}\r\nconst mutableHandlers = {\r\n    get,\r\n    set,\r\n    deleteProperty,\r\n    has,\r\n    ownKeys\r\n};\r\nconst readonlyHandlers = {\r\n    get: readonlyGet,\r\n    has,\r\n    ownKeys,\r\n    set(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Set operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    },\r\n    deleteProperty(target, key) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`Delete operation on key \"${String(key)}\" failed: target is readonly.`, target);\r\n        }\r\n        return true;\r\n    }\r\n};\r\nconst shallowReactiveHandlers = extend({}, mutableHandlers, {\r\n    get: shallowGet,\r\n    set: shallowSet\r\n});\r\n// Props handlers are special in the sense that it should not unwrap top-level\r\n// refs (in order to allow refs to be explicitly passed down), but should\r\n// retain the reactivity of the normal readonly object.\r\nconst shallowReadonlyHandlers = extend({}, readonlyHandlers, {\r\n    get: shallowReadonlyGet\r\n});\n\nconst toReactive = (value) => isObject(value) ? reactive(value) : value;\r\nconst toReadonly = (value) => isObject(value) ? readonly(value) : value;\r\nconst toShallow = (value) => value;\r\nconst getProto = (v) => Reflect.getPrototypeOf(v);\r\nfunction get$1(target, key, isReadonly = false, isShallow = false) {\r\n    // #1772: readonly(reactive(Map)) should return readonly + reactive version\r\n    // of the value\r\n    target = target[\"__v_raw\" /* RAW */];\r\n    const rawTarget = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        !isReadonly && track(rawTarget, \"get\" /* GET */, key);\r\n    }\r\n    !isReadonly && track(rawTarget, \"get\" /* GET */, rawKey);\r\n    const { has } = getProto(rawTarget);\r\n    const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n    if (has.call(rawTarget, key)) {\r\n        return wrap(target.get(key));\r\n    }\r\n    else if (has.call(rawTarget, rawKey)) {\r\n        return wrap(target.get(rawKey));\r\n    }\r\n}\r\nfunction has$1(key, isReadonly = false) {\r\n    const target = this[\"__v_raw\" /* RAW */];\r\n    const rawTarget = toRaw(target);\r\n    const rawKey = toRaw(key);\r\n    if (key !== rawKey) {\r\n        !isReadonly && track(rawTarget, \"has\" /* HAS */, key);\r\n    }\r\n    !isReadonly && track(rawTarget, \"has\" /* HAS */, rawKey);\r\n    return target.has(key) || target.has(rawKey);\r\n}\r\nfunction size(target, isReadonly = false) {\r\n    target = target[\"__v_raw\" /* RAW */];\r\n    !isReadonly && track(toRaw(target), \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n    return Reflect.get(target, 'size', target);\r\n}\r\nfunction add(value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const proto = getProto(target);\r\n    const hadKey = proto.has.call(target, value);\r\n    const result = proto.add.call(target, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, value, value);\r\n    }\r\n    return result;\r\n}\r\nfunction set$1(key, value) {\r\n    value = toRaw(value);\r\n    const target = toRaw(this);\r\n    const { has, get, set } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get.call(target, key);\r\n    const result = set.call(target, key, value);\r\n    if (!hadKey) {\r\n        trigger(target, \"add\" /* ADD */, key, value);\r\n    }\r\n    else if (hasChanged(value, oldValue)) {\r\n        trigger(target, \"set\" /* SET */, key, value, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction deleteEntry(key) {\r\n    const target = toRaw(this);\r\n    const { has, get, delete: del } = getProto(target);\r\n    let hadKey = has.call(target, key);\r\n    if (!hadKey) {\r\n        key = toRaw(key);\r\n        hadKey = has.call(target, key);\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        checkIdentityKeys(target, has, key);\r\n    }\r\n    const oldValue = get ? get.call(target, key) : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = del.call(target, key);\r\n    if (hadKey) {\r\n        trigger(target, \"delete\" /* DELETE */, key, undefined, oldValue);\r\n    }\r\n    return result;\r\n}\r\nfunction clear() {\r\n    const target = toRaw(this);\r\n    const hadItems = target.size !== 0;\r\n    const oldTarget = (process.env.NODE_ENV !== 'production')\r\n        ? target instanceof Map\r\n            ? new Map(target)\r\n            : new Set(target)\r\n        : undefined;\r\n    // forward the operation before queueing reactions\r\n    const result = getProto(target).clear.call(target);\r\n    if (hadItems) {\r\n        trigger(target, \"clear\" /* CLEAR */, undefined, undefined, oldTarget);\r\n    }\r\n    return result;\r\n}\r\nfunction createForEach(isReadonly, isShallow) {\r\n    return function forEach(callback, thisArg) {\r\n        const observed = this;\r\n        const target = toRaw(observed);\r\n        const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n        !isReadonly && track(target, \"iterate\" /* ITERATE */, ITERATE_KEY);\r\n        // important: create sure the callback is\r\n        // 1. invoked with the reactive map as `this` and 3rd arg\r\n        // 2. the value received should be a corresponding reactive/readonly.\r\n        function wrappedCallback(value, key) {\r\n            return callback.call(thisArg, wrap(value), wrap(key), observed);\r\n        }\r\n        return getProto(target).forEach.call(target, wrappedCallback);\r\n    };\r\n}\r\nfunction createIterableMethod(method, isReadonly, isShallow) {\r\n    return function (...args) {\r\n        const target = this[\"__v_raw\" /* RAW */];\r\n        const rawTarget = toRaw(target);\r\n        const isMap = rawTarget instanceof Map;\r\n        const isPair = method === 'entries' || (method === Symbol.iterator && isMap);\r\n        const isKeyOnly = method === 'keys' && isMap;\r\n        const innerIterator = target[method](...args);\r\n        const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;\r\n        !isReadonly &&\r\n            track(rawTarget, \"iterate\" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);\r\n        // return a wrapped iterator which returns observed versions of the\r\n        // values emitted from the real iterator\r\n        return {\r\n            // iterator protocol\r\n            next() {\r\n                const { value, done } = innerIterator.next();\r\n                return done\r\n                    ? { value, done }\r\n                    : {\r\n                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),\r\n                        done\r\n                    };\r\n            },\r\n            // iterable protocol\r\n            [Symbol.iterator]() {\r\n                return this;\r\n            }\r\n        };\r\n    };\r\n}\r\nfunction createReadonlyMethod(type) {\r\n    return function (...args) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            const key = args[0] ? `on key \"${args[0]}\" ` : ``;\r\n            console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));\r\n        }\r\n        return type === \"delete\" /* DELETE */ ? false : this;\r\n    };\r\n}\r\nconst mutableInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, false)\r\n};\r\nconst shallowInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, false, true);\r\n    },\r\n    get size() {\r\n        return size(this);\r\n    },\r\n    has: has$1,\r\n    add,\r\n    set: set$1,\r\n    delete: deleteEntry,\r\n    clear,\r\n    forEach: createForEach(false, true)\r\n};\r\nconst readonlyInstrumentations = {\r\n    get(key) {\r\n        return get$1(this, key, true);\r\n    },\r\n    get size() {\r\n        return size(this, true);\r\n    },\r\n    has(key) {\r\n        return has$1.call(this, key, true);\r\n    },\r\n    add: createReadonlyMethod(\"add\" /* ADD */),\r\n    set: createReadonlyMethod(\"set\" /* SET */),\r\n    delete: createReadonlyMethod(\"delete\" /* DELETE */),\r\n    clear: createReadonlyMethod(\"clear\" /* CLEAR */),\r\n    forEach: createForEach(true, false)\r\n};\r\nconst iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];\r\niteratorMethods.forEach(method => {\r\n    mutableInstrumentations[method] = createIterableMethod(method, false, false);\r\n    readonlyInstrumentations[method] = createIterableMethod(method, true, false);\r\n    shallowInstrumentations[method] = createIterableMethod(method, false, true);\r\n});\r\nfunction createInstrumentationGetter(isReadonly, shallow) {\r\n    const instrumentations = shallow\r\n        ? shallowInstrumentations\r\n        : isReadonly\r\n            ? readonlyInstrumentations\r\n            : mutableInstrumentations;\r\n    return (target, key, receiver) => {\r\n        if (key === \"__v_isReactive\" /* IS_REACTIVE */) {\r\n            return !isReadonly;\r\n        }\r\n        else if (key === \"__v_isReadonly\" /* IS_READONLY */) {\r\n            return isReadonly;\r\n        }\r\n        else if (key === \"__v_raw\" /* RAW */) {\r\n            return target;\r\n        }\r\n        return Reflect.get(hasOwn(instrumentations, key) && key in target\r\n            ? instrumentations\r\n            : target, key, receiver);\r\n    };\r\n}\r\nconst mutableCollectionHandlers = {\r\n    get: createInstrumentationGetter(false, false)\r\n};\r\nconst readonlyCollectionHandlers = {\r\n    get: createInstrumentationGetter(true, false)\r\n};\r\nfunction checkIdentityKeys(target, has, key) {\r\n    const rawKey = toRaw(key);\r\n    if (rawKey !== key && has.call(target, rawKey)) {\r\n        const type = toRawType(target);\r\n        console.warn(`Reactive ${type} contains both the raw and reactive ` +\r\n            `versions of the same object${type === `Map` ? `as keys` : ``}, ` +\r\n            `which can lead to inconsistencies. ` +\r\n            `Avoid differentiating between the raw and reactive versions ` +\r\n            `of an object and only use the reactive version if possible.`);\r\n    }\r\n}\n\nfunction targetTypeMap(rawType) {\r\n    switch (rawType) {\r\n        case 'Object':\r\n        case 'Array':\r\n            return 1 /* COMMON */;\r\n        case 'Map':\r\n        case 'Set':\r\n        case 'WeakMap':\r\n        case 'WeakSet':\r\n            return 2 /* COLLECTION */;\r\n        default:\r\n            return 0 /* INVALID */;\r\n    }\r\n}\r\nfunction getTargetType(value) {\r\n    return value[\"__v_skip\" /* SKIP */] || !Object.isExtensible(value)\r\n        ? 0 /* INVALID */\r\n        : targetTypeMap(toRawType(value));\r\n}\r\nfunction reactive(target) {\r\n    // if trying to observe a readonly proxy, return the readonly version.\r\n    if (target && target[\"__v_isReadonly\" /* IS_READONLY */]) {\r\n        return target;\r\n    }\r\n    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);\r\n}\r\nfunction readonly(target) {\r\n    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);\r\n}\r\n// Return a reactive-copy of the original object, where only the root level\r\n// properties are readonly, and does NOT unwrap refs nor recursively convert\r\n// returned properties.\r\n// This is used for creating the props proxy object for stateful components.\r\nfunction shallowReadonly(target) {\r\n    return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);\r\n}\r\nfunction createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {\r\n    if (!isObject(target)) {\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            console.warn(`value cannot be made reactive: ${String(target)}`);\r\n        }\r\n        return target;\r\n    }\r\n    // target is already a Proxy, return it.\r\n    // exception: calling readonly() on a reactive object\r\n    if (target[\"__v_raw\" /* RAW */] &&\r\n        !(isReadonly && target[\"__v_isReactive\" /* IS_REACTIVE */])) {\r\n        return target;\r\n    }\r\n    // target already has corresponding Proxy\r\n    const reactiveFlag = isReadonly\r\n        ? \"__v_readonly\" /* READONLY */\r\n        : \"__v_reactive\" /* REACTIVE */;\r\n    if (hasOwn(target, reactiveFlag)) {\r\n        return target[reactiveFlag];\r\n    }\r\n    // only a whitelist of value types can be observed.\r\n    const targetType = getTargetType(target);\r\n    if (targetType === 0 /* INVALID */) {\r\n        return target;\r\n    }\r\n    const observed = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);\r\n    def(target, reactiveFlag, observed);\r\n    return observed;\r\n}\r\nfunction isReactive(value) {\r\n    if (isReadonly(value)) {\r\n        return isReactive(value[\"__v_raw\" /* RAW */]);\r\n    }\r\n    return !!(value && value[\"__v_isReactive\" /* IS_REACTIVE */]);\r\n}\r\nfunction isReadonly(value) {\r\n    return !!(value && value[\"__v_isReadonly\" /* IS_READONLY */]);\r\n}\r\nfunction isProxy(value) {\r\n    return isReactive(value) || isReadonly(value);\r\n}\r\nfunction toRaw(observed) {\r\n    return ((observed && toRaw(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\r\nfunction isRef(r) {\r\n    return r ? r.__v_isRef === true : false;\r\n}\n\nconst stack = [];\r\nfunction pushWarningContext(vnode) {\r\n    stack.push(vnode);\r\n}\r\nfunction popWarningContext() {\r\n    stack.pop();\r\n}\r\nfunction warn(msg, ...args) {\r\n    // avoid props formatting or warn handler tracking deps that might be mutated\r\n    // during patch, leading to infinite recursion.\r\n    pauseTracking();\r\n    const instance = stack.length ? stack[stack.length - 1].component : null;\r\n    const appWarnHandler = instance && instance.appContext.config.warnHandler;\r\n    const trace = getComponentTrace();\r\n    if (appWarnHandler) {\r\n        callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [\r\n            msg + args.join(''),\r\n            instance && instance.proxy,\r\n            trace\r\n                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)\r\n                .join('\\n'),\r\n            trace\r\n        ]);\r\n    }\r\n    else {\r\n        const warnArgs = [`[Vue warn]: ${msg}`, ...args];\r\n        /* istanbul ignore if */\r\n        if (trace.length &&\r\n            // avoid spamming console during tests\r\n            !false) {\r\n            warnArgs.push(`\\n`, ...formatTrace(trace));\r\n        }\r\n        console.warn(...warnArgs);\r\n    }\r\n    resetTracking();\r\n}\r\nfunction getComponentTrace() {\r\n    let currentVNode = stack[stack.length - 1];\r\n    if (!currentVNode) {\r\n        return [];\r\n    }\r\n    // we can't just use the stack because it will be incomplete during updates\r\n    // that did not start from the root. Re-construct the parent chain using\r\n    // instance parent pointers.\r\n    const normalizedStack = [];\r\n    while (currentVNode) {\r\n        const last = normalizedStack[0];\r\n        if (last && last.vnode === currentVNode) {\r\n            last.recurseCount++;\r\n        }\r\n        else {\r\n            normalizedStack.push({\r\n                vnode: currentVNode,\r\n                recurseCount: 0\r\n            });\r\n        }\r\n        const parentInstance = currentVNode.component && currentVNode.component.parent;\r\n        currentVNode = parentInstance && parentInstance.vnode;\r\n    }\r\n    return normalizedStack;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatTrace(trace) {\r\n    const logs = [];\r\n    trace.forEach((entry, i) => {\r\n        logs.push(...(i === 0 ? [] : [`\\n`]), ...formatTraceEntry(entry));\r\n    });\r\n    return logs;\r\n}\r\nfunction formatTraceEntry({ vnode, recurseCount }) {\r\n    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;\r\n    const isRoot = vnode.component ? vnode.component.parent == null : false;\r\n    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;\r\n    const close = `>` + postfix;\r\n    return vnode.props\r\n        ? [open, ...formatProps(vnode.props), close]\r\n        : [open + close];\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProps(props) {\r\n    const res = [];\r\n    const keys = Object.keys(props);\r\n    keys.slice(0, 3).forEach(key => {\r\n        res.push(...formatProp(key, props[key]));\r\n    });\r\n    if (keys.length > 3) {\r\n        res.push(` ...`);\r\n    }\r\n    return res;\r\n}\r\n/* istanbul ignore next */\r\nfunction formatProp(key, value, raw) {\r\n    if (isString(value)) {\r\n        value = JSON.stringify(value);\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (typeof value === 'number' ||\r\n        typeof value === 'boolean' ||\r\n        value == null) {\r\n        return raw ? value : [`${key}=${value}`];\r\n    }\r\n    else if (isRef(value)) {\r\n        value = formatProp(key, toRaw(value.value), true);\r\n        return raw ? value : [`${key}=Ref<`, value, `>`];\r\n    }\r\n    else if (isFunction(value)) {\r\n        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];\r\n    }\r\n    else {\r\n        value = toRaw(value);\r\n        return raw ? value : [`${key}=`, value];\r\n    }\r\n}\n\nconst ErrorTypeStrings = {\r\n    [\"bc\" /* BEFORE_CREATE */]: 'beforeCreate hook',\r\n    [\"c\" /* CREATED */]: 'created hook',\r\n    [\"bm\" /* BEFORE_MOUNT */]: 'beforeMount hook',\r\n    [\"m\" /* MOUNTED */]: 'mounted hook',\r\n    [\"bu\" /* BEFORE_UPDATE */]: 'beforeUpdate hook',\r\n    [\"u\" /* UPDATED */]: 'updated',\r\n    [\"bum\" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',\r\n    [\"um\" /* UNMOUNTED */]: 'unmounted hook',\r\n    [\"a\" /* ACTIVATED */]: 'activated hook',\r\n    [\"da\" /* DEACTIVATED */]: 'deactivated hook',\r\n    [\"ec\" /* ERROR_CAPTURED */]: 'errorCaptured hook',\r\n    [\"rtc\" /* RENDER_TRACKED */]: 'renderTracked hook',\r\n    [\"rtg\" /* RENDER_TRIGGERED */]: 'renderTriggered hook',\r\n    [0 /* SETUP_FUNCTION */]: 'setup function',\r\n    [1 /* RENDER_FUNCTION */]: 'render function',\r\n    [2 /* WATCH_GETTER */]: 'watcher getter',\r\n    [3 /* WATCH_CALLBACK */]: 'watcher callback',\r\n    [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',\r\n    [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',\r\n    [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',\r\n    [7 /* VNODE_HOOK */]: 'vnode hook',\r\n    [8 /* DIRECTIVE_HOOK */]: 'directive hook',\r\n    [9 /* TRANSITION_HOOK */]: 'transition hook',\r\n    [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',\r\n    [11 /* APP_WARN_HANDLER */]: 'app warnHandler',\r\n    [12 /* FUNCTION_REF */]: 'ref function',\r\n    [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',\r\n    [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +\r\n        'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'\r\n};\r\nfunction callWithErrorHandling(fn, instance, type, args) {\r\n    let res;\r\n    try {\r\n        res = args ? fn(...args) : fn();\r\n    }\r\n    catch (err) {\r\n        handleError(err, instance, type);\r\n    }\r\n    return res;\r\n}\r\nfunction callWithAsyncErrorHandling(fn, instance, type, args) {\r\n    if (isFunction(fn)) {\r\n        const res = callWithErrorHandling(fn, instance, type, args);\r\n        if (res && isPromise(res)) {\r\n            res.catch(err => {\r\n                handleError(err, instance, type);\r\n            });\r\n        }\r\n        return res;\r\n    }\r\n    const values = [];\r\n    for (let i = 0; i < fn.length; i++) {\r\n        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));\r\n    }\r\n    return values;\r\n}\r\nfunction handleError(err, instance, type) {\r\n    const contextVNode = instance ? instance.vnode : null;\r\n    if (instance) {\r\n        let cur = instance.parent;\r\n        // the exposed instance is the render proxy to keep it consistent with 2.x\r\n        const exposedInstance = instance.proxy;\r\n        // in production the hook receives only the error code\r\n        const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] : type;\r\n        while (cur) {\r\n            const errorCapturedHooks = cur.ec;\r\n            if (errorCapturedHooks) {\r\n                for (let i = 0; i < errorCapturedHooks.length; i++) {\r\n                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {\r\n                        return;\r\n                    }\r\n                }\r\n            }\r\n            cur = cur.parent;\r\n        }\r\n        // app-level handling\r\n        const appErrorHandler = instance.appContext.config.errorHandler;\r\n        if (appErrorHandler) {\r\n            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);\r\n            return;\r\n        }\r\n    }\r\n    logError(err, type, contextVNode);\r\n}\r\nfunction logError(err, type, contextVNode) {\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        const info = ErrorTypeStrings[type];\r\n        if (contextVNode) {\r\n            pushWarningContext(contextVNode);\r\n        }\r\n        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);\r\n        if (contextVNode) {\r\n            popWarningContext();\r\n        }\r\n        // crash in dev so it's more noticeable\r\n        throw err;\r\n    }\r\n    else {\r\n        // recover in prod to reduce the impact on end-user\r\n        console.error(err);\r\n    }\r\n}\n\nlet isFlushing = false;\r\nlet isFlushPending = false;\r\nconst queue = [];\r\nlet flushIndex = 0;\r\nconst pendingPreFlushCbs = [];\r\nlet activePreFlushCbs = null;\r\nlet preFlushIndex = 0;\r\nconst pendingPostFlushCbs = [];\r\nlet activePostFlushCbs = null;\r\nlet postFlushIndex = 0;\r\nconst resolvedPromise = Promise.resolve();\r\nlet currentFlushPromise = null;\r\nlet currentPreFlushParentJob = null;\r\nconst RECURSION_LIMIT = 100;\r\nfunction nextTick(fn) {\r\n    const p = currentFlushPromise || resolvedPromise;\r\n    return fn ? p.then(fn) : p;\r\n}\r\nfunction queueJob(job) {\r\n    // the dedupe search uses the startIndex argument of Array.includes()\r\n    // by default the search index includes the current job that is being run\r\n    // so it cannot recursively trigger itself again.\r\n    // if the job is a watch() callback, the search will start with a +1 index to\r\n    // allow it recursively trigger itself - it is the user's responsibility to\r\n    // ensure it doesn't end up in an infinite loop.\r\n    if ((!queue.length ||\r\n        !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&\r\n        job !== currentPreFlushParentJob) {\r\n        queue.push(job);\r\n        queueFlush();\r\n    }\r\n}\r\nfunction queueFlush() {\r\n    if (!isFlushing && !isFlushPending) {\r\n        isFlushPending = true;\r\n        currentFlushPromise = resolvedPromise.then(flushJobs);\r\n    }\r\n}\r\nfunction queueCb(cb, activeQueue, pendingQueue, index) {\r\n    if (!isArray(cb)) {\r\n        if (!activeQueue ||\r\n            !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {\r\n            pendingQueue.push(cb);\r\n        }\r\n    }\r\n    else {\r\n        // if cb is an array, it is a component lifecycle hook which can only be\r\n        // triggered by a job, which is already deduped in the main queue, so\r\n        // we can skip duplicate check here to improve perf\r\n        pendingQueue.push(...cb);\r\n    }\r\n    queueFlush();\r\n}\r\nfunction queuePreFlushCb(cb) {\r\n    queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);\r\n}\r\nfunction queuePostFlushCb(cb) {\r\n    queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);\r\n}\r\nfunction flushPreFlushCbs(seen, parentJob = null) {\r\n    if (pendingPreFlushCbs.length) {\r\n        currentPreFlushParentJob = parentJob;\r\n        activePreFlushCbs = [...new Set(pendingPreFlushCbs)];\r\n        pendingPreFlushCbs.length = 0;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);\r\n            }\r\n            activePreFlushCbs[preFlushIndex]();\r\n        }\r\n        activePreFlushCbs = null;\r\n        preFlushIndex = 0;\r\n        currentPreFlushParentJob = null;\r\n        // recursively flush until it drains\r\n        flushPreFlushCbs(seen, parentJob);\r\n    }\r\n}\r\nfunction flushPostFlushCbs(seen) {\r\n    if (pendingPostFlushCbs.length) {\r\n        activePostFlushCbs = [...new Set(pendingPostFlushCbs)];\r\n        pendingPostFlushCbs.length = 0;\r\n        if ((process.env.NODE_ENV !== 'production')) {\r\n            seen = seen || new Map();\r\n        }\r\n        activePostFlushCbs.sort((a, b) => getId(a) - getId(b));\r\n        for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);\r\n            }\r\n            activePostFlushCbs[postFlushIndex]();\r\n        }\r\n        activePostFlushCbs = null;\r\n        postFlushIndex = 0;\r\n    }\r\n}\r\nconst getId = (job) => job.id == null ? Infinity : job.id;\r\nfunction flushJobs(seen) {\r\n    isFlushPending = false;\r\n    isFlushing = true;\r\n    if ((process.env.NODE_ENV !== 'production')) {\r\n        seen = seen || new Map();\r\n    }\r\n    flushPreFlushCbs(seen);\r\n    // Sort queue before flush.\r\n    // This ensures that:\r\n    // 1. Components are updated from parent to child. (because parent is always\r\n    //    created before the child so its render effect will have smaller\r\n    //    priority number)\r\n    // 2. If a component is unmounted during a parent component's update,\r\n    //    its update can be skipped.\r\n    // Jobs can never be null before flush starts, since they are only invalidated\r\n    // during execution of another flushed job.\r\n    queue.sort((a, b) => getId(a) - getId(b));\r\n    try {\r\n        for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {\r\n            const job = queue[flushIndex];\r\n            if (job) {\r\n                if ((process.env.NODE_ENV !== 'production')) {\r\n                    checkRecursiveUpdates(seen, job);\r\n                }\r\n                callWithErrorHandling(job, null, 14 /* SCHEDULER */);\r\n            }\r\n        }\r\n    }\r\n    finally {\r\n        flushIndex = 0;\r\n        queue.length = 0;\r\n        flushPostFlushCbs(seen);\r\n        isFlushing = false;\r\n        currentFlushPromise = null;\r\n        // some postFlushCb queued jobs!\r\n        // keep flushing until it drains.\r\n        if (queue.length || pendingPostFlushCbs.length) {\r\n            flushJobs(seen);\r\n        }\r\n    }\r\n}\r\nfunction checkRecursiveUpdates(seen, fn) {\r\n    if (!seen.has(fn)) {\r\n        seen.set(fn, 1);\r\n    }\r\n    else {\r\n        const count = seen.get(fn);\r\n        if (count > RECURSION_LIMIT) {\r\n            throw new Error(`Maximum recursive updates exceeded. ` +\r\n                `This means you have a reactive effect that is mutating its own ` +\r\n                `dependencies and thus recursively triggering itself. Possible sources ` +\r\n                `include component template, render function, updated hook or ` +\r\n                `watcher source function.`);\r\n        }\r\n        else {\r\n            seen.set(fn, count + 1);\r\n        }\r\n    }\r\n}\nconst hmrDirtyComponents = new Set();\r\n// Expose the HMR runtime on the global object\r\n// This makes it entirely tree-shakable without polluting the exports and makes\r\n// it easier to be used in toolings like vue-loader\r\n// Note: for a component to be eligible for HMR it also needs the __hmrId option\r\n// to be set so that its instances can be registered / removed.\r\nif ((process.env.NODE_ENV !== 'production')) {\r\n    const globalObject = typeof global !== 'undefined'\r\n        ? global\r\n        : typeof self !== 'undefined'\r\n            ? self\r\n            : typeof window !== 'undefined'\r\n                ? window\r\n                : {};\r\n    globalObject.__VUE_HMR_RUNTIME__ = {\r\n        createRecord: tryWrap(createRecord),\r\n        rerender: tryWrap(rerender),\r\n        reload: tryWrap(reload)\r\n    };\r\n}\r\nconst map = new Map();\r\nfunction createRecord(id) {\r\n    if (map.has(id)) {\r\n        return false;\r\n    }\r\n    map.set(id, new Set());\r\n    return true;\r\n}\r\nfunction rerender(id, newRender) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        if (newRender) {\r\n            instance.render = newRender;\r\n        }\r\n        instance.renderCache = [];\r\n        instance.update();\r\n    });\r\n}\r\nfunction reload(id, newComp) {\r\n    const record = map.get(id);\r\n    if (!record)\r\n        return;\r\n    // Array.from creates a snapshot which avoids the set being mutated during\r\n    // updates\r\n    Array.from(record).forEach(instance => {\r\n        const comp = instance.type;\r\n        if (!hmrDirtyComponents.has(comp)) {\r\n            // 1. Update existing comp definition to match new one\r\n            extend(comp, newComp);\r\n            for (const key in comp) {\r\n                if (!(key in newComp)) {\r\n                    delete comp[key];\r\n                }\r\n            }\r\n            // 2. Mark component dirty. This forces the renderer to replace the component\r\n            // on patch.\r\n            hmrDirtyComponents.add(comp);\r\n            // 3. Make sure to unmark the component after the reload.\r\n            queuePostFlushCb(() => {\r\n                hmrDirtyComponents.delete(comp);\r\n            });\r\n        }\r\n        if (instance.parent) {\r\n            // 4. Force the parent instance to re-render. This will cause all updated\r\n            // components to be unmounted and re-mounted. Queue the update so that we\r\n            // don't end up forcing the same parent to re-render multiple times.\r\n            queueJob(instance.parent.update);\r\n        }\r\n        else if (instance.appContext.reload) {\r\n            // root instance mounted via createApp() has a reload method\r\n            instance.appContext.reload();\r\n        }\r\n        else if (typeof window !== 'undefined') {\r\n            // root instance inside tree created via raw render(). Force reload.\r\n            window.location.reload();\r\n        }\r\n        else {\r\n            console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');\r\n        }\r\n    });\r\n}\r\nfunction tryWrap(fn) {\r\n    return (id, arg) => {\r\n        try {\r\n            return fn(id, arg);\r\n        }\r\n        catch (e) {\r\n            console.error(e);\r\n            console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +\r\n                `Full reload required.`);\r\n        }\r\n    };\r\n}\n\n// mark the current rendering instance for asset resolution (e.g.\r\n// resolveComponent, resolveDirective) during render\r\nlet currentRenderingInstance = null;\r\nfunction markAttrsAccessed() {\r\n}\r\n\nconst isSuspense = (type) => type.__isSuspense;\r\nfunction queueEffectWithSuspense(fn, suspense) {\r\n    if (suspense && !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}\n\n// SFC scoped style ID management.\r\nlet currentScopeId = null;\r\n\nconst isTeleport = (type) => type.__isTeleport;\r\nconst NULL_DYNAMIC_COMPONENT = Symbol();\r\n\nlet isRenderingTemplateSlot = false;\r\n\nconst Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined);\r\nconst Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined);\r\nconst Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined);\r\nconst Static = Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined);\r\nlet currentBlock = null;\r\n// Whether we should be tracking dynamic child nodes inside a block.\r\n// Only tracks when this value is > 0\r\n// We are not using a simple boolean because this value may need to be\r\n// incremented/decremented by nested usage of v-once (see below)\r\nlet shouldTrack$1 = 1;\r\nfunction isVNode(value) {\r\n    return value ? value.__v_isVNode === true : false;\r\n}\r\nfunction isSameVNodeType(n1, n2) {\r\n    if ((process.env.NODE_ENV !== 'production') &&\r\n        n2.shapeFlag & 6 /* COMPONENT */ &&\r\n        hmrDirtyComponents.has(n2.type)) {\r\n        // HMR only: if the component has been hot-updated, force a reload.\r\n        return false;\r\n    }\r\n    return n1.type === n2.type && n1.key === n2.key;\r\n}\r\nlet vnodeArgsTransformer;\r\nconst createVNodeWithArgsTransform = (...args) => {\r\n    return _createVNode(...(vnodeArgsTransformer\r\n        ? vnodeArgsTransformer(args, currentRenderingInstance)\r\n        : args));\r\n};\r\nconst InternalObjectKey = `__vInternal`;\r\nconst normalizeKey = ({ key }) => key != null ? key : null;\r\nconst normalizeRef = ({ ref: ref$$1 }) => {\r\n    return (ref$$1 != null\r\n        ? isArray(ref$$1)\r\n            ? ref$$1\r\n            : [currentRenderingInstance, ref$$1]\r\n        : null);\r\n};\r\nconst createVNode = ((process.env.NODE_ENV !== 'production')\r\n    ? createVNodeWithArgsTransform\r\n    : _createVNode);\r\nfunction _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {\r\n    if (!type || type === NULL_DYNAMIC_COMPONENT) {\r\n        if ((process.env.NODE_ENV !== 'production') && !type) {\r\n            warn(`Invalid vnode type when creating vnode: ${type}.`);\r\n        }\r\n        type = Comment;\r\n    }\r\n    if (isVNode(type)) {\r\n        const cloned = cloneVNode(type, props);\r\n        if (children) {\r\n            normalizeChildren(cloned, children);\r\n        }\r\n        return cloned;\r\n    }\r\n    // class component normalization.\r\n    if (isFunction(type) && '__vccOpts' in type) {\r\n        type = type.__vccOpts;\r\n    }\r\n    // class & style normalization.\r\n    if (props) {\r\n        // for reactive or proxy objects, we need to clone it to enable mutation.\r\n        if (isProxy(props) || InternalObjectKey in props) {\r\n            props = extend({}, props);\r\n        }\r\n        let { class: klass, style } = props;\r\n        if (klass && !isString(klass)) {\r\n            props.class = normalizeClass(klass);\r\n        }\r\n        if (isObject(style)) {\r\n            // reactive state objects need to be cloned since they are likely to be\r\n            // mutated\r\n            if (isProxy(style) && !isArray(style)) {\r\n                style = extend({}, style);\r\n            }\r\n            props.style = normalizeStyle(style);\r\n        }\r\n    }\r\n    // encode the vnode type information into a bitmap\r\n    const shapeFlag = isString(type)\r\n        ? 1 /* ELEMENT */\r\n        :  isSuspense(type)\r\n            ? 128 /* SUSPENSE */\r\n            : isTeleport(type)\r\n                ? 64 /* TELEPORT */\r\n                : isObject(type)\r\n                    ? 4 /* STATEFUL_COMPONENT */\r\n                    : isFunction(type)\r\n                        ? 2 /* FUNCTIONAL_COMPONENT */\r\n                        : 0;\r\n    if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {\r\n        type = toRaw(type);\r\n        warn(`Vue received a Component which was made a reactive object. This can ` +\r\n            `lead to unnecessary performance overhead, and should be avoided by ` +\r\n            `marking the component with \\`markRaw\\` or using \\`shallowRef\\` ` +\r\n            `instead of \\`ref\\`.`, `\\nComponent that was made reactive: `, type);\r\n    }\r\n    const vnode = {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type,\r\n        props,\r\n        key: props && normalizeKey(props),\r\n        ref: props && normalizeRef(props),\r\n        scopeId: currentScopeId,\r\n        children: null,\r\n        component: null,\r\n        suspense: null,\r\n        dirs: null,\r\n        transition: null,\r\n        el: null,\r\n        anchor: null,\r\n        target: null,\r\n        targetAnchor: null,\r\n        staticCount: 0,\r\n        shapeFlag,\r\n        patchFlag,\r\n        dynamicProps,\r\n        dynamicChildren: null,\r\n        appContext: null\r\n    };\r\n    // validate key\r\n    if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) {\r\n        warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);\r\n    }\r\n    normalizeChildren(vnode, children);\r\n    if ((shouldTrack$1 > 0 || isRenderingTemplateSlot) &&\r\n        // avoid a block node from tracking itself\r\n        !isBlockNode &&\r\n        // has current parent block\r\n        currentBlock &&\r\n        // presence of a patch flag indicates this node needs patching on updates.\r\n        // component nodes also should always be patched, because even if the\r\n        // component doesn't need to update, it needs to persist the instance on to\r\n        // the next vnode so that it can be properly unmounted later.\r\n        (patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&\r\n        // the EVENTS flag is only for hydration and if it is the only flag, the\r\n        // vnode should not be considered dynamic due to handler caching.\r\n        patchFlag !== 32 /* HYDRATE_EVENTS */) {\r\n        currentBlock.push(vnode);\r\n    }\r\n    return vnode;\r\n}\r\nfunction cloneVNode(vnode, extraProps) {\r\n    // This is intentionally NOT using spread or extend to avoid the runtime\r\n    // key enumeration cost.\r\n    const { props, patchFlag } = vnode;\r\n    const mergedProps = extraProps\r\n        ? props\r\n            ? mergeProps(props, extraProps)\r\n            : extend({}, extraProps)\r\n        : props;\r\n    return {\r\n        __v_isVNode: true,\r\n        __v_skip: true,\r\n        type: vnode.type,\r\n        props: mergedProps,\r\n        key: mergedProps && normalizeKey(mergedProps),\r\n        ref: extraProps && extraProps.ref ? normalizeRef(extraProps) : vnode.ref,\r\n        scopeId: vnode.scopeId,\r\n        children: vnode.children,\r\n        target: vnode.target,\r\n        targetAnchor: vnode.targetAnchor,\r\n        staticCount: vnode.staticCount,\r\n        shapeFlag: vnode.shapeFlag,\r\n        // if the vnode is cloned with extra props, we can no longer assume its\r\n        // existing patch flag to be reliable and need to add the FULL_PROPS flag.\r\n        // note: perserve flag for fragments since they use the flag for children\r\n        // fast paths only.\r\n        patchFlag: extraProps && vnode.type !== Fragment\r\n            ? patchFlag === -1 // hoisted node\r\n                ? 16 /* FULL_PROPS */\r\n                : patchFlag | 16 /* FULL_PROPS */\r\n            : patchFlag,\r\n        dynamicProps: vnode.dynamicProps,\r\n        dynamicChildren: vnode.dynamicChildren,\r\n        appContext: vnode.appContext,\r\n        dirs: vnode.dirs,\r\n        transition: vnode.transition,\r\n        // These should technically only be non-null on mounted VNodes. However,\r\n        // they *should* be copied for kept-alive vnodes. So we just always copy\r\n        // them since them being non-null during a mount doesn't affect the logic as\r\n        // they will simply be overwritten.\r\n        component: vnode.component,\r\n        suspense: vnode.suspense,\r\n        el: vnode.el,\r\n        anchor: vnode.anchor\r\n    };\r\n}\r\n/**\r\n * @private\r\n */\r\nfunction createTextVNode(text$$1 = ' ', flag = 0) {\r\n    return createVNode(Text, null, text$$1, flag);\r\n}\r\nfunction normalizeChildren(vnode, children) {\r\n    let type = 0;\r\n    const { shapeFlag } = vnode;\r\n    if (children == null) {\r\n        children = null;\r\n    }\r\n    else if (isArray(children)) {\r\n        type = 16 /* ARRAY_CHILDREN */;\r\n    }\r\n    else if (typeof children === 'object') {\r\n        // Normalize slot to plain children\r\n        if ((shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) &&\r\n            children.default) {\r\n            normalizeChildren(vnode, children.default());\r\n            return;\r\n        }\r\n        else {\r\n            type = 32 /* SLOTS_CHILDREN */;\r\n            const slotFlag = children._;\r\n            if (!slotFlag && !(InternalObjectKey in children)) {\r\n                children._ctx = currentRenderingInstance;\r\n            }\r\n            else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {\r\n                // a child component receives forwarded slots from the parent.\r\n                // its slot type is determined by its parent's slot type.\r\n                if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {\r\n                    children._ = 2 /* DYNAMIC */;\r\n                    vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;\r\n                }\r\n                else {\r\n                    children._ = 1 /* STABLE */;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(children)) {\r\n        children = { default: children, _ctx: currentRenderingInstance };\r\n        type = 32 /* SLOTS_CHILDREN */;\r\n    }\r\n    else {\r\n        children = String(children);\r\n        // force teleport children to array so it can be moved around\r\n        if (shapeFlag & 64 /* TELEPORT */) {\r\n            type = 16 /* ARRAY_CHILDREN */;\r\n            children = [createTextVNode(children)];\r\n        }\r\n        else {\r\n            type = 8 /* TEXT_CHILDREN */;\r\n        }\r\n    }\r\n    vnode.children = children;\r\n    vnode.shapeFlag |= type;\r\n}\r\nfunction mergeProps(...args) {\r\n    const ret = extend({}, args[0]);\r\n    for (let i = 1; i < args.length; i++) {\r\n        const toMerge = args[i];\r\n        for (const key in toMerge) {\r\n            if (key === 'class') {\r\n                if (ret.class !== toMerge.class) {\r\n                    ret.class = normalizeClass([ret.class, toMerge.class]);\r\n                }\r\n            }\r\n            else if (key === 'style') {\r\n                ret.style = normalizeStyle([ret.style, toMerge.style]);\r\n            }\r\n            else if (isOn(key)) {\r\n                const existing = ret[key];\r\n                const incoming = toMerge[key];\r\n                if (existing !== incoming) {\r\n                    ret[key] = existing\r\n                        ? [].concat(existing, toMerge[key])\r\n                        : incoming;\r\n                }\r\n            }\r\n            else {\r\n                ret[key] = toMerge[key];\r\n            }\r\n        }\r\n    }\r\n    return ret;\r\n}\nfunction normalizePropsOptions(comp) {\r\n    if (comp.__props) {\r\n        return comp.__props;\r\n    }\r\n    const raw = comp.props;\r\n    const normalized = {};\r\n    const needCastKeys = [];\r\n    // apply mixin/extends props\r\n    let hasExtends = false;\r\n    if (__VUE_OPTIONS_API__ && !isFunction(comp)) {\r\n        const extendProps = (raw) => {\r\n            const [props, keys] = normalizePropsOptions(raw);\r\n            extend(normalized, props);\r\n            if (keys)\r\n                needCastKeys.push(...keys);\r\n        };\r\n        if (comp.extends) {\r\n            hasExtends = true;\r\n            extendProps(comp.extends);\r\n        }\r\n        if (comp.mixins) {\r\n            hasExtends = true;\r\n            comp.mixins.forEach(extendProps);\r\n        }\r\n    }\r\n    if (!raw && !hasExtends) {\r\n        return (comp.__props = EMPTY_ARR);\r\n    }\r\n    if (isArray(raw)) {\r\n        for (let i = 0; i < raw.length; i++) {\r\n            if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) {\r\n                warn(`props must be strings when using array syntax.`, raw[i]);\r\n            }\r\n            const normalizedKey = camelize(raw[i]);\r\n            if (validatePropName(normalizedKey)) {\r\n                normalized[normalizedKey] = EMPTY_OBJ;\r\n            }\r\n        }\r\n    }\r\n    else if (raw) {\r\n        if ((process.env.NODE_ENV !== 'production') && !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 (validatePropName(normalizedKey)) {\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) {\r\n                    const booleanIndex = getTypeIndex(Boolean, prop.type);\r\n                    const stringIndex = getTypeIndex(String, prop.type);\r\n                    prop[0 /* shouldCast */] = booleanIndex > -1;\r\n                    prop[1 /* shouldCastTrue */] =\r\n                        stringIndex < 0 || booleanIndex < stringIndex;\r\n                    // if the prop needs boolean casting or default value\r\n                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {\r\n                        needCastKeys.push(normalizedKey);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n    const normalizedEntry = [normalized, needCastKeys];\r\n    comp.__props = normalizedEntry;\r\n    return normalizedEntry;\r\n}\r\n// use function string name to check type constructors\r\n// so that it works across vms / iframes.\r\nfunction getType(ctor) {\r\n    const match = ctor && ctor.toString().match(/^\\s*function (\\w+)/);\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 < len; i++) {\r\n            if (isSameType(expectedTypes[i], type)) {\r\n                return i;\r\n            }\r\n        }\r\n    }\r\n    else if (isFunction(expectedTypes)) {\r\n        return isSameType(expectedTypes, type) ? 0 : -1;\r\n    }\r\n    return -1;\r\n}\r\n/**\r\n * dev only\r\n */\r\nfunction validatePropName(key) {\r\n    if (key[0] !== '$') {\r\n        return true;\r\n    }\r\n    else if ((process.env.NODE_ENV !== 'production')) {\r\n        warn(`Invalid prop name: \"${key}\" is a reserved property.`);\r\n    }\r\n    return false;\r\n}\r\nconst isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');\r\n\nfunction injectHook(type, hook, target = currentInstance, prepend = false) {\r\n    if (target) {\r\n        const hooks = target[type] || (target[type] = []);\r\n        // cache the error handling wrapper for injected hooks so the same hook\r\n        // can be properly deduped by the scheduler. \"__weh\" stands for \"with error\r\n        // handling\".\r\n        const wrappedHook = hook.__weh ||\r\n            (hook.__weh = (...args) => {\r\n                if (target.isUnmounted) {\r\n                    return;\r\n                }\r\n                // disable tracking inside all lifecycle hooks\r\n                // since they can potentially be called inside effects.\r\n                pauseTracking();\r\n                // Set currentInstance during hook invocation.\r\n                // This assumes the hook does not synchronously trigger other hooks, which\r\n                // 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                resetTracking();\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 if ((process.env.NODE_ENV !== 'production')) {\r\n        const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;\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) => (hook, target = currentInstance) => \r\n// post-create lifecycle registrations are noops during SSR\r\n!isInSSRComponentSetup && injectHook(lifecycle, hook, target);\r\nconst onMounted = createHook(\"m\" /* MOUNTED */);\r\nconst onUpdated = createHook(\"u\" /* UPDATED */);\r\nconst onBeforeUnmount = createHook(\"bum\" /* BEFORE_UNMOUNT */);\r\n\nfunction useTransitionState() {\r\n    const state = {\r\n        isMounted: false,\r\n        isLeaving: false,\r\n        isUnmounting: false,\r\n        leavingVNodes: new Map()\r\n    };\r\n    onMounted(() => {\r\n        state.isMounted = true;\r\n    });\r\n    onBeforeUnmount(() => {\r\n        state.isUnmounting = true;\r\n    });\r\n    return state;\r\n}\r\nconst TransitionHookValidator = [Function, Array];\r\nconst BaseTransitionImpl = {\r\n    name: `BaseTransition`,\r\n    props: {\r\n        mode: String,\r\n        appear: Boolean,\r\n        persisted: Boolean,\r\n        // enter\r\n        onBeforeEnter: TransitionHookValidator,\r\n        onEnter: TransitionHookValidator,\r\n        onAfterEnter: TransitionHookValidator,\r\n        onEnterCancelled: TransitionHookValidator,\r\n        // leave\r\n        onBeforeLeave: TransitionHookValidator,\r\n        onLeave: TransitionHookValidator,\r\n        onAfterLeave: TransitionHookValidator,\r\n        onLeaveCancelled: TransitionHookValidator,\r\n        // appear\r\n        onBeforeAppear: TransitionHookValidator,\r\n        onAppear: TransitionHookValidator,\r\n        onAfterAppear: TransitionHookValidator,\r\n        onAppearCancelled: TransitionHookValidator\r\n    },\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevTransitionKey;\r\n        return () => {\r\n            const children = slots.default && getTransitionRawChildren(slots.default(), true);\r\n            if (!children || !children.length) {\r\n                return;\r\n            }\r\n            // warn multiple elements\r\n            if ((process.env.NODE_ENV !== 'production') && children.length > 1) {\r\n                warn('<transition> can only be used on a single element or component. Use ' +\r\n                    '<transition-group> for lists.');\r\n            }\r\n            // there's no need to track reactivity for these props so use the raw\r\n            // props for a bit better perf\r\n            const rawProps = toRaw(props);\r\n            const { mode } = rawProps;\r\n            // check mode\r\n            if ((process.env.NODE_ENV !== 'production') && mode && !['in-out', 'out-in', 'default'].includes(mode)) {\r\n                warn(`invalid <transition> mode: ${mode}`);\r\n            }\r\n            // at this point children has a guaranteed length of 1.\r\n            const child = children[0];\r\n            if (state.isLeaving) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            // in the case of <transition><keep-alive/></transition>, we need to\r\n            // compare the type of the kept-alive children.\r\n            const innerChild = getKeepAliveChild(child);\r\n            if (!innerChild) {\r\n                return emptyPlaceholder(child);\r\n            }\r\n            const enterHooks = (innerChild.transition = resolveTransitionHooks(innerChild, rawProps, state, instance));\r\n            const oldChild = instance.subTree;\r\n            const oldInnerChild = oldChild && getKeepAliveChild(oldChild);\r\n            let transitionKeyChanged = false;\r\n            const { getTransitionKey } = innerChild.type;\r\n            if (getTransitionKey) {\r\n                const key = getTransitionKey();\r\n                if (prevTransitionKey === undefined) {\r\n                    prevTransitionKey = key;\r\n                }\r\n                else if (key !== prevTransitionKey) {\r\n                    prevTransitionKey = key;\r\n                    transitionKeyChanged = true;\r\n                }\r\n            }\r\n            // handle mode\r\n            if (oldInnerChild &&\r\n                oldInnerChild.type !== Comment &&\r\n                (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {\r\n                const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);\r\n                // update old tree's hooks in case of dynamic transition\r\n                setTransitionHooks(oldInnerChild, leavingHooks);\r\n                // switching between different views\r\n                if (mode === 'out-in') {\r\n                    state.isLeaving = true;\r\n                    // return placeholder node and queue update when leave finishes\r\n                    leavingHooks.afterLeave = () => {\r\n                        state.isLeaving = false;\r\n                        instance.update();\r\n                    };\r\n                    return emptyPlaceholder(child);\r\n                }\r\n                else if (mode === 'in-out') {\r\n                    leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {\r\n                        const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);\r\n                        leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;\r\n                        // early removal callback\r\n                        el._leaveCb = () => {\r\n                            earlyRemove();\r\n                            el._leaveCb = undefined;\r\n                            delete enterHooks.delayedLeave;\r\n                        };\r\n                        enterHooks.delayedLeave = delayedLeave;\r\n                    };\r\n                }\r\n            }\r\n            return child;\r\n        };\r\n    }\r\n};\r\n// export the public type for h/tsx inference\r\n// also to avoid inline import() in generated d.ts files\r\nconst BaseTransition = BaseTransitionImpl;\r\nfunction getLeavingNodesForType(state, vnode) {\r\n    const { leavingVNodes } = state;\r\n    let leavingVNodesCache = leavingVNodes.get(vnode.type);\r\n    if (!leavingVNodesCache) {\r\n        leavingVNodesCache = Object.create(null);\r\n        leavingVNodes.set(vnode.type, leavingVNodesCache);\r\n    }\r\n    return leavingVNodesCache;\r\n}\r\n// The transition hooks are attached to the vnode as vnode.transition\r\n// and will be called at appropriate timing in the renderer.\r\nfunction resolveTransitionHooks(vnode, { appear, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled }, state, instance) {\r\n    const key = String(vnode.key);\r\n    const leavingVNodesCache = getLeavingNodesForType(state, vnode);\r\n    const callHook = (hook, args) => {\r\n        hook &&\r\n            callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);\r\n    };\r\n    const hooks = {\r\n        persisted,\r\n        beforeEnter(el) {\r\n            let hook = onBeforeEnter;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onBeforeAppear || onBeforeEnter;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            // for same element (v-show)\r\n            if (el._leaveCb) {\r\n                el._leaveCb(true /* cancelled */);\r\n            }\r\n            // for toggled element with same key (v-if)\r\n            const leavingVNode = leavingVNodesCache[key];\r\n            if (leavingVNode &&\r\n                isSameVNodeType(vnode, leavingVNode) &&\r\n                leavingVNode.el._leaveCb) {\r\n                // force early removal (not cancelled)\r\n                leavingVNode.el._leaveCb();\r\n            }\r\n            callHook(hook, [el]);\r\n        },\r\n        enter(el) {\r\n            let hook = onEnter;\r\n            let afterHook = onAfterEnter;\r\n            let cancelHook = onEnterCancelled;\r\n            if (!state.isMounted) {\r\n                if (appear) {\r\n                    hook = onAppear || onEnter;\r\n                    afterHook = onAfterAppear || onAfterEnter;\r\n                    cancelHook = onAppearCancelled || onEnterCancelled;\r\n                }\r\n                else {\r\n                    return;\r\n                }\r\n            }\r\n            let called = false;\r\n            const done = (el._enterCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                if (cancelled) {\r\n                    callHook(cancelHook, [el]);\r\n                }\r\n                else {\r\n                    callHook(afterHook, [el]);\r\n                }\r\n                if (hooks.delayedLeave) {\r\n                    hooks.delayedLeave();\r\n                }\r\n                el._enterCb = undefined;\r\n            });\r\n            if (hook) {\r\n                hook(el, done);\r\n                if (hook.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        },\r\n        leave(el, remove$$1) {\r\n            const key = String(vnode.key);\r\n            if (el._enterCb) {\r\n                el._enterCb(true /* cancelled */);\r\n            }\r\n            if (state.isUnmounting) {\r\n                return remove$$1();\r\n            }\r\n            callHook(onBeforeLeave, [el]);\r\n            let called = false;\r\n            const done = (el._leaveCb = (cancelled) => {\r\n                if (called)\r\n                    return;\r\n                called = true;\r\n                remove$$1();\r\n                if (cancelled) {\r\n                    callHook(onLeaveCancelled, [el]);\r\n                }\r\n                else {\r\n                    callHook(onAfterLeave, [el]);\r\n                }\r\n                el._leaveCb = undefined;\r\n                if (leavingVNodesCache[key] === vnode) {\r\n                    delete leavingVNodesCache[key];\r\n                }\r\n            });\r\n            leavingVNodesCache[key] = vnode;\r\n            if (onLeave) {\r\n                onLeave(el, done);\r\n                if (onLeave.length <= 1) {\r\n                    done();\r\n                }\r\n            }\r\n            else {\r\n                done();\r\n            }\r\n        }\r\n    };\r\n    return hooks;\r\n}\r\n// the placeholder really only handles one special case: KeepAlive\r\n// in the case of a KeepAlive in a leave phase we need to return a KeepAlive\r\n// placeholder with empty content to avoid the KeepAlive instance from being\r\n// unmounted.\r\nfunction emptyPlaceholder(vnode) {\r\n    if (isKeepAlive(vnode)) {\r\n        vnode = cloneVNode(vnode);\r\n        vnode.children = null;\r\n        return vnode;\r\n    }\r\n}\r\nfunction getKeepAliveChild(vnode) {\r\n    return isKeepAlive(vnode)\r\n        ? vnode.children\r\n            ? vnode.children[0]\r\n            : undefined\r\n        : vnode;\r\n}\r\nfunction setTransitionHooks(vnode, hooks) {\r\n    if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {\r\n        setTransitionHooks(vnode.component.subTree, hooks);\r\n    }\r\n    else {\r\n        vnode.transition = hooks;\r\n    }\r\n}\r\nfunction getTransitionRawChildren(children, keepComment = false) {\r\n    let ret = [];\r\n    let keyedFragmentCount = 0;\r\n    for (let i = 0; i < children.length; i++) {\r\n        const child = children[i];\r\n        // handle fragment children case, e.g. v-for\r\n        if (child.type === Fragment) {\r\n            if (child.patchFlag & 128 /* KEYED_FRAGMENT */)\r\n                keyedFragmentCount++;\r\n            ret = ret.concat(getTransitionRawChildren(child.children, keepComment));\r\n        }\r\n        // comment placeholders should be skipped, e.g. v-if\r\n        else if (keepComment || child.type !== Comment) {\r\n            ret.push(child);\r\n        }\r\n    }\r\n    // #1126 if a transition children list contains multiple sub fragments, these\r\n    // fragments will be merged into a flat children array. Since each v-for\r\n    // fragment may contain different static bindings inside, we need to de-top\r\n    // these children to force full diffs to ensure correct behavior.\r\n    if (keyedFragmentCount > 1) {\r\n        for (let i = 0; i < ret.length; i++) {\r\n            ret[i].patchFlag = -2 /* BAIL */;\r\n        }\r\n    }\r\n    return ret;\r\n}\n\nconst isKeepAlive = (vnode) => vnode.type.__isKeepAlive;\r\n\n/**\r\nRuntime helper for applying directives to a vnode. Example usage:\r\n\nconst comp = resolveComponent('comp')\r\nconst foo = resolveDirective('foo')\r\nconst bar = resolveDirective('bar')\r\n\nreturn withDirectives(h(comp), [\r\n  [foo, this.x],\r\n  [bar, this.y]\r\n])\r\n*/\r\nconst isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');\r\nfunction setDevtoolsHook(hook) {\r\n}\r\nconst queuePostRenderEffect =  queueEffectWithSuspense\r\n    ;\r\n// initial value for watchers to trigger on undefined initial values\r\nconst INITIAL_WATCHER_VALUE = {};\r\nfunction doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {\r\n    if ((process.env.NODE_ENV !== 'production') && !cb) {\r\n        if (immediate !== undefined) {\r\n            warn(`watch() \"immediate\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n        if (deep !== undefined) {\r\n            warn(`watch() \"deep\" option is only respected when using the ` +\r\n                `watch(source, callback, options?) signature.`);\r\n        }\r\n    }\r\n    const warnInvalidSource = (s) => {\r\n        warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +\r\n            `a reactive object, or an array of these types.`);\r\n    };\r\n    let getter;\r\n    const isRefSource = isRef(source);\r\n    if (isRefSource) {\r\n        getter = () => source.value;\r\n    }\r\n    else if (isReactive(source)) {\r\n        getter = () => source;\r\n        deep = true;\r\n    }\r\n    else if (isArray(source)) {\r\n        getter = () => source.map(s => {\r\n            if (isRef(s)) {\r\n                return s.value;\r\n            }\r\n            else if (isReactive(s)) {\r\n                return traverse(s);\r\n            }\r\n            else if (isFunction(s)) {\r\n                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);\r\n            }\r\n            else {\r\n                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);\r\n            }\r\n        });\r\n    }\r\n    else if (isFunction(source)) {\r\n        if (cb) {\r\n            // getter with cb\r\n            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);\r\n        }\r\n        else {\r\n            // no cb -> simple effect\r\n            getter = () => {\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 /* WATCH_CALLBACK */, [onInvalidate]);\r\n            };\r\n        }\r\n    }\r\n    else {\r\n        getter = NOOP;\r\n        (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);\r\n    }\r\n    if (cb && deep) {\r\n        const baseGetter = getter;\r\n        getter = () => traverse(baseGetter());\r\n    }\r\n    let cleanup;\r\n    const onInvalidate = (fn) => {\r\n        cleanup = runner.options.onStop = () => {\r\n            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);\r\n        };\r\n    };\r\n    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;\r\n    const job = () => {\r\n        if (!runner.active) {\r\n            return;\r\n        }\r\n        if (cb) {\r\n            // watch(source, cb)\r\n            const newValue = runner();\r\n            if (deep || isRefSource || hasChanged(newValue, oldValue)) {\r\n                // cleanup before running cb again\r\n                if (cleanup) {\r\n                    cleanup();\r\n                }\r\n                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [\r\n                    newValue,\r\n                    // pass undefined as the old value when it's changed for the first time\r\n                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,\r\n                    onInvalidate\r\n                ]);\r\n                oldValue = newValue;\r\n            }\r\n        }\r\n        else {\r\n            // watchEffect\r\n            runner();\r\n        }\r\n    };\r\n    // important: mark the job as a watcher callback so that scheduler knows it\r\n    // it is allowed to self-trigger (#1727)\r\n    job.allowRecurse = !!cb;\r\n    let scheduler;\r\n    if (flush === 'sync') {\r\n        scheduler = job;\r\n    }\r\n    else if (flush === 'pre') {\r\n        // ensure it's queued before component updates (which have positive ids)\r\n        job.id = -1;\r\n        scheduler = () => {\r\n            if (!instance || instance.isMounted) {\r\n                queuePreFlushCb(job);\r\n            }\r\n            else {\r\n                // with 'pre' option, the first call must happen before\r\n                // the component is mounted so it is called synchronously.\r\n                job();\r\n            }\r\n        };\r\n    }\r\n    else {\r\n        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);\r\n    }\r\n    const runner = effect(getter, {\r\n        lazy: true,\r\n        onTrack,\r\n        onTrigger,\r\n        scheduler\r\n    });\r\n    recordInstanceBoundEffect(runner);\r\n    // initial run\r\n    if (cb) {\r\n        if (immediate) {\r\n            job();\r\n        }\r\n        else {\r\n            oldValue = runner();\r\n        }\r\n    }\r\n    else {\r\n        runner();\r\n    }\r\n    return () => {\r\n        stop(runner);\r\n        if (instance) {\r\n            remove(instance.effects, runner);\r\n        }\r\n    };\r\n}\r\n// this.$watch\r\nfunction instanceWatch(source, cb, options) {\r\n    const publicThis = this.proxy;\r\n    const getter = isString(source)\r\n        ? () => publicThis[source]\r\n        : source.bind(publicThis);\r\n    return doWatch(getter, cb.bind(publicThis), options, this);\r\n}\r\nfunction traverse(value, seen = new Set()) {\r\n    if (!isObject(value) || seen.has(value)) {\r\n        return value;\r\n    }\r\n    seen.add(value);\r\n    if (isArray(value)) {\r\n        for (let i = 0; i < 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) => {\r\n            // 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 => {\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}\nlet isInBeforeCreate = false;\r\nfunction resolveMergedOptions(instance) {\r\n    const raw = instance.type;\r\n    const { __merged, mixins, extends: extendsOptions } = raw;\r\n    if (__merged)\r\n        return __merged;\r\n    const globalMixins = instance.appContext.mixins;\r\n    if (!globalMixins.length && !mixins && !extendsOptions)\r\n        return raw;\r\n    const options = {};\r\n    globalMixins.forEach(m => mergeOptions(options, m, instance));\r\n    extendsOptions && mergeOptions(options, extendsOptions, instance);\r\n    mixins && mixins.forEach(m => mergeOptions(options, m, instance));\r\n    mergeOptions(options, raw, instance);\r\n    return (raw.__merged = options);\r\n}\r\nfunction mergeOptions(to, from, instance) {\r\n    const strats = instance.appContext.config.optionMergeStrategies;\r\n    for (const key in from) {\r\n        if (strats && hasOwn(strats, key)) {\r\n            to[key] = strats[key](to[key], from[key], instance.proxy, key);\r\n        }\r\n        else if (!hasOwn(to, key)) {\r\n            to[key] = from[key];\r\n        }\r\n    }\r\n}\n\nconst publicPropertiesMap = extend(Object.create(null), {\r\n    $: i => i,\r\n    $el: i => i.vnode.el,\r\n    $data: i => i.data,\r\n    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),\r\n    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),\r\n    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),\r\n    $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs),\r\n    $parent: i => i.parent && i.parent.proxy,\r\n    $root: i => i.root && i.root.proxy,\r\n    $emit: i => i.emit,\r\n    $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),\r\n    $forceUpdate: i => () => queueJob(i.update),\r\n    $nextTick: () => nextTick,\r\n    $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP)\r\n});\r\nconst PublicInstanceProxyHandlers = {\r\n    get({ _: instance }, key) {\r\n        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;\r\n        // let @vue/reactivity know it should never observe Vue public instances.\r\n        if (key === \"__v_skip\" /* SKIP */) {\r\n            return true;\r\n        }\r\n        // data / props / ctx\r\n        // This getter gets called for every property access on the render context\r\n        // during render and is a major hotspot. The most expensive part of this\r\n        // is the multiple hasOwn() calls. It's much faster to do a simple property\r\n        // access on a plain object, so we use an accessCache object (with null\r\n        // prototype) to memoize what access type a key corresponds to.\r\n        let normalizedProps;\r\n        if (key[0] !== '$') {\r\n            const n = accessCache[key];\r\n            if (n !== undefined) {\r\n                switch (n) {\r\n                    case 0 /* SETUP */:\r\n                        return setupState[key];\r\n                    case 1 /* DATA */:\r\n                        return data[key];\r\n                    case 3 /* CONTEXT */:\r\n                        return ctx[key];\r\n                    case 2 /* PROPS */:\r\n                        return props[key];\r\n                    // default: just fallthrough\r\n                }\r\n            }\r\n            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n                accessCache[key] = 0 /* SETUP */;\r\n                return setupState[key];\r\n            }\r\n            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n                accessCache[key] = 1 /* DATA */;\r\n                return data[key];\r\n            }\r\n            else if (\r\n            // only cache other properties when instance has declared (thus stable)\r\n            // props\r\n            (normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) {\r\n                accessCache[key] = 2 /* PROPS */;\r\n                return props[key];\r\n            }\r\n            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n                accessCache[key] = 3 /* CONTEXT */;\r\n                return ctx[key];\r\n            }\r\n            else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {\r\n                accessCache[key] = 4 /* OTHER */;\r\n            }\r\n        }\r\n        const publicGetter = publicPropertiesMap[key];\r\n        let cssModule, globalProperties;\r\n        // public $xxx properties\r\n        if (publicGetter) {\r\n            if (key === '$attrs') {\r\n                track(instance, \"get\" /* GET */, key);\r\n                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();\r\n            }\r\n            return publicGetter(instance);\r\n        }\r\n        else if (\r\n        // css module (injected by vue-loader)\r\n        (cssModule = type.__cssModules) &&\r\n            (cssModule = cssModule[key])) {\r\n            return cssModule;\r\n        }\r\n        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {\r\n            // user may set custom properties to `this` that start with `$`\r\n            accessCache[key] = 3 /* CONTEXT */;\r\n            return ctx[key];\r\n        }\r\n        else if (\r\n        // global properties\r\n        (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key))) {\r\n            return globalProperties[key];\r\n        }\r\n        else if ((process.env.NODE_ENV !== 'production') &&\r\n            currentRenderingInstance &&\r\n            (!isString(key) ||\r\n                // #1091 avoid internal isRef/isVNode checks on component instance leading\r\n                // to infinite warning loop\r\n                key.indexOf('__v') !== 0)) {\r\n            if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) {\r\n                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +\r\n                    `character and is not proxied on the render context.`);\r\n            }\r\n            else {\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    },\r\n    set({ _: instance }, key, value) {\r\n        const { data, setupState, ctx } = instance;\r\n        if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {\r\n            setupState[key] = value;\r\n        }\r\n        else if (data !== EMPTY_OBJ && hasOwn(data, key)) {\r\n            data[key] = value;\r\n        }\r\n        else if (key in instance.props) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate prop \"${key}\". Props are readonly.`, instance);\r\n            return false;\r\n        }\r\n        if (key[0] === '$' && key.slice(1) in instance) {\r\n            (process.env.NODE_ENV !== 'production') &&\r\n                warn(`Attempting to mutate public property \"${key}\". ` +\r\n                    `Properties starting with $ are reserved and readonly.`, instance);\r\n            return false;\r\n        }\r\n        else {\r\n            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {\r\n                Object.defineProperty(ctx, key, {\r\n                    enumerable: true,\r\n                    configurable: true,\r\n                    value\r\n                });\r\n            }\r\n            else {\r\n                ctx[key] = value;\r\n            }\r\n        }\r\n        return true;\r\n    },\r\n    has({ _: { data, setupState, accessCache, ctx, type, appContext } }, key) {\r\n        let normalizedProps;\r\n        return (accessCache[key] !== undefined ||\r\n            (data !== EMPTY_OBJ && hasOwn(data, key)) ||\r\n            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||\r\n            ((normalizedProps = normalizePropsOptions(type)[0]) &&\r\n                hasOwn(normalizedProps, key)) ||\r\n            hasOwn(ctx, key) ||\r\n            hasOwn(publicPropertiesMap, key) ||\r\n            hasOwn(appContext.config.globalProperties, key));\r\n    }\r\n};\r\nif ((process.env.NODE_ENV !== 'production') && !false) {\r\n    PublicInstanceProxyHandlers.ownKeys = (target) => {\r\n        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +\r\n            `The keys will be empty in production mode to avoid performance overhead.`);\r\n        return Reflect.ownKeys(target);\r\n    };\r\n}\r\nconst RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {\r\n    get(target, key) {\r\n        // fast path for unscopables when using `with` block\r\n        if (key === Symbol.unscopables) {\r\n            return;\r\n        }\r\n        return PublicInstanceProxyHandlers.get(target, key, target);\r\n    },\r\n    has(_, key) {\r\n        const has = key[0] !== '_' && !isGloballyWhitelisted(key);\r\n        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {\r\n            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);\r\n        }\r\n        return has;\r\n    }\r\n});\r\nlet currentInstance = null;\r\nconst getCurrentInstance = () => currentInstance || currentRenderingInstance;\r\nconst setCurrentInstance = (instance) => {\r\n    currentInstance = instance;\r\n};\r\nconst isBuiltInTag = /*#__PURE__*/ makeMap('slot,component');\r\nlet isInSSRComponentSetup = false;\r\n// record effects created during a component's setup() so that they can be\r\n// stopped when the component unmounts\r\nfunction recordInstanceBoundEffect(effect$$1) {\r\n    if (currentInstance) {\r\n        (currentInstance.effects || (currentInstance.effects = [])).push(effect$$1);\r\n    }\r\n}\r\nconst classifyRE = /(?:^|[-_])(\\w)/g;\r\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\r\n/* istanbul ignore next */\r\nfunction formatComponentName(instance, Component, isRoot = false) {\r\n    let name = isFunction(Component)\r\n        ? Component.displayName || Component.name\r\n        : Component.name;\r\n    if (!name && Component.__file) {\r\n        const match = Component.__file.match(/([^/\\\\]+)\\.vue$/);\r\n        if (match) {\r\n            name = match[1];\r\n        }\r\n    }\r\n    if (!name && instance && instance.parent) {\r\n        // try to infer the name based on reverse resolution\r\n        const inferFromRegistry = (registry) => {\r\n            for (const key in registry) {\r\n                if (registry[key] === Component) {\r\n                    return key;\r\n                }\r\n            }\r\n        };\r\n        name =\r\n            inferFromRegistry(instance.parent.type.components) || inferFromRegistry(instance.appContext.components);\r\n    }\r\n    return name ? classify(name) : isRoot ? `App` : `Anonymous`;\r\n}\n\n// implementation, close to no-op\r\nfunction defineComponent(options) {\r\n    return isFunction(options) ? { setup: options, name: options.name } : options;\r\n}\n\n// Actual implementation\r\nfunction h(type, propsOrChildren, children) {\r\n    if (arguments.length === 2) {\r\n        if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {\r\n            // single vnode without props\r\n            if (isVNode(propsOrChildren)) {\r\n                return createVNode(type, null, [propsOrChildren]);\r\n            }\r\n            // props without children\r\n            return createVNode(type, propsOrChildren);\r\n        }\r\n        else {\r\n            // 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}\n\nconst ssrContextKey = Symbol((process.env.NODE_ENV !== 'production') ? `ssrContext` : ``);\n\nconst svgNS = 'http://www.w3.org/2000/svg';\r\nconst doc = (typeof document !== 'undefined' ? document : null);\r\nlet tempContainer;\r\nlet tempSVGContainer;\r\nconst nodeOps = {\r\n    insert: (child, parent, anchor) => {\r\n        parent.insertBefore(child, anchor || null);\r\n    },\r\n    remove: child => {\r\n        const parent = child.parentNode;\r\n        if (parent) {\r\n            parent.removeChild(child);\r\n        }\r\n    },\r\n    createElement: (tag, isSVG, is) => isSVG\r\n        ? doc.createElementNS(svgNS, tag)\r\n        : doc.createElement(tag, is ? { is } : undefined),\r\n    createText: text$$1 => doc.createTextNode(text$$1),\r\n    createComment: text$$1 => doc.createComment(text$$1),\r\n    setText: (node, text$$1) => {\r\n        node.nodeValue = text$$1;\r\n    },\r\n    setElementText: (el, text$$1) => {\r\n        el.textContent = text$$1;\r\n    },\r\n    parentNode: node => node.parentNode,\r\n    nextSibling: node => node.nextSibling,\r\n    querySelector: selector => doc.querySelector(selector),\r\n    setScopeId(el, id) {\r\n        el.setAttribute(id, '');\r\n    },\r\n    cloneNode(el) {\r\n        return el.cloneNode(true);\r\n    },\r\n    // __UNSAFE__\r\n    // Reason: innerHTML.\r\n    // Static content here can only come from compiled templates.\r\n    // As long as the user only uses trusted templates, this is safe.\r\n    insertStaticContent(content, parent, anchor, isSVG) {\r\n        const temp = isSVG\r\n            ? tempSVGContainer ||\r\n                (tempSVGContainer = doc.createElementNS(svgNS, 'svg'))\r\n            : tempContainer || (tempContainer = doc.createElement('div'));\r\n        temp.innerHTML = content;\r\n        const first = temp.firstChild;\r\n        let node = first;\r\n        let last = node;\r\n        while (node) {\r\n            last = node;\r\n            nodeOps.insert(node, parent, anchor);\r\n            node = temp.firstChild;\r\n        }\r\n        return [first, last];\r\n    }\r\n};\n\n// compiler should normalize class + :class bindings on the same element\r\n// into a single binding ['staticClass', dynamic]\r\nfunction patchClass(el, value, isSVG) {\r\n    if (value == null) {\r\n        value = '';\r\n    }\r\n    if (isSVG) {\r\n        el.setAttribute('class', value);\r\n    }\r\n    else {\r\n        // directly setting className should be faster than setAttribute in theory\r\n        // if this is an element during a transition, take the temporary transition\r\n        // classes into account.\r\n        const transitionClasses = el._vtc;\r\n        if (transitionClasses) {\r\n            value = (value\r\n                ? [value, ...transitionClasses]\r\n                : [...transitionClasses]).join(' ');\r\n        }\r\n        el.className = value;\r\n    }\r\n}\n\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        if (prev !== next) {\r\n            style.cssText = next;\r\n        }\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] == null) {\r\n                    setStyle(style, key, '');\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nconst importantRE = /\\s*!important$/;\r\nfunction setStyle(style, name, val) {\r\n    if (isArray(val)) {\r\n        val.forEach(v => setStyle(style, name, v));\r\n    }\r\n    else {\r\n        if (name.startsWith('--')) {\r\n            // 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                // !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\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(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 < 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}\n\nconst xlinkNS = 'http://www.w3.org/1999/xlink';\r\nfunction patchAttr(el, key, value, isSVG) {\r\n    if (isSVG && key.startsWith('xlink:')) {\r\n        if (value == null) {\r\n            el.removeAttributeNS(xlinkNS, key.slice(6, key.length));\r\n        }\r\n        else {\r\n            el.setAttributeNS(xlinkNS, key, value);\r\n        }\r\n    }\r\n    else {\r\n        // note we are only checking boolean attributes that don't have a\r\n        // corresponding dom prop of the same name here.\r\n        const isBoolean = isSpecialBooleanAttr(key);\r\n        if (value == null || (isBoolean && value === false)) {\r\n            el.removeAttribute(key);\r\n        }\r\n        else {\r\n            el.setAttribute(key, isBoolean ? '' : value);\r\n        }\r\n    }\r\n}\n\n// __UNSAFE__\r\n// functions. The user is responsible for using them with only trusted content.\r\nfunction patchDOMProp(el, key, value, \r\n// the following args are passed only due to potential innerHTML/textContent\r\n// overriding existing VNodes, in which case the old tree must be properly\r\n// unmounted.\r\nprevChildren, parentComponent, parentSuspense, unmountChildren) {\r\n    if (key === 'innerHTML' || key === 'textContent') {\r\n        if (prevChildren) {\r\n            unmountChildren(prevChildren, parentComponent, parentSuspense);\r\n        }\r\n        el[key] = value == null ? '' : value;\r\n        return;\r\n    }\r\n    if (key === 'value' && el.tagName !== 'PROGRESS') {\r\n        // store value as _value as well since\r\n        // 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        // e.g. <select multiple> compiles to { multiple: '' }\r\n        el[key] = true;\r\n    }\r\n    else if (value == null && typeof el[key] === 'string') {\r\n        // e.g. <div :id=\"null\">\r\n        el[key] = '';\r\n        el.removeAttribute(key);\r\n    }\r\n    else {\r\n        // some properties perform value validation and throw\r\n        try {\r\n            el[key] = value;\r\n        }\r\n        catch (e) {\r\n            if ((process.env.NODE_ENV !== 'production')) {\r\n                warn(`Failed setting prop \"${key}\" on <${el.tagName.toLowerCase()}>: ` +\r\n                    `value ${value} is invalid.`, e);\r\n            }\r\n        }\r\n    }\r\n}\n\n// Async edge case fix requires storing an event listener's attach timestamp.\r\nlet _getNow = Date.now;\r\n// Determine what event timestamp the browser is using. Annoyingly, the\r\n// timestamp can either be hi-res (relative to page load) or low-res\r\n// (relative to UNIX epoch), so in order to compare time we have to use the\r\n// same timestamp type when saving the flush timestamp.\r\nif (typeof document !== 'undefined' &&\r\n    _getNow() > document.createEvent('Event').timeStamp) {\r\n    // if the low-res timestamp which is bigger than the event timestamp\r\n    // (which is evaluated AFTER) it means the event is using a hi-res timestamp,\r\n    // and we need to use the hi-res version for event listeners as well.\r\n    _getNow = () => performance.now();\r\n}\r\n// To avoid the overhead of repeatedly calling performance.now(), we cache\r\n// and use the same timestamp for all event listeners attached in the same tick.\r\nlet cachedNow = 0;\r\nconst p = Promise.resolve();\r\nconst reset = () => {\r\n    cachedNow = 0;\r\n};\r\nconst getNow = () => cachedNow || (p.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, rawName, prevValue, nextValue, instance = null) {\r\n    // vei = vue event invokers\r\n    const invokers = el._vei || (el._vei = {});\r\n    const existingInvoker = invokers[rawName];\r\n    if (nextValue && existingInvoker) {\r\n        // patch\r\n        existingInvoker.value = nextValue;\r\n    }\r\n    else {\r\n        const [name, options] = parseName(rawName);\r\n        if (nextValue) {\r\n            // add\r\n            const invoker = (invokers[rawName] = createInvoker(nextValue, instance));\r\n            addEventListener(el, name, invoker, options);\r\n        }\r\n        else if (existingInvoker) {\r\n            // remove\r\n            removeEventListener(el, name, existingInvoker, options);\r\n            invokers[rawName] = undefined;\r\n        }\r\n    }\r\n}\r\nconst optionsModifierRE = /(?:Once|Passive|Capture)$/;\r\nfunction parseName(name) {\r\n    let options;\r\n    if (optionsModifierRE.test(name)) {\r\n        options = {};\r\n        let m;\r\n        while ((m = name.match(optionsModifierRE))) {\r\n            name = name.slice(0, name.length - m[0].length);\r\n            options[m[0].toLowerCase()] = true;\r\n        }\r\n    }\r\n    return [name.slice(2).toLowerCase(), options];\r\n}\r\nfunction createInvoker(initialValue, instance) {\r\n    const invoker = (e) => {\r\n        // async edge case #6566: inner click event triggers patch, event handler\r\n        // attached to outer element during patch, and triggered again. This\r\n        // happens because browsers fire microtask ticks between event propagation.\r\n        // the solution is simple: we save the timestamp when a handler is attached,\r\n        // and the handler would only fire if the event passed to it was fired\r\n        // AFTER it was attached.\r\n        const timeStamp = e.timeStamp || _getNow();\r\n        if (timeStamp >= invoker.attached - 1) {\r\n            callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);\r\n        }\r\n    };\r\n    invoker.value = initialValue;\r\n    invoker.attached = getNow();\r\n    return invoker;\r\n}\r\nfunction patchStopImmediatePropagation(e, value) {\r\n    if (isArray(value)) {\r\n        const originalStop = e.stopImmediatePropagation;\r\n        e.stopImmediatePropagation = () => {\r\n            originalStop.call(e);\r\n            e._stopped = true;\r\n        };\r\n        return value.map(fn => (e) => !e._stopped && fn(e));\r\n    }\r\n    else {\r\n        return value;\r\n    }\r\n}\n\nconst nativeOnRE = /^on[a-z]/;\r\nconst forcePatchProp = (_, key) => key === 'value';\r\nconst patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {\r\n    switch (key) {\r\n        // 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        default:\r\n            if (isOn(key)) {\r\n                // ignore v-model listeners\r\n                if (!isModelListener(key)) {\r\n                    patchEvent(el, key, prevValue, nextValue, parentComponent);\r\n                }\r\n            }\r\n            else if (shouldSetAsProp(el, key, nextValue, isSVG)) {\r\n                patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);\r\n            }\r\n            else {\r\n                // special case for <input v-model type=\"checkbox\"> with\r\n                // :true-value & :false-value\r\n                // store value as dom properties since non-string values will be\r\n                // 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, isSVG);\r\n            }\r\n            break;\r\n    }\r\n};\r\nfunction shouldSetAsProp(el, key, value, isSVG) {\r\n    if (isSVG) {\r\n        // most keys must be set as attribute on svg elements to work\r\n        // ...except innerHTML\r\n        if (key === 'innerHTML') {\r\n            return true;\r\n        }\r\n        // or native onclick with function values\r\n        if (key in el && nativeOnRE.test(key) && isFunction(value)) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n    // spellcheck and draggable are numerated attrs, however their\r\n    // corresponding DOM properties are actually booleans - this leads to\r\n    // setting it with a string \"false\" value leading it to be coerced to\r\n    // `true`, so we need to always treat them as attributes.\r\n    // Note that `contentEditable` doesn't have this problem: its DOM\r\n    // property is also enumerated string values.\r\n    if (key === 'spellcheck' || key === 'draggable') {\r\n        return false;\r\n    }\r\n    // #1787 form as an attribute must be a string, while it accepts an Element as\r\n    // a prop\r\n    if (key === 'form' && typeof value === 'string') {\r\n        return false;\r\n    }\r\n    // #1526 <input list> must be set as attribute\r\n    if (key === 'list' && el.tagName === 'INPUT') {\r\n        return false;\r\n    }\r\n    // native onclick with string value, must be set as attribute\r\n    if (nativeOnRE.test(key) && isString(value)) {\r\n        return false;\r\n    }\r\n    return key in el;\r\n}\n\nconst TRANSITION = 'transition';\r\nconst ANIMATION = 'animation';\r\n// DOM Transition is a higher-order-component based on the platform-agnostic\r\n// base Transition component, with DOM-specific logic.\r\nconst Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);\r\nTransition.displayName = 'Transition';\r\nconst DOMTransitionPropsValidators = {\r\n    name: String,\r\n    type: String,\r\n    css: {\r\n        type: Boolean,\r\n        default: true\r\n    },\r\n    duration: [String, Number, Object],\r\n    enterFromClass: String,\r\n    enterActiveClass: String,\r\n    enterToClass: String,\r\n    appearFromClass: String,\r\n    appearActiveClass: String,\r\n    appearToClass: String,\r\n    leaveFromClass: String,\r\n    leaveActiveClass: String,\r\n    leaveToClass: String\r\n};\r\nconst TransitionPropsValidators = (Transition.props = /*#__PURE__*/ extend({}, BaseTransition.props, DOMTransitionPropsValidators));\r\nfunction resolveTransitionProps(rawProps) {\r\n    let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;\r\n    const baseProps = {};\r\n    for (const key in rawProps) {\r\n        if (!(key in DOMTransitionPropsValidators)) {\r\n            baseProps[key] = rawProps[key];\r\n        }\r\n    }\r\n    if (!css) {\r\n        return baseProps;\r\n    }\r\n    const durations = normalizeDuration(duration);\r\n    const enterDuration = durations && durations[0];\r\n    const leaveDuration = durations && durations[1];\r\n    const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;\r\n    const finishEnter = (el, isAppear, done) => {\r\n        removeTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n        removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);\r\n        done && done();\r\n    };\r\n    const finishLeave = (el, done) => {\r\n        removeTransitionClass(el, leaveToClass);\r\n        removeTransitionClass(el, leaveActiveClass);\r\n        done && done();\r\n    };\r\n    const makeEnterHook = (isAppear) => {\r\n        return (el, done) => {\r\n            const hook = isAppear ? onAppear : onEnter;\r\n            const resolve = () => finishEnter(el, isAppear, done);\r\n            hook && hook(el, resolve);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);\r\n                addTransitionClass(el, isAppear ? appearToClass : enterToClass);\r\n                if (!(hook && hook.length > 1)) {\r\n                    if (enterDuration) {\r\n                        setTimeout(resolve, enterDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n        };\r\n    };\r\n    return extend(baseProps, {\r\n        onBeforeEnter(el) {\r\n            onBeforeEnter && onBeforeEnter(el);\r\n            addTransitionClass(el, enterActiveClass);\r\n            addTransitionClass(el, enterFromClass);\r\n        },\r\n        onBeforeAppear(el) {\r\n            onBeforeAppear && onBeforeAppear(el);\r\n            addTransitionClass(el, appearActiveClass);\r\n            addTransitionClass(el, appearFromClass);\r\n        },\r\n        onEnter: makeEnterHook(false),\r\n        onAppear: makeEnterHook(true),\r\n        onLeave(el, done) {\r\n            const resolve = () => finishLeave(el, done);\r\n            addTransitionClass(el, leaveActiveClass);\r\n            addTransitionClass(el, leaveFromClass);\r\n            nextFrame(() => {\r\n                removeTransitionClass(el, leaveFromClass);\r\n                addTransitionClass(el, leaveToClass);\r\n                if (!(onLeave && onLeave.length > 1)) {\r\n                    if (leaveDuration) {\r\n                        setTimeout(resolve, leaveDuration);\r\n                    }\r\n                    else {\r\n                        whenTransitionEnds(el, type, resolve);\r\n                    }\r\n                }\r\n            });\r\n            onLeave && onLeave(el, resolve);\r\n        },\r\n        onEnterCancelled(el) {\r\n            finishEnter(el, false);\r\n            onEnterCancelled && onEnterCancelled(el);\r\n        },\r\n        onAppearCancelled(el) {\r\n            finishEnter(el, true);\r\n            onAppearCancelled && onAppearCancelled(el);\r\n        },\r\n        onLeaveCancelled(el) {\r\n            finishLeave(el);\r\n            onLeaveCancelled && onLeaveCancelled(el);\r\n        }\r\n    });\r\n}\r\nfunction normalizeDuration(duration) {\r\n    if (duration == null) {\r\n        return null;\r\n    }\r\n    else if (isObject(duration)) {\r\n        return [NumberOf(duration.enter), NumberOf(duration.leave)];\r\n    }\r\n    else {\r\n        const n = NumberOf(duration);\r\n        return [n, n];\r\n    }\r\n}\r\nfunction NumberOf(val) {\r\n    const res = toNumber(val);\r\n    if ((process.env.NODE_ENV !== 'production'))\r\n        validateDuration(res);\r\n    return res;\r\n}\r\nfunction validateDuration(val) {\r\n    if (typeof val !== 'number') {\r\n        warn(`<transition> explicit duration is not a valid number - ` +\r\n            `got ${JSON.stringify(val)}.`);\r\n    }\r\n    else if (isNaN(val)) {\r\n        warn(`<transition> explicit duration is NaN - ` +\r\n            'the duration expression might be incorrect.');\r\n    }\r\n}\r\nfunction addTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.add(c));\r\n    (el._vtc ||\r\n        (el._vtc = new Set())).add(cls);\r\n}\r\nfunction removeTransitionClass(el, cls) {\r\n    cls.split(/\\s+/).forEach(c => c && el.classList.remove(c));\r\n    const { _vtc } = el;\r\n    if (_vtc) {\r\n        _vtc.delete(cls);\r\n        if (!_vtc.size) {\r\n            el._vtc = undefined;\r\n        }\r\n    }\r\n}\r\nfunction nextFrame(cb) {\r\n    requestAnimationFrame(() => {\r\n        requestAnimationFrame(cb);\r\n    });\r\n}\r\nfunction whenTransitionEnds(el, expectedType, cb) {\r\n    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);\r\n    if (!type) {\r\n        return cb();\r\n    }\r\n    const endEvent = type + 'end';\r\n    let ended = 0;\r\n    const end = () => {\r\n        el.removeEventListener(endEvent, onEnd);\r\n        cb();\r\n    };\r\n    const onEnd = (e) => {\r\n        if (e.target === el) {\r\n            if (++ended >= propCount) {\r\n                end();\r\n            }\r\n        }\r\n    };\r\n    setTimeout(() => {\r\n        if (ended < propCount) {\r\n            end();\r\n        }\r\n    }, timeout + 1);\r\n    el.addEventListener(endEvent, onEnd);\r\n}\r\nfunction getTransitionInfo(el, expectedType) {\r\n    const styles = window.getComputedStyle(el);\r\n    // JSDOM may return undefined for transition properties\r\n    const getStyleProperties = (key) => (styles[key] || '').split(', ');\r\n    const transitionDelays = getStyleProperties(TRANSITION + 'Delay');\r\n    const transitionDurations = getStyleProperties(TRANSITION + 'Duration');\r\n    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);\r\n    const animationDelays = getStyleProperties(ANIMATION + 'Delay');\r\n    const animationDurations = getStyleProperties(ANIMATION + 'Duration');\r\n    const animationTimeout = getTimeout(animationDelays, animationDurations);\r\n    let type = null;\r\n    let timeout = 0;\r\n    let propCount = 0;\r\n    /* istanbul ignore if */\r\n    if (expectedType === TRANSITION) {\r\n        if (transitionTimeout > 0) {\r\n            type = TRANSITION;\r\n            timeout = transitionTimeout;\r\n            propCount = transitionDurations.length;\r\n        }\r\n    }\r\n    else if (expectedType === ANIMATION) {\r\n        if (animationTimeout > 0) {\r\n            type = ANIMATION;\r\n            timeout = animationTimeout;\r\n            propCount = animationDurations.length;\r\n        }\r\n    }\r\n    else {\r\n        timeout = Math.max(transitionTimeout, animationTimeout);\r\n        type =\r\n            timeout > 0\r\n                ? transitionTimeout > animationTimeout\r\n                    ? TRANSITION\r\n                    : ANIMATION\r\n                : null;\r\n        propCount = type\r\n            ? type === TRANSITION\r\n                ? transitionDurations.length\r\n                : animationDurations.length\r\n            : 0;\r\n    }\r\n    const hasTransform = type === TRANSITION &&\r\n        /\\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']);\r\n    return {\r\n        type,\r\n        timeout,\r\n        propCount,\r\n        hasTransform\r\n    };\r\n}\r\nfunction getTimeout(delays, durations) {\r\n    while (delays.length < durations.length) {\r\n        delays = delays.concat(delays);\r\n    }\r\n    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));\r\n}\r\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer\r\n// numbers in a locale-dependent way, using a comma instead of a dot.\r\n// If comma is not replaced with a dot, the input will be rounded down\r\n// (i.e. acting as a floor function) causing unexpected behaviors\r\nfunction toMs(s) {\r\n    return Number(s.slice(0, -1).replace(',', '.')) * 1000;\r\n}\n\nfunction toRaw$1(observed) {\r\n    return ((observed && toRaw$1(observed[\"__v_raw\" /* RAW */])) || observed);\r\n}\n\nconst positionMap = new WeakMap();\r\nconst newPositionMap = new WeakMap();\r\nconst TransitionGroupImpl = {\r\n    name: 'TransitionGroup',\r\n    props: /*#__PURE__*/ extend({}, TransitionPropsValidators, {\r\n        tag: String,\r\n        moveClass: String\r\n    }),\r\n    setup(props, { slots }) {\r\n        const instance = getCurrentInstance();\r\n        const state = useTransitionState();\r\n        let prevChildren;\r\n        let children;\r\n        onUpdated(() => {\r\n            // children is guaranteed to exist after initial render\r\n            if (!prevChildren.length) {\r\n                return;\r\n            }\r\n            const moveClass = props.moveClass || `${props.name || 'v'}-move`;\r\n            if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {\r\n                return;\r\n            }\r\n            // we divide the work into three loops to avoid mixing DOM reads and writes\r\n            // in each iteration - which helps prevent layout thrashing.\r\n            prevChildren.forEach(callPendingCbs);\r\n            prevChildren.forEach(recordPosition);\r\n            const movedChildren = prevChildren.filter(applyTranslation);\r\n            // force reflow to put everything in position\r\n            forceReflow();\r\n            movedChildren.forEach(c => {\r\n                const el = c.el;\r\n                const style = el.style;\r\n                addTransitionClass(el, moveClass);\r\n                style.transform = style.webkitTransform = style.transitionDuration = '';\r\n                const cb = (el._moveCb = (e) => {\r\n                    if (e && e.target !== el) {\r\n                        return;\r\n                    }\r\n                    if (!e || /transform$/.test(e.propertyName)) {\r\n                        el.removeEventListener('transitionend', cb);\r\n                        el._moveCb = null;\r\n                        removeTransitionClass(el, moveClass);\r\n                    }\r\n                });\r\n                el.addEventListener('transitionend', cb);\r\n            });\r\n        });\r\n        return () => {\r\n            const rawProps = toRaw$1(props);\r\n            const cssTransitionProps = resolveTransitionProps(rawProps);\r\n            const tag = rawProps.tag || Fragment;\r\n            prevChildren = children;\r\n            children = slots.default ? getTransitionRawChildren(slots.default()) : [];\r\n            for (let i = 0; i < children.length; i++) {\r\n                const child = children[i];\r\n                if (child.key != null) {\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                }\r\n                else if ((process.env.NODE_ENV !== 'production')) {\r\n                    warn(`<TransitionGroup> children must be keyed.`);\r\n                }\r\n            }\r\n            if (prevChildren) {\r\n                for (let i = 0; i < prevChildren.length; i++) {\r\n                    const child = prevChildren[i];\r\n                    setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));\r\n                    positionMap.set(child, child.el.getBoundingClientRect());\r\n                }\r\n            }\r\n            return createVNode(tag, null, children);\r\n        };\r\n    }\r\n};\r\nfunction callPendingCbs(c) {\r\n    const el = c.el;\r\n    if (el._moveCb) {\r\n        el._moveCb();\r\n    }\r\n    if (el._enterCb) {\r\n        el._enterCb();\r\n    }\r\n}\r\nfunction recordPosition(c) {\r\n    newPositionMap.set(c, c.el.getBoundingClientRect());\r\n}\r\nfunction applyTranslation(c) {\r\n    const oldPos = positionMap.get(c);\r\n    const newPos = newPositionMap.get(c);\r\n    const dx = oldPos.left - newPos.left;\r\n    const dy = oldPos.top - newPos.top;\r\n    if (dx || dy) {\r\n        const s = c.el.style;\r\n        s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;\r\n        s.transitionDuration = '0s';\r\n        return c;\r\n    }\r\n}\r\n// this is put in a dedicated function to avoid the line from being treeshaken\r\nfunction forceReflow() {\r\n    return document.body.offsetHeight;\r\n}\r\nfunction hasCSSTransform(el, root, moveClass) {\r\n    // Detect whether an element with the move class applied has\r\n    // CSS transitions. Since the element may be inside an entering\r\n    // transition at this very moment, we make a clone of it and remove\r\n    // all other transition classes applied to ensure only the move class\r\n    // is applied.\r\n    const clone = el.cloneNode();\r\n    if (el._vtc) {\r\n        el._vtc.forEach(cls => {\r\n            cls.split(/\\s+/).forEach(c => c && clone.classList.remove(c));\r\n        });\r\n    }\r\n    moveClass.split(/\\s+/).forEach(c => c && clone.classList.add(c));\r\n    clone.style.display = 'none';\r\n    const container = (root.nodeType === 1\r\n        ? root\r\n        : root.parentNode);\r\n    container.appendChild(clone);\r\n    const { hasTransform } = getTransitionInfo(clone);\r\n    container.removeChild(clone);\r\n    return hasTransform;\r\n}\n\nconst rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps);\n\nfunction initDev() {\r\n    const target = getGlobalThis();\r\n    target.__VUE__ = true;\r\n    setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);\r\n    {\r\n        console.info(`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}\n\n// This entry exports the runtime only, and is built as\r\n(process.env.NODE_ENV !== 'production') && initDev();\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar humps = createCommonjsModule(function (module) {\n(function(global) {\n\n  var _processKeys = function(convert, obj, options) {\n    if(!_isObject(obj) || _isDate(obj) || _isRegExp(obj) || _isBoolean(obj) || _isFunction(obj)) {\n      return obj;\n    }\n\n    var output,\n        i = 0,\n        l = 0;\n\n    if(_isArray(obj)) {\n      output = [];\n      for(l=obj.length; i<l; i++) {\n        output.push(_processKeys(convert, obj[i], options));\n      }\n    }\n    else {\n      output = {};\n      for(var key in obj) {\n        if(Object.prototype.hasOwnProperty.call(obj, key)) {\n          output[convert(key, options)] = _processKeys(convert, obj[key], options);\n        }\n      }\n    }\n    return output;\n  };\n\n  // String conversion methods\n\n  var separateWords = function(string, options) {\n    options = options || {};\n    var separator = options.separator || '_';\n    var split = options.split || /(?=[A-Z])/;\n\n    return string.split(split).join(separator);\n  };\n\n  var camelize = function(string) {\n    if (_isNumerical(string)) {\n      return string;\n    }\n    string = string.replace(/[\\-_\\s]+(.)?/g, function(match, chr) {\n      return chr ? chr.toUpperCase() : '';\n    });\n    // Ensure 1st char is always lowercase\n    return string.substr(0, 1).toLowerCase() + string.substr(1);\n  };\n\n  var pascalize = function(string) {\n    var camelized = camelize(string);\n    // Ensure 1st char is always uppercase\n    return camelized.substr(0, 1).toUpperCase() + camelized.substr(1);\n  };\n\n  var decamelize = function(string, options) {\n    return separateWords(string, options).toLowerCase();\n  };\n\n  // Utilities\n  // Taken from Underscore.js\n\n  var toString = Object.prototype.toString;\n\n  var _isFunction = function(obj) {\n    return typeof(obj) === 'function';\n  };\n  var _isObject = function(obj) {\n    return obj === Object(obj);\n  };\n  var _isArray = function(obj) {\n    return toString.call(obj) == '[object Array]';\n  };\n  var _isDate = function(obj) {\n    return toString.call(obj) == '[object Date]';\n  };\n  var _isRegExp = function(obj) {\n    return toString.call(obj) == '[object RegExp]';\n  };\n  var _isBoolean = function(obj) {\n    return toString.call(obj) == '[object Boolean]';\n  };\n\n  // Performant way to determine if obj coerces to a number\n  var _isNumerical = function(obj) {\n    obj = obj - 0;\n    return obj === obj;\n  };\n\n  // Sets up function which handles processing keys\n  // allowing the convert function to be modified by a callback\n  var _processor = function(convert, options) {\n    var callback = options && 'process' in options ? options.process : options;\n\n    if(typeof(callback) !== 'function') {\n      return convert;\n    }\n\n    return function(string, options) {\n      return callback(string, convert, options);\n    }\n  };\n\n  var humps = {\n    camelize: camelize,\n    decamelize: decamelize,\n    pascalize: pascalize,\n    depascalize: decamelize,\n    camelizeKeys: function(object, options) {\n      return _processKeys(_processor(camelize, options), object);\n    },\n    decamelizeKeys: function(object, options) {\n      return _processKeys(_processor(decamelize, options), object, options);\n    },\n    pascalizeKeys: function(object, options) {\n      return _processKeys(_processor(pascalize, options), object);\n    },\n    depascalizeKeys: function () {\n      return this.decamelizeKeys.apply(this, arguments);\n    }\n  };\n\n  if (typeof undefined === 'function' && undefined.amd) {\n    undefined(humps);\n  } else if ('object' !== 'undefined' && module.exports) {\n    module.exports = humps;\n  } else {\n    global.humps = humps;\n  }\n\n})(commonjsGlobal);\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar objectWithoutProperties = function (obj, keys) {\n  var target = {};\n\n  for (var i in obj) {\n    if (keys.indexOf(i) >= 0) continue;\n    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n    target[i] = obj[i];\n  }\n\n  return target;\n};\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\n/**\n * Converts a CSS style into a plain Javascript object.\n * @param {String} style The style to converts into a plain Javascript object.\n * @returns {Object}\n */\nfunction styleToObject(style) {\n  return style.split(';').map(function (s) {\n    return s.trim();\n  }).filter(function (s) {\n    return s;\n  }).reduce(function (output, pair) {\n    var idx = pair.indexOf(':');\n    var prop = humps.camelize(pair.slice(0, idx));\n    var value = pair.slice(idx + 1).trim();\n\n    output[prop] = value;\n    return output;\n  }, {});\n}\n\n/**\n * Converts a CSS class list into a plain Javascript object.\n * @param {Array<String>} classes The class list to convert.\n * @returns {Object}\n */\nfunction classToObject(classes) {\n  return classes.split(/\\s+/).reduce(function (output, className) {\n    output[className] = true;\n    return output;\n  }, {});\n}\n\n/**\n * Converts a FontAwesome abstract element of an icon into a Vue render function.\n * @param {AbstractElement | String} abstractElement The element to convert.\n * @param {Object} props The user-defined props.\n * @param {Object} attrs The user-defined native HTML attributes.\n * @returns {Function | String}\n */\nfunction convert$1(abstractElement) {\n  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var attrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  // If the abstract element is a string, we'll just return a string render function\n  if (typeof abstractElement === 'string') {\n    return abstractElement;\n  }\n\n  // Converting abstract element children into Vue render functions, then we'll execute\n  // them to retrieve VDOM elements\n  var children = (abstractElement.children || []).map(function (child) {\n    return convert$1(child);\n  }).map(function (renderFn) {\n    return typeof renderFn === 'string' ? renderFn : renderFn();\n  });\n\n  // Converting abstract element attributes into valid Vue format\n  var mixins = Object.keys(abstractElement.attributes || {}).reduce(function (mixins, key) {\n    var value = abstractElement.attributes[key];\n\n    switch (key) {\n      case 'class':\n        mixins.class = classToObject(value);\n        break;\n      case 'style':\n        mixins.style = styleToObject(value);\n        break;\n      default:\n        mixins.attrs[key] = value;\n    }\n\n    return mixins;\n  }, {\n    attrs: {},\n    class: {},\n    style: {}\n  });\n\n  // Now, we'll return the render function of the \n\n  var _attrs$class = attrs.class,\n      _attrs$style = attrs.style,\n      aStyle = _attrs$style === undefined ? {} : _attrs$style,\n      otherAttrs = objectWithoutProperties(attrs, ['class', 'style']);\n\n  return function () {\n    return h(abstractElement.tag, _extends({}, props, {\n      class: mixins.class,\n      style: _extends({}, mixins.style, aStyle)\n    }, mixins.attrs, otherAttrs), children);\n  };\n}\n\nvar PRODUCTION = false;\n\ntry {\n  PRODUCTION = process.env.NODE_ENV === 'production';\n} catch (e) {}\n\nfunction log () {\n  if (!PRODUCTION && console && typeof console.error === 'function') {\n    var _console;\n\n    (_console = console).error.apply(_console, arguments);\n  }\n}\n\nfunction objectWithKey(key, value) {\n  return Array.isArray(value) && value.length > 0 || !Array.isArray(value) && value ? defineProperty({}, key, value) : {};\n}\n\nfunction classList(props) {\n  var _classes;\n\n  var classes = (_classes = {\n    'fa-spin': props.spin,\n    'fa-pulse': props.pulse,\n    'fa-fw': props.fixedWidth,\n    'fa-border': props.border,\n    'fa-li': props.listItem,\n    'fa-inverse': props.inverse,\n    'fa-flip-horizontal': props.flip === 'horizontal' || props.flip === 'both',\n    'fa-flip-vertical': props.flip === 'vertical' || props.flip === 'both'\n  }, defineProperty(_classes, 'fa-' + props.size, props.size !== null), defineProperty(_classes, 'fa-rotate-' + props.rotation, props.rotation !== null), defineProperty(_classes, 'fa-pull-' + props.pull, props.pull !== null), defineProperty(_classes, 'fa-swap-opacity', props.swapOpacity), _classes);\n\n  return Object.keys(classes).map(function (key) {\n    return classes[key] ? key : null;\n  }).filter(function (key) {\n    return key;\n  });\n}\n\nfunction normalizeIconArgs(icon$$1) {\n  if (icon$$1 === null) {\n    return null;\n  }\n\n  if ((typeof icon$$1 === 'undefined' ? 'undefined' : _typeof(icon$$1)) === 'object' && icon$$1.prefix && icon$$1.iconName) {\n    return icon$$1;\n  }\n\n  if (Array.isArray(icon$$1) && icon$$1.length === 2) {\n    return { prefix: icon$$1[0], iconName: icon$$1[1] };\n  }\n\n  if (typeof icon$$1 === 'string') {\n    return { prefix: 'fas', iconName: icon$$1 };\n  }\n}\n\nvar FontAwesomeIcon = defineComponent({\n  name: 'FontAwesomeIcon',\n\n  props: {\n    border: {\n      type: Boolean,\n      default: false\n    },\n    fixedWidth: {\n      type: Boolean,\n      default: false\n    },\n    flip: {\n      type: String,\n      default: null,\n      validator: function validator(value) {\n        return ['horizontal', 'vertical', 'both'].indexOf(value) > -1;\n      }\n    },\n    icon: {\n      type: [Object, Array, String],\n      required: true\n    },\n    mask: {\n      type: [Object, Array, String],\n      default: null\n    },\n    listItem: {\n      type: Boolean,\n      default: false\n    },\n    pull: {\n      type: String,\n      default: null,\n      validator: function validator(value) {\n        return ['right', 'left'].indexOf(value) > -1;\n      }\n    },\n    pulse: {\n      type: Boolean,\n      default: false\n    },\n    rotation: {\n      type: [String, Number],\n      default: null,\n      validator: function validator(value) {\n        return [90, 180, 270].indexOf(Number.parseInt(value, 10)) > -1;\n      }\n    },\n    swapOpacity: {\n      type: Boolean,\n      default: false\n    },\n    size: {\n      type: String,\n      default: null,\n      validator: function validator(value) {\n        return ['lg', 'xs', 'sm', '1x', '2x', '3x', '4x', '5x', '6x', '7x', '8x', '9x', '10x'].indexOf(value) > -1;\n      }\n    },\n    spin: {\n      type: Boolean,\n      default: false\n    },\n    transform: {\n      type: [String, Object],\n      default: null\n    },\n    symbol: {\n      type: [Boolean, String],\n      default: false\n    },\n    title: {\n      type: String,\n      default: null\n    },\n    inverse: {\n      type: Boolean,\n      default: false\n    }\n  },\n\n  setup: function setup(props, _ref) {\n    var attrs = _ref.attrs;\n    var symbol = props.symbol,\n        title = props.title;\n\n    var icon$$1 = normalizeIconArgs(props.icon);\n    var classes = objectWithKey('classes', classList(props));\n    var transform = objectWithKey('transform', typeof props.transform === 'string' ? parse.transform(props.transform) : props.transform);\n    var mask = objectWithKey('mask', normalizeIconArgs(props.mask));\n\n    var renderedIcon = icon(icon$$1, _extends({}, classes, transform, mask, {\n      symbol: symbol,\n      title: title\n    }));\n\n    if (!renderedIcon) {\n      return log('Could not find one or more icon(s)', icon$$1, mask);\n    }\n\n    var abstractElement = renderedIcon.abstract[0];\n    return convert$1(abstractElement, {}, attrs);\n  }\n});\n\nvar FontAwesomeLayers = defineComponent({\n  name: 'FontAwesomeLayers',\n\n  props: {\n    fixedWidth: {\n      type: Boolean,\n      default: false\n    }\n  },\n\n  setup: function setup(props, _ref) {\n    var slots = _ref.slots;\n    var familyPrefix = config.familyPrefix;\n\n\n    var className = [familyPrefix + '-layers'].concat(toConsumableArray(props.fixedWidth ? [familyPrefix + '-fw'] : []));\n\n    return function () {\n      return h('div', { class: className }, slots.default ? slots.default() : []);\n    };\n  }\n});\n\nvar FontAwesomeLayersText = defineComponent({\n  name: 'FontAwesomeLayersText',\n\n  props: {\n    value: {\n      type: [String, Number],\n      default: ''\n    },\n    transform: {\n      type: [String, Object],\n      default: null\n    },\n    counter: {\n      type: Boolean,\n      default: false\n    },\n    position: {\n      type: String,\n      default: null,\n      validator: function validator(value) {\n        return ['bottom-left', 'bottom-right', 'top-left', 'top-right'].indexOf(value) > -1;\n      }\n    }\n  },\n\n  setup: function setup(props, _ref) {\n    var attrs = _ref.attrs;\n    var familyPrefix = config.familyPrefix;\n\n\n    var classes = objectWithKey('classes', [].concat(toConsumableArray(props.counter ? [familyPrefix + '-layers-counter'] : []), toConsumableArray(props.position ? [familyPrefix + '-layers-' + props.position] : [])));\n    var transform = objectWithKey('transform', typeof props.transform === 'string' ? parse.transform(props.transform) : props.transform);\n    var renderedText = text(props.value.toString(), _extends({}, transform, classes));\n\n    var abstract = renderedText.abstract;\n\n    if (props.counter) {\n      abstract[0].attributes.class = abstract[0].attributes.class.replace('fa-layers-text', '');\n    }\n\n    return convert$1(abstract[0], {}, attrs);\n  }\n});\n\nexport { FontAwesomeIcon, FontAwesomeLayers, FontAwesomeLayersText };\n","/*!\n * Font Awesome Free 5.15.1 by @fontawesome - https://fontawesome.com\n * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)\n */\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n    var ownKeys = Object.keys(source);\n\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n\n    ownKeys.forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    });\n  }\n\n  return target;\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  }\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nfunction _iterableToArray(iter) {\n  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n}\n\nvar noop = function noop() {};\n\nvar _WINDOW = {};\nvar _DOCUMENT = {};\nvar _MUTATION_OBSERVER = null;\nvar _PERFORMANCE = {\n  mark: noop,\n  measure: noop\n};\n\ntry {\n  if (typeof window !== 'undefined') _WINDOW = window;\n  if (typeof document !== 'undefined') _DOCUMENT = document;\n  if (typeof MutationObserver !== 'undefined') _MUTATION_OBSERVER = MutationObserver;\n  if (typeof performance !== 'undefined') _PERFORMANCE = performance;\n} catch (e) {}\n\nvar _ref = _WINDOW.navigator || {},\n    _ref$userAgent = _ref.userAgent,\n    userAgent = _ref$userAgent === void 0 ? '' : _ref$userAgent;\n\nvar WINDOW = _WINDOW;\nvar DOCUMENT = _DOCUMENT;\nvar MUTATION_OBSERVER = _MUTATION_OBSERVER;\nvar PERFORMANCE = _PERFORMANCE;\nvar IS_BROWSER = !!WINDOW.document;\nvar IS_DOM = !!DOCUMENT.documentElement && !!DOCUMENT.head && typeof DOCUMENT.addEventListener === 'function' && typeof DOCUMENT.createElement === 'function';\nvar IS_IE = ~userAgent.indexOf('MSIE') || ~userAgent.indexOf('Trident/');\n\nvar NAMESPACE_IDENTIFIER = '___FONT_AWESOME___';\nvar UNITS_IN_GRID = 16;\nvar DEFAULT_FAMILY_PREFIX = 'fa';\nvar DEFAULT_REPLACEMENT_CLASS = 'svg-inline--fa';\nvar DATA_FA_I2SVG = 'data-fa-i2svg';\nvar DATA_FA_PSEUDO_ELEMENT = 'data-fa-pseudo-element';\nvar DATA_FA_PSEUDO_ELEMENT_PENDING = 'data-fa-pseudo-element-pending';\nvar DATA_PREFIX = 'data-prefix';\nvar DATA_ICON = 'data-icon';\nvar HTML_CLASS_I2SVG_BASE_CLASS = 'fontawesome-i2svg';\nvar MUTATION_APPROACH_ASYNC = 'async';\nvar TAGNAMES_TO_SKIP_FOR_PSEUDOELEMENTS = ['HTML', 'HEAD', 'STYLE', 'SCRIPT'];\nvar PRODUCTION = function () {\n  try {\n    return process.env.NODE_ENV === 'production';\n  } catch (e) {\n    return false;\n  }\n}();\nvar PREFIX_TO_STYLE = {\n  'fas': 'solid',\n  'far': 'regular',\n  'fal': 'light',\n  'fad': 'duotone',\n  'fab': 'brands',\n  'fak': 'kit',\n  'fa': 'solid'\n};\nvar STYLE_TO_PREFIX = {\n  'solid': 'fas',\n  'regular': 'far',\n  'light': 'fal',\n  'duotone': 'fad',\n  'brands': 'fab',\n  'kit': 'fak'\n};\nvar LAYERS_TEXT_CLASSNAME = 'fa-layers-text';\nvar FONT_FAMILY_PATTERN = /Font Awesome ([5 ]*)(Solid|Regular|Light|Duotone|Brands|Free|Pro|Kit).*/; // TODO: do we need to handle font-weight for kit SVG pseudo-elements?\n\nvar FONT_WEIGHT_TO_PREFIX = {\n  '900': 'fas',\n  '400': 'far',\n  'normal': 'far',\n  '300': 'fal'\n};\nvar oneToTen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\nvar oneToTwenty = oneToTen.concat([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);\nvar ATTRIBUTES_WATCHED_FOR_MUTATION = ['class', 'data-prefix', 'data-icon', 'data-fa-transform', 'data-fa-mask'];\nvar DUOTONE_CLASSES = {\n  GROUP: 'group',\n  SWAP_OPACITY: 'swap-opacity',\n  PRIMARY: 'primary',\n  SECONDARY: 'secondary'\n};\nvar RESERVED_CLASSES = ['xs', 'sm', 'lg', 'fw', 'ul', 'li', 'border', 'pull-left', 'pull-right', 'spin', 'pulse', 'rotate-90', 'rotate-180', 'rotate-270', 'flip-horizontal', 'flip-vertical', 'flip-both', 'stack', 'stack-1x', 'stack-2x', 'inverse', 'layers', 'layers-text', 'layers-counter', DUOTONE_CLASSES.GROUP, DUOTONE_CLASSES.SWAP_OPACITY, DUOTONE_CLASSES.PRIMARY, DUOTONE_CLASSES.SECONDARY].concat(oneToTen.map(function (n) {\n  return \"\".concat(n, \"x\");\n})).concat(oneToTwenty.map(function (n) {\n  return \"w-\".concat(n);\n}));\n\nvar initial = WINDOW.FontAwesomeConfig || {};\n\nfunction getAttrConfig(attr) {\n  var element = DOCUMENT.querySelector('script[' + attr + ']');\n\n  if (element) {\n    return element.getAttribute(attr);\n  }\n}\n\nfunction coerce(val) {\n  // Getting an empty string will occur if the attribute is set on the HTML tag but without a value\n  // We'll assume that this is an indication that it should be toggled to true\n  // For example <script data-search-pseudo-elements src=\"...\"></script>\n  if (val === '') return true;\n  if (val === 'false') return false;\n  if (val === 'true') return true;\n  return val;\n}\n\nif (DOCUMENT && typeof DOCUMENT.querySelector === 'function') {\n  var attrs = [['data-family-prefix', 'familyPrefix'], ['data-replacement-class', 'replacementClass'], ['data-auto-replace-svg', 'autoReplaceSvg'], ['data-auto-add-css', 'autoAddCss'], ['data-auto-a11y', 'autoA11y'], ['data-search-pseudo-elements', 'searchPseudoElements'], ['data-observe-mutations', 'observeMutations'], ['data-mutate-approach', 'mutateApproach'], ['data-keep-original-source', 'keepOriginalSource'], ['data-measure-performance', 'measurePerformance'], ['data-show-missing-icons', 'showMissingIcons']];\n  attrs.forEach(function (_ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        attr = _ref2[0],\n        key = _ref2[1];\n\n    var val = coerce(getAttrConfig(attr));\n\n    if (val !== undefined && val !== null) {\n      initial[key] = val;\n    }\n  });\n}\n\nvar _default = {\n  familyPrefix: DEFAULT_FAMILY_PREFIX,\n  replacementClass: DEFAULT_REPLACEMENT_CLASS,\n  autoReplaceSvg: true,\n  autoAddCss: true,\n  autoA11y: true,\n  searchPseudoElements: false,\n  observeMutations: true,\n  mutateApproach: 'async',\n  keepOriginalSource: true,\n  measurePerformance: false,\n  showMissingIcons: true\n};\n\nvar _config = _objectSpread({}, _default, initial);\n\nif (!_config.autoReplaceSvg) _config.observeMutations = false;\n\nvar config = _objectSpread({}, _config);\n\nWINDOW.FontAwesomeConfig = config;\n\nvar w = WINDOW || {};\nif (!w[NAMESPACE_IDENTIFIER]) w[NAMESPACE_IDENTIFIER] = {};\nif (!w[NAMESPACE_IDENTIFIER].styles) w[NAMESPACE_IDENTIFIER].styles = {};\nif (!w[NAMESPACE_IDENTIFIER].hooks) w[NAMESPACE_IDENTIFIER].hooks = {};\nif (!w[NAMESPACE_IDENTIFIER].shims) w[NAMESPACE_IDENTIFIER].shims = [];\nvar namespace = w[NAMESPACE_IDENTIFIER];\n\nvar functions = [];\n\nvar listener = function listener() {\n  DOCUMENT.removeEventListener('DOMContentLoaded', listener);\n  loaded = 1;\n  functions.map(function (fn) {\n    return fn();\n  });\n};\n\nvar loaded = false;\n\nif (IS_DOM) {\n  loaded = (DOCUMENT.documentElement.doScroll ? /^loaded|^c/ : /^loaded|^i|^c/).test(DOCUMENT.readyState);\n  if (!loaded) DOCUMENT.addEventListener('DOMContentLoaded', listener);\n}\n\nfunction domready (fn) {\n  if (!IS_DOM) return;\n  loaded ? setTimeout(fn, 0) : functions.push(fn);\n}\n\nvar PENDING = 'pending';\nvar SETTLED = 'settled';\nvar FULFILLED = 'fulfilled';\nvar REJECTED = 'rejected';\n\nvar NOOP = function NOOP() {};\n\nvar isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';\nvar asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;\nvar asyncQueue = [];\nvar asyncTimer;\n\nfunction asyncFlush() {\n  // run promise callbacks\n  for (var i = 0; i < asyncQueue.length; i++) {\n    asyncQueue[i][0](asyncQueue[i][1]);\n  } // reset async asyncQueue\n\n\n  asyncQueue = [];\n  asyncTimer = false;\n}\n\nfunction asyncCall(callback, arg) {\n  asyncQueue.push([callback, arg]);\n\n  if (!asyncTimer) {\n    asyncTimer = true;\n    asyncSetTimer(asyncFlush, 0);\n  }\n}\n\nfunction invokeResolver(resolver, promise) {\n  function resolvePromise(value) {\n    resolve(promise, value);\n  }\n\n  function rejectPromise(reason) {\n    reject(promise, reason);\n  }\n\n  try {\n    resolver(resolvePromise, rejectPromise);\n  } catch (e) {\n    rejectPromise(e);\n  }\n}\n\nfunction invokeCallback(subscriber) {\n  var owner = subscriber.owner;\n  var settled = owner._state;\n  var value = owner._data;\n  var callback = subscriber[settled];\n  var promise = subscriber.then;\n\n  if (typeof callback === 'function') {\n    settled = FULFILLED;\n\n    try {\n      value = callback(value);\n    } catch (e) {\n      reject(promise, e);\n    }\n  }\n\n  if (!handleThenable(promise, value)) {\n    if (settled === FULFILLED) {\n      resolve(promise, value);\n    }\n\n    if (settled === REJECTED) {\n      reject(promise, value);\n    }\n  }\n}\n\nfunction handleThenable(promise, value) {\n  var resolved;\n\n  try {\n    if (promise === value) {\n      throw new TypeError('A promises callback cannot return that same promise.');\n    }\n\n    if (value && (typeof value === 'function' || _typeof(value) === 'object')) {\n      // then should be retrieved only once\n      var then = value.then;\n\n      if (typeof then === 'function') {\n        then.call(value, function (val) {\n          if (!resolved) {\n            resolved = true;\n\n            if (value === val) {\n              fulfill(promise, val);\n            } else {\n              resolve(promise, val);\n            }\n          }\n        }, function (reason) {\n          if (!resolved) {\n            resolved = true;\n            reject(promise, reason);\n          }\n        });\n        return true;\n      }\n    }\n  } catch (e) {\n    if (!resolved) {\n      reject(promise, e);\n    }\n\n    return true;\n  }\n\n  return false;\n}\n\nfunction resolve(promise, value) {\n  if (promise === value || !handleThenable(promise, value)) {\n    fulfill(promise, value);\n  }\n}\n\nfunction fulfill(promise, value) {\n  if (promise._state === PENDING) {\n    promise._state = SETTLED;\n    promise._data = value;\n    asyncCall(publishFulfillment, promise);\n  }\n}\n\nfunction reject(promise, reason) {\n  if (promise._state === PENDING) {\n    promise._state = SETTLED;\n    promise._data = reason;\n    asyncCall(publishRejection, promise);\n  }\n}\n\nfunction publish(promise) {\n  promise._then = promise._then.forEach(invokeCallback);\n}\n\nfunction publishFulfillment(promise) {\n  promise._state = FULFILLED;\n  publish(promise);\n}\n\nfunction publishRejection(promise) {\n  promise._state = REJECTED;\n  publish(promise);\n\n  if (!promise._handled && isNode) {\n    global.process.emit('unhandledRejection', promise._data, promise);\n  }\n}\n\nfunction notifyRejectionHandled(promise) {\n  global.process.emit('rejectionHandled', promise);\n}\n/**\n * @class\n */\n\n\nfunction P(resolver) {\n  if (typeof resolver !== 'function') {\n    throw new TypeError('Promise resolver ' + resolver + ' is not a function');\n  }\n\n  if (this instanceof P === false) {\n    throw new TypeError('Failed to construct \\'Promise\\': Please use the \\'new\\' operator, this object constructor cannot be called as a function.');\n  }\n\n  this._then = [];\n  invokeResolver(resolver, this);\n}\n\nP.prototype = {\n  constructor: P,\n  _state: PENDING,\n  _then: null,\n  _data: undefined,\n  _handled: false,\n  then: function then(onFulfillment, onRejection) {\n    var subscriber = {\n      owner: this,\n      then: new this.constructor(NOOP),\n      fulfilled: onFulfillment,\n      rejected: onRejection\n    };\n\n    if ((onRejection || onFulfillment) && !this._handled) {\n      this._handled = true;\n\n      if (this._state === REJECTED && isNode) {\n        asyncCall(notifyRejectionHandled, this);\n      }\n    }\n\n    if (this._state === FULFILLED || this._state === REJECTED) {\n      // already resolved, call callback async\n      asyncCall(invokeCallback, subscriber);\n    } else {\n      // subscribe\n      this._then.push(subscriber);\n    }\n\n    return subscriber.then;\n  },\n  catch: function _catch(onRejection) {\n    return this.then(null, onRejection);\n  }\n};\n\nP.all = function (promises) {\n  if (!Array.isArray(promises)) {\n    throw new TypeError('You must pass an array to Promise.all().');\n  }\n\n  return new P(function (resolve, reject) {\n    var results = [];\n    var remaining = 0;\n\n    function resolver(index) {\n      remaining++;\n      return function (value) {\n        results[index] = value;\n\n        if (! --remaining) {\n          resolve(results);\n        }\n      };\n    }\n\n    for (var i = 0, promise; i < promises.length; i++) {\n      promise = promises[i];\n\n      if (promise && typeof promise.then === 'function') {\n        promise.then(resolver(i), reject);\n      } else {\n        results[i] = promise;\n      }\n    }\n\n    if (!remaining) {\n      resolve(results);\n    }\n  });\n};\n\nP.race = function (promises) {\n  if (!Array.isArray(promises)) {\n    throw new TypeError('You must pass an array to Promise.race().');\n  }\n\n  return new P(function (resolve, reject) {\n    for (var i = 0, promise; i < promises.length; i++) {\n      promise = promises[i];\n\n      if (promise && typeof promise.then === 'function') {\n        promise.then(resolve, reject);\n      } else {\n        resolve(promise);\n      }\n    }\n  });\n};\n\nP.resolve = function (value) {\n  if (value && _typeof(value) === 'object' && value.constructor === P) {\n    return value;\n  }\n\n  return new P(function (resolve) {\n    resolve(value);\n  });\n};\n\nP.reject = function (reason) {\n  return new P(function (resolve, reject) {\n    reject(reason);\n  });\n};\n\nvar picked = typeof Promise === 'function' ? Promise : P;\n\nvar d = UNITS_IN_GRID;\nvar meaninglessTransform = {\n  size: 16,\n  x: 0,\n  y: 0,\n  rotate: 0,\n  flipX: false,\n  flipY: false\n};\n\nfunction isReserved(name) {\n  return ~RESERVED_CLASSES.indexOf(name);\n}\nfunction insertCss(css) {\n  if (!css || !IS_DOM) {\n    return;\n  }\n\n  var style = DOCUMENT.createElement('style');\n  style.setAttribute('type', 'text/css');\n  style.innerHTML = css;\n  var headChildren = DOCUMENT.head.childNodes;\n  var beforeChild = null;\n\n  for (var i = headChildren.length - 1; i > -1; i--) {\n    var child = headChildren[i];\n    var tagName = (child.tagName || '').toUpperCase();\n\n    if (['STYLE', 'LINK'].indexOf(tagName) > -1) {\n      beforeChild = child;\n    }\n  }\n\n  DOCUMENT.head.insertBefore(style, beforeChild);\n  return css;\n}\nvar idPool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\nfunction nextUniqueId() {\n  var size = 12;\n  var id = '';\n\n  while (size-- > 0) {\n    id += idPool[Math.random() * 62 | 0];\n  }\n\n  return id;\n}\nfunction toArray(obj) {\n  var array = [];\n\n  for (var i = (obj || []).length >>> 0; i--;) {\n    array[i] = obj[i];\n  }\n\n  return array;\n}\nfunction classArray(node) {\n  if (node.classList) {\n    return toArray(node.classList);\n  } else {\n    return (node.getAttribute('class') || '').split(' ').filter(function (i) {\n      return i;\n    });\n  }\n}\nfunction getIconName(familyPrefix, cls) {\n  var parts = cls.split('-');\n  var prefix = parts[0];\n  var iconName = parts.slice(1).join('-');\n\n  if (prefix === familyPrefix && iconName !== '' && !isReserved(iconName)) {\n    return iconName;\n  } else {\n    return null;\n  }\n}\nfunction htmlEscape(str) {\n  return \"\".concat(str).replace(/&/g, '&amp;').replace(/\"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n}\nfunction joinAttributes(attributes) {\n  return Object.keys(attributes || {}).reduce(function (acc, attributeName) {\n    return acc + \"\".concat(attributeName, \"=\\\"\").concat(htmlEscape(attributes[attributeName]), \"\\\" \");\n  }, '').trim();\n}\nfunction joinStyles(styles) {\n  return Object.keys(styles || {}).reduce(function (acc, styleName) {\n    return acc + \"\".concat(styleName, \": \").concat(styles[styleName], \";\");\n  }, '');\n}\nfunction transformIsMeaningful(transform) {\n  return transform.size !== meaninglessTransform.size || transform.x !== meaninglessTransform.x || transform.y !== meaninglessTransform.y || transform.rotate !== meaninglessTransform.rotate || transform.flipX || transform.flipY;\n}\nfunction transformForSvg(_ref) {\n  var transform = _ref.transform,\n      containerWidth = _ref.containerWidth,\n      iconWidth = _ref.iconWidth;\n  var outer = {\n    transform: \"translate(\".concat(containerWidth / 2, \" 256)\")\n  };\n  var innerTranslate = \"translate(\".concat(transform.x * 32, \", \").concat(transform.y * 32, \") \");\n  var innerScale = \"scale(\".concat(transform.size / 16 * (transform.flipX ? -1 : 1), \", \").concat(transform.size / 16 * (transform.flipY ? -1 : 1), \") \");\n  var innerRotate = \"rotate(\".concat(transform.rotate, \" 0 0)\");\n  var inner = {\n    transform: \"\".concat(innerTranslate, \" \").concat(innerScale, \" \").concat(innerRotate)\n  };\n  var path = {\n    transform: \"translate(\".concat(iconWidth / 2 * -1, \" -256)\")\n  };\n  return {\n    outer: outer,\n    inner: inner,\n    path: path\n  };\n}\nfunction transformForCss(_ref2) {\n  var transform = _ref2.transform,\n      _ref2$width = _ref2.width,\n      width = _ref2$width === void 0 ? UNITS_IN_GRID : _ref2$width,\n      _ref2$height = _ref2.height,\n      height = _ref2$height === void 0 ? UNITS_IN_GRID : _ref2$height,\n      _ref2$startCentered = _ref2.startCentered,\n      startCentered = _ref2$startCentered === void 0 ? false : _ref2$startCentered;\n  var val = '';\n\n  if (startCentered && IS_IE) {\n    val += \"translate(\".concat(transform.x / d - width / 2, \"em, \").concat(transform.y / d - height / 2, \"em) \");\n  } else if (startCentered) {\n    val += \"translate(calc(-50% + \".concat(transform.x / d, \"em), calc(-50% + \").concat(transform.y / d, \"em)) \");\n  } else {\n    val += \"translate(\".concat(transform.x / d, \"em, \").concat(transform.y / d, \"em) \");\n  }\n\n  val += \"scale(\".concat(transform.size / d * (transform.flipX ? -1 : 1), \", \").concat(transform.size / d * (transform.flipY ? -1 : 1), \") \");\n  val += \"rotate(\".concat(transform.rotate, \"deg) \");\n  return val;\n}\n\nvar ALL_SPACE = {\n  x: 0,\n  y: 0,\n  width: '100%',\n  height: '100%'\n};\n\nfunction fillBlack(abstract) {\n  var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n  if (abstract.attributes && (abstract.attributes.fill || force)) {\n    abstract.attributes.fill = 'black';\n  }\n\n  return abstract;\n}\n\nfunction deGroup(abstract) {\n  if (abstract.tag === 'g') {\n    return abstract.children;\n  } else {\n    return [abstract];\n  }\n}\n\nfunction makeIconMasking (_ref) {\n  var children = _ref.children,\n      attributes = _ref.attributes,\n      main = _ref.main,\n      mask = _ref.mask,\n      explicitMaskId = _ref.maskId,\n      transform = _ref.transform;\n  var mainWidth = main.width,\n      mainPath = main.icon;\n  var maskWidth = mask.width,\n      maskPath = mask.icon;\n  var trans = transformForSvg({\n    transform: transform,\n    containerWidth: maskWidth,\n    iconWidth: mainWidth\n  });\n  var maskRect = {\n    tag: 'rect',\n    attributes: _objectSpread({}, ALL_SPACE, {\n      fill: 'white'\n    })\n  };\n  var maskInnerGroupChildrenMixin = mainPath.children ? {\n    children: mainPath.children.map(fillBlack)\n  } : {};\n  var maskInnerGroup = {\n    tag: 'g',\n    attributes: _objectSpread({}, trans.inner),\n    children: [fillBlack(_objectSpread({\n      tag: mainPath.tag,\n      attributes: _objectSpread({}, mainPath.attributes, trans.path)\n    }, maskInnerGroupChildrenMixin))]\n  };\n  var maskOuterGroup = {\n    tag: 'g',\n    attributes: _objectSpread({}, trans.outer),\n    children: [maskInnerGroup]\n  };\n  var maskId = \"mask-\".concat(explicitMaskId || nextUniqueId());\n  var clipId = \"clip-\".concat(explicitMaskId || nextUniqueId());\n  var maskTag = {\n    tag: 'mask',\n    attributes: _objectSpread({}, ALL_SPACE, {\n      id: maskId,\n      maskUnits: 'userSpaceOnUse',\n      maskContentUnits: 'userSpaceOnUse'\n    }),\n    children: [maskRect, maskOuterGroup]\n  };\n  var defs = {\n    tag: 'defs',\n    children: [{\n      tag: 'clipPath',\n      attributes: {\n        id: clipId\n      },\n      children: deGroup(maskPath)\n    }, maskTag]\n  };\n  children.push(defs, {\n    tag: 'rect',\n    attributes: _objectSpread({\n      fill: 'currentColor',\n      'clip-path': \"url(#\".concat(clipId, \")\"),\n      mask: \"url(#\".concat(maskId, \")\")\n    }, ALL_SPACE)\n  });\n  return {\n    children: children,\n    attributes: attributes\n  };\n}\n\nfunction makeIconStandard (_ref) {\n  var children = _ref.children,\n      attributes = _ref.attributes,\n      main = _ref.main,\n      transform = _ref.transform,\n      styles = _ref.styles;\n  var styleString = joinStyles(styles);\n\n  if (styleString.length > 0) {\n    attributes['style'] = styleString;\n  }\n\n  if (transformIsMeaningful(transform)) {\n    var trans = transformForSvg({\n      transform: transform,\n      containerWidth: main.width,\n      iconWidth: main.width\n    });\n    children.push({\n      tag: 'g',\n      attributes: _objectSpread({}, trans.outer),\n      children: [{\n        tag: 'g',\n        attributes: _objectSpread({}, trans.inner),\n        children: [{\n          tag: main.icon.tag,\n          children: main.icon.children,\n          attributes: _objectSpread({}, main.icon.attributes, trans.path)\n        }]\n      }]\n    });\n  } else {\n    children.push(main.icon);\n  }\n\n  return {\n    children: children,\n    attributes: attributes\n  };\n}\n\nfunction asIcon (_ref) {\n  var children = _ref.children,\n      main = _ref.main,\n      mask = _ref.mask,\n      attributes = _ref.attributes,\n      styles = _ref.styles,\n      transform = _ref.transform;\n\n  if (transformIsMeaningful(transform) && main.found && !mask.found) {\n    var width = main.width,\n        height = main.height;\n    var offset = {\n      x: width / height / 2,\n      y: 0.5\n    };\n    attributes['style'] = joinStyles(_objectSpread({}, styles, {\n      'transform-origin': \"\".concat(offset.x + transform.x / 16, \"em \").concat(offset.y + transform.y / 16, \"em\")\n    }));\n  }\n\n  return [{\n    tag: 'svg',\n    attributes: attributes,\n    children: children\n  }];\n}\n\nfunction asSymbol (_ref) {\n  var prefix = _ref.prefix,\n      iconName = _ref.iconName,\n      children = _ref.children,\n      attributes = _ref.attributes,\n      symbol = _ref.symbol;\n  var id = symbol === true ? \"\".concat(prefix, \"-\").concat(config.familyPrefix, \"-\").concat(iconName) : symbol;\n  return [{\n    tag: 'svg',\n    attributes: {\n      style: 'display: none;'\n    },\n    children: [{\n      tag: 'symbol',\n      attributes: _objectSpread({}, attributes, {\n        id: id\n      }),\n      children: children\n    }]\n  }];\n}\n\nfunction makeInlineSvgAbstract(params) {\n  var _params$icons = params.icons,\n      main = _params$icons.main,\n      mask = _params$icons.mask,\n      prefix = params.prefix,\n      iconName = params.iconName,\n      transform = params.transform,\n      symbol = params.symbol,\n      title = params.title,\n      maskId = params.maskId,\n      titleId = params.titleId,\n      extra = params.extra,\n      _params$watchable = params.watchable,\n      watchable = _params$watchable === void 0 ? false : _params$watchable;\n\n  var _ref = mask.found ? mask : main,\n      width = _ref.width,\n      height = _ref.height;\n\n  var isUploadedIcon = prefix === 'fak';\n  var widthClass = isUploadedIcon ? '' : \"fa-w-\".concat(Math.ceil(width / height * 16));\n  var attrClass = [config.replacementClass, iconName ? \"\".concat(config.familyPrefix, \"-\").concat(iconName) : '', widthClass].filter(function (c) {\n    return extra.classes.indexOf(c) === -1;\n  }).filter(function (c) {\n    return c !== '' || !!c;\n  }).concat(extra.classes).join(' ');\n  var content = {\n    children: [],\n    attributes: _objectSpread({}, extra.attributes, {\n      'data-prefix': prefix,\n      'data-icon': iconName,\n      'class': attrClass,\n      'role': extra.attributes.role || 'img',\n      'xmlns': 'http://www.w3.org/2000/svg',\n      'viewBox': \"0 0 \".concat(width, \" \").concat(height)\n    })\n  };\n  var uploadedIconWidthStyle = isUploadedIcon && !~extra.classes.indexOf('fa-fw') ? {\n    width: \"\".concat(width / height * 16 * 0.0625, \"em\")\n  } : {};\n\n  if (watchable) {\n    content.attributes[DATA_FA_I2SVG] = '';\n  }\n\n  if (title) content.children.push({\n    tag: 'title',\n    attributes: {\n      id: content.attributes['aria-labelledby'] || \"title-\".concat(titleId || nextUniqueId())\n    },\n    children: [title]\n  });\n\n  var args = _objectSpread({}, content, {\n    prefix: prefix,\n    iconName: iconName,\n    main: main,\n    mask: mask,\n    maskId: maskId,\n    transform: transform,\n    symbol: symbol,\n    styles: _objectSpread({}, uploadedIconWidthStyle, extra.styles)\n  });\n\n  var _ref2 = mask.found && main.found ? makeIconMasking(args) : makeIconStandard(args),\n      children = _ref2.children,\n      attributes = _ref2.attributes;\n\n  args.children = children;\n  args.attributes = attributes;\n\n  if (symbol) {\n    return asSymbol(args);\n  } else {\n    return asIcon(args);\n  }\n}\nfunction makeLayersTextAbstract(params) {\n  var content = params.content,\n      width = params.width,\n      height = params.height,\n      transform = params.transform,\n      title = params.title,\n      extra = params.extra,\n      _params$watchable2 = params.watchable,\n      watchable = _params$watchable2 === void 0 ? false : _params$watchable2;\n\n  var attributes = _objectSpread({}, extra.attributes, title ? {\n    'title': title\n  } : {}, {\n    'class': extra.classes.join(' ')\n  });\n\n  if (watchable) {\n    attributes[DATA_FA_I2SVG] = '';\n  }\n\n  var styles = _objectSpread({}, extra.styles);\n\n  if (transformIsMeaningful(transform)) {\n    styles['transform'] = transformForCss({\n      transform: transform,\n      startCentered: true,\n      width: width,\n      height: height\n    });\n    styles['-webkit-transform'] = styles['transform'];\n  }\n\n  var styleString = joinStyles(styles);\n\n  if (styleString.length > 0) {\n    attributes['style'] = styleString;\n  }\n\n  var val = [];\n  val.push({\n    tag: 'span',\n    attributes: attributes,\n    children: [content]\n  });\n\n  if (title) {\n    val.push({\n      tag: 'span',\n      attributes: {\n        class: 'sr-only'\n      },\n      children: [title]\n    });\n  }\n\n  return val;\n}\nfunction makeLayersCounterAbstract(params) {\n  var content = params.content,\n      title = params.title,\n      extra = params.extra;\n\n  var attributes = _objectSpread({}, extra.attributes, title ? {\n    'title': title\n  } : {}, {\n    'class': extra.classes.join(' ')\n  });\n\n  var styleString = joinStyles(extra.styles);\n\n  if (styleString.length > 0) {\n    attributes['style'] = styleString;\n  }\n\n  var val = [];\n  val.push({\n    tag: 'span',\n    attributes: attributes,\n    children: [content]\n  });\n\n  if (title) {\n    val.push({\n      tag: 'span',\n      attributes: {\n        class: 'sr-only'\n      },\n      children: [title]\n    });\n  }\n\n  return val;\n}\n\nvar noop$1 = function noop() {};\n\nvar p = config.measurePerformance && PERFORMANCE && PERFORMANCE.mark && PERFORMANCE.measure ? PERFORMANCE : {\n  mark: noop$1,\n  measure: noop$1\n};\nvar preamble = \"FA \\\"5.15.1\\\"\";\n\nvar begin = function begin(name) {\n  p.mark(\"\".concat(preamble, \" \").concat(name, \" begins\"));\n  return function () {\n    return end(name);\n  };\n};\n\nvar end = function end(name) {\n  p.mark(\"\".concat(preamble, \" \").concat(name, \" ends\"));\n  p.measure(\"\".concat(preamble, \" \").concat(name), \"\".concat(preamble, \" \").concat(name, \" begins\"), \"\".concat(preamble, \" \").concat(name, \" ends\"));\n};\n\nvar perf = {\n  begin: begin,\n  end: end\n};\n\n/**\n * Internal helper to bind a function known to have 4 arguments\n * to a given context.\n */\n\nvar bindInternal4 = function bindInternal4(func, thisContext) {\n  return function (a, b, c, d) {\n    return func.call(thisContext, a, b, c, d);\n  };\n};\n\n/**\n * # Reduce\n *\n * A fast object `.reduce()` implementation.\n *\n * @param  {Object}   subject      The object to reduce over.\n * @param  {Function} fn           The reducer function.\n * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].\n * @param  {Object}   thisContext  The context for the reducer.\n * @return {mixed}                 The final result.\n */\n\n\nvar reduce = function fastReduceObject(subject, fn, initialValue, thisContext) {\n  var keys = Object.keys(subject),\n      length = keys.length,\n      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,\n      i,\n      key,\n      result;\n\n  if (initialValue === undefined) {\n    i = 1;\n    result = subject[keys[0]];\n  } else {\n    i = 0;\n    result = initialValue;\n  }\n\n  for (; i < length; i++) {\n    key = keys[i];\n    result = iterator(result, subject[key], key, subject);\n  }\n\n  return result;\n};\n\nfunction toHex(unicode) {\n  var result = '';\n\n  for (var i = 0; i < unicode.length; i++) {\n    var hex = unicode.charCodeAt(i).toString(16);\n    result += ('000' + hex).slice(-4);\n  }\n\n  return result;\n}\nfunction codePointAt(string, index) {\n  /*! https://mths.be/codepointat v0.2.0 by @mathias */\n  var size = string.length;\n  var first = string.charCodeAt(index);\n  var second;\n\n  if (first >= 0xD800 && first <= 0xDBFF && size > index + 1) {\n    second = string.charCodeAt(index + 1);\n\n    if (second >= 0xDC00 && second <= 0xDFFF) {\n      return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;\n    }\n  }\n\n  return first;\n}\n/**\n * Used to check that the character is between the E000..F8FF private unicode\n * range\n */\n\nfunction isPrivateUnicode(iconName) {\n  if (iconName.length !== 1) {\n    return false;\n  } else {\n    var cp = codePointAt(iconName, 0);\n    return cp >= 57344 && cp <= 63743;\n  }\n}\n\nfunction defineIcons(prefix, icons) {\n  var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var _params$skipHooks = params.skipHooks,\n      skipHooks = _params$skipHooks === void 0 ? false : _params$skipHooks;\n  var normalized = Object.keys(icons).reduce(function (acc, iconName) {\n    var icon = icons[iconName];\n    var expanded = !!icon.icon;\n\n    if (expanded) {\n      acc[icon.iconName] = icon.icon;\n    } else {\n      acc[iconName] = icon;\n    }\n\n    return acc;\n  }, {});\n\n  if (typeof namespace.hooks.addPack === 'function' && !skipHooks) {\n    namespace.hooks.addPack(prefix, normalized);\n  } else {\n    namespace.styles[prefix] = _objectSpread({}, namespace.styles[prefix] || {}, normalized);\n  }\n  /**\n   * Font Awesome 4 used the prefix of `fa` for all icons. With the introduction\n   * of new styles we needed to differentiate between them. Prefix `fa` is now an alias\n   * for `fas` so we'll easy the upgrade process for our users by automatically defining\n   * this as well.\n   */\n\n\n  if (prefix === 'fas') {\n    defineIcons('fa', icons);\n  }\n}\n\nvar styles = namespace.styles,\n    shims = namespace.shims;\nvar _byUnicode = {};\nvar _byLigature = {};\nvar _byOldName = {};\nvar build = function build() {\n  var lookup = function lookup(reducer) {\n    return reduce(styles, function (o, style, prefix) {\n      o[prefix] = reduce(style, reducer, {});\n      return o;\n    }, {});\n  };\n\n  _byUnicode = lookup(function (acc, icon, iconName) {\n    if (icon[3]) {\n      acc[icon[3]] = iconName;\n    }\n\n    return acc;\n  });\n  _byLigature = lookup(function (acc, icon, iconName) {\n    var ligatures = icon[2];\n    acc[iconName] = iconName;\n    ligatures.forEach(function (ligature) {\n      acc[ligature] = iconName;\n    });\n    return acc;\n  });\n  var hasRegular = 'far' in styles;\n  _byOldName = reduce(shims, function (acc, shim) {\n    var oldName = shim[0];\n    var prefix = shim[1];\n    var iconName = shim[2];\n\n    if (prefix === 'far' && !hasRegular) {\n      prefix = 'fas';\n    }\n\n    acc[oldName] = {\n      prefix: prefix,\n      iconName: iconName\n    };\n    return acc;\n  }, {});\n};\nbuild();\nfunction byUnicode(prefix, unicode) {\n  return (_byUnicode[prefix] || {})[unicode];\n}\nfunction byLigature(prefix, ligature) {\n  return (_byLigature[prefix] || {})[ligature];\n}\nfunction byOldName(name) {\n  return _byOldName[name] || {\n    prefix: null,\n    iconName: null\n  };\n}\n\nvar styles$1 = namespace.styles;\nvar emptyCanonicalIcon = function emptyCanonicalIcon() {\n  return {\n    prefix: null,\n    iconName: null,\n    rest: []\n  };\n};\nfunction getCanonicalIcon(values) {\n  return values.reduce(function (acc, cls) {\n    var iconName = getIconName(config.familyPrefix, cls);\n\n    if (styles$1[cls]) {\n      acc.prefix = cls;\n    } else if (config.autoFetchSvg && Object.keys(PREFIX_TO_STYLE).indexOf(cls) > -1) {\n      acc.prefix = cls;\n    } else if (iconName) {\n      var shim = acc.prefix === 'fa' ? byOldName(iconName) : {};\n      acc.iconName = shim.iconName || iconName;\n      acc.prefix = shim.prefix || acc.prefix;\n    } else if (cls !== config.replacementClass && cls.indexOf('fa-w-') !== 0) {\n      acc.rest.push(cls);\n    }\n\n    return acc;\n  }, emptyCanonicalIcon());\n}\nfunction iconFromMapping(mapping, prefix, iconName) {\n  if (mapping && mapping[prefix] && mapping[prefix][iconName]) {\n    return {\n      prefix: prefix,\n      iconName: iconName,\n      icon: mapping[prefix][iconName]\n    };\n  }\n}\n\nfunction toHtml(abstractNodes) {\n  var tag = abstractNodes.tag,\n      _abstractNodes$attrib = abstractNodes.attributes,\n      attributes = _abstractNodes$attrib === void 0 ? {} : _abstractNodes$attrib,\n      _abstractNodes$childr = abstractNodes.children,\n      children = _abstractNodes$childr === void 0 ? [] : _abstractNodes$childr;\n\n  if (typeof abstractNodes === 'string') {\n    return htmlEscape(abstractNodes);\n  } else {\n    return \"<\".concat(tag, \" \").concat(joinAttributes(attributes), \">\").concat(children.map(toHtml).join(''), \"</\").concat(tag, \">\");\n  }\n}\n\nvar noop$2 = function noop() {};\n\nfunction isWatched(node) {\n  var i2svg = node.getAttribute ? node.getAttribute(DATA_FA_I2SVG) : null;\n  return typeof i2svg === 'string';\n}\n\nfunction getMutator() {\n  if (config.autoReplaceSvg === true) {\n    return mutators.replace;\n  }\n\n  var mutator = mutators[config.autoReplaceSvg];\n  return mutator || mutators.replace;\n}\n\nvar mutators = {\n  replace: function replace(mutation) {\n    var node = mutation[0];\n    var abstract = mutation[1];\n    var newOuterHTML = abstract.map(function (a) {\n      return toHtml(a);\n    }).join('\\n');\n\n    if (node.parentNode && node.outerHTML) {\n      node.outerHTML = newOuterHTML + (config.keepOriginalSource && node.tagName.toLowerCase() !== 'svg' ? \"<!-- \".concat(node.outerHTML, \" Font Awesome fontawesome.com -->\") : '');\n    } else if (node.parentNode) {\n      var newNode = document.createElement('span');\n      node.parentNode.replaceChild(newNode, node);\n      newNode.outerHTML = newOuterHTML;\n    }\n  },\n  nest: function nest(mutation) {\n    var node = mutation[0];\n    var abstract = mutation[1]; // If we already have a replaced node we do not want to continue nesting within it.\n    // Short-circuit to the standard replacement\n\n    if (~classArray(node).indexOf(config.replacementClass)) {\n      return mutators.replace(mutation);\n    }\n\n    var forSvg = new RegExp(\"\".concat(config.familyPrefix, \"-.*\"));\n    delete abstract[0].attributes.style;\n    delete abstract[0].attributes.id;\n    var splitClasses = abstract[0].attributes.class.split(' ').reduce(function (acc, cls) {\n      if (cls === config.replacementClass || cls.match(forSvg)) {\n        acc.toSvg.push(cls);\n      } else {\n        acc.toNode.push(cls);\n      }\n\n      return acc;\n    }, {\n      toNode: [],\n      toSvg: []\n    });\n    abstract[0].attributes.class = splitClasses.toSvg.join(' ');\n    var newInnerHTML = abstract.map(function (a) {\n      return toHtml(a);\n    }).join('\\n');\n    node.setAttribute('class', splitClasses.toNode.join(' '));\n    node.setAttribute(DATA_FA_I2SVG, '');\n    node.innerHTML = newInnerHTML;\n  }\n};\n\nfunction performOperationSync(op) {\n  op();\n}\n\nfunction perform(mutations, callback) {\n  var callbackFunction = typeof callback === 'function' ? callback : noop$2;\n\n  if (mutations.length === 0) {\n    callbackFunction();\n  } else {\n    var frame = performOperationSync;\n\n    if (config.mutateApproach === MUTATION_APPROACH_ASYNC) {\n      frame = WINDOW.requestAnimationFrame || performOperationSync;\n    }\n\n    frame(function () {\n      var mutator = getMutator();\n      var mark = perf.begin('mutate');\n      mutations.map(mutator);\n      mark();\n      callbackFunction();\n    });\n  }\n}\nvar disabled = false;\nfunction disableObservation() {\n  disabled = true;\n}\nfunction enableObservation() {\n  disabled = false;\n}\nvar mo = null;\nfunction observe(options) {\n  if (!MUTATION_OBSERVER) {\n    return;\n  }\n\n  if (!config.observeMutations) {\n    return;\n  }\n\n  var treeCallback = options.treeCallback,\n      nodeCallback = options.nodeCallback,\n      pseudoElementsCallback = options.pseudoElementsCallback,\n      _options$observeMutat = options.observeMutationsRoot,\n      observeMutationsRoot = _options$observeMutat === void 0 ? DOCUMENT : _options$observeMutat;\n  mo = new MUTATION_OBSERVER(function (objects) {\n    if (disabled) return;\n    toArray(objects).forEach(function (mutationRecord) {\n      if (mutationRecord.type === 'childList' && mutationRecord.addedNodes.length > 0 && !isWatched(mutationRecord.addedNodes[0])) {\n        if (config.searchPseudoElements) {\n          pseudoElementsCallback(mutationRecord.target);\n        }\n\n        treeCallback(mutationRecord.target);\n      }\n\n      if (mutationRecord.type === 'attributes' && mutationRecord.target.parentNode && config.searchPseudoElements) {\n        pseudoElementsCallback(mutationRecord.target.parentNode);\n      }\n\n      if (mutationRecord.type === 'attributes' && isWatched(mutationRecord.target) && ~ATTRIBUTES_WATCHED_FOR_MUTATION.indexOf(mutationRecord.attributeName)) {\n        if (mutationRecord.attributeName === 'class') {\n          var _getCanonicalIcon = getCanonicalIcon(classArray(mutationRecord.target)),\n              prefix = _getCanonicalIcon.prefix,\n              iconName = _getCanonicalIcon.iconName;\n\n          if (prefix) mutationRecord.target.setAttribute('data-prefix', prefix);\n          if (iconName) mutationRecord.target.setAttribute('data-icon', iconName);\n        } else {\n          nodeCallback(mutationRecord.target);\n        }\n      }\n    });\n  });\n  if (!IS_DOM) return;\n  mo.observe(observeMutationsRoot, {\n    childList: true,\n    attributes: true,\n    characterData: true,\n    subtree: true\n  });\n}\nfunction disconnect() {\n  if (!mo) return;\n  mo.disconnect();\n}\n\nfunction styleParser (node) {\n  var style = node.getAttribute('style');\n  var val = [];\n\n  if (style) {\n    val = style.split(';').reduce(function (acc, style) {\n      var styles = style.split(':');\n      var prop = styles[0];\n      var value = styles.slice(1);\n\n      if (prop && value.length > 0) {\n        acc[prop] = value.join(':').trim();\n      }\n\n      return acc;\n    }, {});\n  }\n\n  return val;\n}\n\nfunction classParser (node) {\n  var existingPrefix = node.getAttribute('data-prefix');\n  var existingIconName = node.getAttribute('data-icon');\n  var innerText = node.innerText !== undefined ? node.innerText.trim() : '';\n  var val = getCanonicalIcon(classArray(node));\n\n  if (existingPrefix && existingIconName) {\n    val.prefix = existingPrefix;\n    val.iconName = existingIconName;\n  }\n\n  if (val.prefix && innerText.length > 1) {\n    val.iconName = byLigature(val.prefix, node.innerText);\n  } else if (val.prefix && innerText.length === 1) {\n    val.iconName = byUnicode(val.prefix, toHex(node.innerText));\n  }\n\n  return val;\n}\n\nvar parseTransformString = function parseTransformString(transformString) {\n  var transform = {\n    size: 16,\n    x: 0,\n    y: 0,\n    flipX: false,\n    flipY: false,\n    rotate: 0\n  };\n\n  if (!transformString) {\n    return transform;\n  } else {\n    return transformString.toLowerCase().split(' ').reduce(function (acc, n) {\n      var parts = n.toLowerCase().split('-');\n      var first = parts[0];\n      var rest = parts.slice(1).join('-');\n\n      if (first && rest === 'h') {\n        acc.flipX = true;\n        return acc;\n      }\n\n      if (first && rest === 'v') {\n        acc.flipY = true;\n        return acc;\n      }\n\n      rest = parseFloat(rest);\n\n      if (isNaN(rest)) {\n        return acc;\n      }\n\n      switch (first) {\n        case 'grow':\n          acc.size = acc.size + rest;\n          break;\n\n        case 'shrink':\n          acc.size = acc.size - rest;\n          break;\n\n        case 'left':\n          acc.x = acc.x - rest;\n          break;\n\n        case 'right':\n          acc.x = acc.x + rest;\n          break;\n\n        case 'up':\n          acc.y = acc.y - rest;\n          break;\n\n        case 'down':\n          acc.y = acc.y + rest;\n          break;\n\n        case 'rotate':\n          acc.rotate = acc.rotate + rest;\n          break;\n      }\n\n      return acc;\n    }, transform);\n  }\n};\nfunction transformParser (node) {\n  return parseTransformString(node.getAttribute('data-fa-transform'));\n}\n\nfunction symbolParser (node) {\n  var symbol = node.getAttribute('data-fa-symbol');\n  return symbol === null ? false : symbol === '' ? true : symbol;\n}\n\nfunction attributesParser (node) {\n  var extraAttributes = toArray(node.attributes).reduce(function (acc, attr) {\n    if (acc.name !== 'class' && acc.name !== 'style') {\n      acc[attr.name] = attr.value;\n    }\n\n    return acc;\n  }, {});\n  var title = node.getAttribute('title');\n  var titleId = node.getAttribute('data-fa-title-id');\n\n  if (config.autoA11y) {\n    if (title) {\n      extraAttributes['aria-labelledby'] = \"\".concat(config.replacementClass, \"-title-\").concat(titleId || nextUniqueId());\n    } else {\n      extraAttributes['aria-hidden'] = 'true';\n      extraAttributes['focusable'] = 'false';\n    }\n  }\n\n  return extraAttributes;\n}\n\nfunction maskParser (node) {\n  var mask = node.getAttribute('data-fa-mask');\n\n  if (!mask) {\n    return emptyCanonicalIcon();\n  } else {\n    return getCanonicalIcon(mask.split(' ').map(function (i) {\n      return i.trim();\n    }));\n  }\n}\n\nfunction blankMeta() {\n  return {\n    iconName: null,\n    title: null,\n    titleId: null,\n    prefix: null,\n    transform: meaninglessTransform,\n    symbol: false,\n    mask: null,\n    maskId: null,\n    extra: {\n      classes: [],\n      styles: {},\n      attributes: {}\n    }\n  };\n}\nfunction parseMeta(node) {\n  var _classParser = classParser(node),\n      iconName = _classParser.iconName,\n      prefix = _classParser.prefix,\n      extraClasses = _classParser.rest;\n\n  var extraStyles = styleParser(node);\n  var transform = transformParser(node);\n  var symbol = symbolParser(node);\n  var extraAttributes = attributesParser(node);\n  var mask = maskParser(node);\n  return {\n    iconName: iconName,\n    title: node.getAttribute('title'),\n    titleId: node.getAttribute('data-fa-title-id'),\n    prefix: prefix,\n    transform: transform,\n    symbol: symbol,\n    mask: mask,\n    maskId: node.getAttribute('data-fa-mask-id'),\n    extra: {\n      classes: extraClasses,\n      styles: extraStyles,\n      attributes: extraAttributes\n    }\n  };\n}\n\nfunction MissingIcon(error) {\n  this.name = 'MissingIcon';\n  this.message = error || 'Icon unavailable';\n  this.stack = new Error().stack;\n}\nMissingIcon.prototype = Object.create(Error.prototype);\nMissingIcon.prototype.constructor = MissingIcon;\n\nvar FILL = {\n  fill: 'currentColor'\n};\nvar ANIMATION_BASE = {\n  attributeType: 'XML',\n  repeatCount: 'indefinite',\n  dur: '2s'\n};\nvar RING = {\n  tag: 'path',\n  attributes: _objectSpread({}, FILL, {\n    d: 'M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z'\n  })\n};\n\nvar OPACITY_ANIMATE = _objectSpread({}, ANIMATION_BASE, {\n  attributeName: 'opacity'\n});\n\nvar DOT = {\n  tag: 'circle',\n  attributes: _objectSpread({}, FILL, {\n    cx: '256',\n    cy: '364',\n    r: '28'\n  }),\n  children: [{\n    tag: 'animate',\n    attributes: _objectSpread({}, ANIMATION_BASE, {\n      attributeName: 'r',\n      values: '28;14;28;28;14;28;'\n    })\n  }, {\n    tag: 'animate',\n    attributes: _objectSpread({}, OPACITY_ANIMATE, {\n      values: '1;0;1;1;0;1;'\n    })\n  }]\n};\nvar QUESTION = {\n  tag: 'path',\n  attributes: _objectSpread({}, FILL, {\n    opacity: '1',\n    d: 'M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z'\n  }),\n  children: [{\n    tag: 'animate',\n    attributes: _objectSpread({}, OPACITY_ANIMATE, {\n      values: '1;0;0;0;0;1;'\n    })\n  }]\n};\nvar EXCLAMATION = {\n  tag: 'path',\n  attributes: _objectSpread({}, FILL, {\n    opacity: '0',\n    d: 'M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z'\n  }),\n  children: [{\n    tag: 'animate',\n    attributes: _objectSpread({}, OPACITY_ANIMATE, {\n      values: '0;0;1;1;0;0;'\n    })\n  }]\n};\nvar missing = {\n  tag: 'g',\n  children: [RING, DOT, QUESTION, EXCLAMATION]\n};\n\nvar styles$2 = namespace.styles;\nfunction resolveCustomIconVersion() {\n  var kitConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var iconName = arguments.length > 1 ? arguments[1] : undefined;\n\n  if (iconName && isPrivateUnicode(iconName)) {\n    if (kitConfig && kitConfig.iconUploads) {\n      var iconUploads = kitConfig.iconUploads;\n      var descriptiveIconName = Object.keys(iconUploads).find(function (key) {\n        return iconUploads[key] && iconUploads[key].u && iconUploads[key].u === toHex(iconName);\n      });\n\n      if (descriptiveIconName) {\n        return iconUploads[descriptiveIconName].v;\n      }\n    }\n  } else {\n    if (kitConfig && kitConfig.iconUploads && kitConfig.iconUploads[iconName] && kitConfig.iconUploads[iconName].v) {\n      return kitConfig.iconUploads[iconName].v;\n    }\n  }\n}\nfunction asFoundIcon(icon) {\n  var width = icon[0];\n  var height = icon[1];\n\n  var _icon$slice = icon.slice(4),\n      _icon$slice2 = _slicedToArray(_icon$slice, 1),\n      vectorData = _icon$slice2[0];\n\n  var element = null;\n\n  if (Array.isArray(vectorData)) {\n    element = {\n      tag: 'g',\n      attributes: {\n        class: \"\".concat(config.familyPrefix, \"-\").concat(DUOTONE_CLASSES.GROUP)\n      },\n      children: [{\n        tag: 'path',\n        attributes: {\n          class: \"\".concat(config.familyPrefix, \"-\").concat(DUOTONE_CLASSES.SECONDARY),\n          fill: 'currentColor',\n          d: vectorData[0]\n        }\n      }, {\n        tag: 'path',\n        attributes: {\n          class: \"\".concat(config.familyPrefix, \"-\").concat(DUOTONE_CLASSES.PRIMARY),\n          fill: 'currentColor',\n          d: vectorData[1]\n        }\n      }]\n    };\n  } else {\n    element = {\n      tag: 'path',\n      attributes: {\n        fill: 'currentColor',\n        d: vectorData\n      }\n    };\n  }\n\n  return {\n    found: true,\n    width: width,\n    height: height,\n    icon: element\n  };\n}\nfunction findIcon(iconName, prefix) {\n  return new picked(function (resolve, reject) {\n    var val = {\n      found: false,\n      width: 512,\n      height: 512,\n      icon: missing\n    };\n\n    if (iconName && prefix && styles$2[prefix] && styles$2[prefix][iconName]) {\n      var icon = styles$2[prefix][iconName];\n      return resolve(asFoundIcon(icon));\n    }\n    var kitToken = null;\n    var iconVersion = resolveCustomIconVersion(WINDOW.FontAwesomeKitConfig, iconName);\n\n    if (WINDOW.FontAwesomeKitConfig && WINDOW.FontAwesomeKitConfig.token) {\n      kitToken = WINDOW.FontAwesomeKitConfig.token;\n    }\n\n    if (iconName && prefix && !config.showMissingIcons) {\n      reject(new MissingIcon(\"Icon is missing for prefix \".concat(prefix, \" with icon name \").concat(iconName)));\n    } else {\n      resolve(val);\n    }\n  });\n}\n\nvar styles$3 = namespace.styles;\n\nfunction generateSvgReplacementMutation(node, nodeMeta) {\n  var iconName = nodeMeta.iconName,\n      title = nodeMeta.title,\n      titleId = nodeMeta.titleId,\n      prefix = nodeMeta.prefix,\n      transform = nodeMeta.transform,\n      symbol = nodeMeta.symbol,\n      mask = nodeMeta.mask,\n      maskId = nodeMeta.maskId,\n      extra = nodeMeta.extra;\n  return new picked(function (resolve, reject) {\n    picked.all([findIcon(iconName, prefix), findIcon(mask.iconName, mask.prefix)]).then(function (_ref) {\n      var _ref2 = _slicedToArray(_ref, 2),\n          main = _ref2[0],\n          mask = _ref2[1];\n\n      resolve([node, makeInlineSvgAbstract({\n        icons: {\n          main: main,\n          mask: mask\n        },\n        prefix: prefix,\n        iconName: iconName,\n        transform: transform,\n        symbol: symbol,\n        mask: mask,\n        maskId: maskId,\n        title: title,\n        titleId: titleId,\n        extra: extra,\n        watchable: true\n      })]);\n    });\n  });\n}\n\nfunction generateLayersText(node, nodeMeta) {\n  var title = nodeMeta.title,\n      transform = nodeMeta.transform,\n      extra = nodeMeta.extra;\n  var width = null;\n  var height = null;\n\n  if (IS_IE) {\n    var computedFontSize = parseInt(getComputedStyle(node).fontSize, 10);\n    var boundingClientRect = node.getBoundingClientRect();\n    width = boundingClientRect.width / computedFontSize;\n    height = boundingClientRect.height / computedFontSize;\n  }\n\n  if (config.autoA11y && !title) {\n    extra.attributes['aria-hidden'] = 'true';\n  }\n\n  return picked.resolve([node, makeLayersTextAbstract({\n    content: node.innerHTML,\n    width: width,\n    height: height,\n    transform: transform,\n    title: title,\n    extra: extra,\n    watchable: true\n  })]);\n}\n\nfunction generateMutation(node) {\n  var nodeMeta = parseMeta(node);\n\n  if (~nodeMeta.extra.classes.indexOf(LAYERS_TEXT_CLASSNAME)) {\n    return generateLayersText(node, nodeMeta);\n  } else {\n    return generateSvgReplacementMutation(node, nodeMeta);\n  }\n}\n\nfunction onTree(root) {\n  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n  if (!IS_DOM) return;\n  var htmlClassList = DOCUMENT.documentElement.classList;\n\n  var hclAdd = function hclAdd(suffix) {\n    return htmlClassList.add(\"\".concat(HTML_CLASS_I2SVG_BASE_CLASS, \"-\").concat(suffix));\n  };\n\n  var hclRemove = function hclRemove(suffix) {\n    return htmlClassList.remove(\"\".concat(HTML_CLASS_I2SVG_BASE_CLASS, \"-\").concat(suffix));\n  };\n\n  var prefixes = config.autoFetchSvg ? Object.keys(PREFIX_TO_STYLE) : Object.keys(styles$3);\n  var prefixesDomQuery = [\".\".concat(LAYERS_TEXT_CLASSNAME, \":not([\").concat(DATA_FA_I2SVG, \"])\")].concat(prefixes.map(function (p) {\n    return \".\".concat(p, \":not([\").concat(DATA_FA_I2SVG, \"])\");\n  })).join(', ');\n\n  if (prefixesDomQuery.length === 0) {\n    return;\n  }\n\n  var candidates = [];\n\n  try {\n    candidates = toArray(root.querySelectorAll(prefixesDomQuery));\n  } catch (e) {// noop\n  }\n\n  if (candidates.length > 0) {\n    hclAdd('pending');\n    hclRemove('complete');\n  } else {\n    return;\n  }\n\n  var mark = perf.begin('onTree');\n  var mutations = candidates.reduce(function (acc, node) {\n    try {\n      var mutation = generateMutation(node);\n\n      if (mutation) {\n        acc.push(mutation);\n      }\n    } catch (e) {\n      if (!PRODUCTION) {\n        if (e instanceof MissingIcon) {\n          console.error(e);\n        }\n      }\n    }\n\n    return acc;\n  }, []);\n  return new picked(function (resolve, reject) {\n    picked.all(mutations).then(function (resolvedMutations) {\n      perform(resolvedMutations, function () {\n        hclAdd('active');\n        hclAdd('complete');\n        hclRemove('pending');\n        if (typeof callback === 'function') callback();\n        mark();\n        resolve();\n      });\n    }).catch(function () {\n      mark();\n      reject();\n    });\n  });\n}\nfunction onNode(node) {\n  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n  generateMutation(node).then(function (mutation) {\n    if (mutation) {\n      perform([mutation], callback);\n    }\n  });\n}\n\nfunction replaceForPosition(node, position) {\n  var pendingAttribute = \"\".concat(DATA_FA_PSEUDO_ELEMENT_PENDING).concat(position.replace(':', '-'));\n  return new picked(function (resolve, reject) {\n    if (node.getAttribute(pendingAttribute) !== null) {\n      // This node is already being processed\n      return resolve();\n    }\n\n    var children = toArray(node.children);\n    var alreadyProcessedPseudoElement = children.filter(function (c) {\n      return c.getAttribute(DATA_FA_PSEUDO_ELEMENT) === position;\n    })[0];\n    var styles = WINDOW.getComputedStyle(node, position);\n    var fontFamily = styles.getPropertyValue('font-family').match(FONT_FAMILY_PATTERN);\n    var fontWeight = styles.getPropertyValue('font-weight');\n    var content = styles.getPropertyValue('content');\n\n    if (alreadyProcessedPseudoElement && !fontFamily) {\n      // If we've already processed it but the current computed style does not result in a font-family,\n      // that probably means that a class name that was previously present to make the icon has been\n      // removed. So we now should delete the icon.\n      node.removeChild(alreadyProcessedPseudoElement);\n      return resolve();\n    } else if (fontFamily && content !== 'none' && content !== '') {\n      var _content = styles.getPropertyValue('content');\n\n      var prefix = ~['Solid', 'Regular', 'Light', 'Duotone', 'Brands', 'Kit'].indexOf(fontFamily[2]) ? STYLE_TO_PREFIX[fontFamily[2].toLowerCase()] : FONT_WEIGHT_TO_PREFIX[fontWeight];\n      var hexValue = toHex(_content.length === 3 ? _content.substr(1, 1) : _content);\n      var iconName = byUnicode(prefix, hexValue);\n      var iconIdentifier = iconName; // Only convert the pseudo element in this :before/:after position into an icon if we haven't\n      // already done so with the same prefix and iconName\n\n      if (iconName && (!alreadyProcessedPseudoElement || alreadyProcessedPseudoElement.getAttribute(DATA_PREFIX) !== prefix || alreadyProcessedPseudoElement.getAttribute(DATA_ICON) !== iconIdentifier)) {\n        node.setAttribute(pendingAttribute, iconIdentifier);\n\n        if (alreadyProcessedPseudoElement) {\n          // Delete the old one, since we're replacing it with a new one\n          node.removeChild(alreadyProcessedPseudoElement);\n        }\n\n        var meta = blankMeta();\n        var extra = meta.extra;\n        extra.attributes[DATA_FA_PSEUDO_ELEMENT] = position;\n        findIcon(iconName, prefix).then(function (main) {\n          var abstract = makeInlineSvgAbstract(_objectSpread({}, meta, {\n            icons: {\n              main: main,\n              mask: emptyCanonicalIcon()\n            },\n            prefix: prefix,\n            iconName: iconIdentifier,\n            extra: extra,\n            watchable: true\n          }));\n          var element = DOCUMENT.createElement('svg');\n\n          if (position === ':before') {\n            node.insertBefore(element, node.firstChild);\n          } else {\n            node.appendChild(element);\n          }\n\n          element.outerHTML = abstract.map(function (a) {\n            return toHtml(a);\n          }).join('\\n');\n          node.removeAttribute(pendingAttribute);\n          resolve();\n        }).catch(reject);\n      } else {\n        resolve();\n      }\n    } else {\n      resolve();\n    }\n  });\n}\n\nfunction replace(node) {\n  return picked.all([replaceForPosition(node, ':before'), replaceForPosition(node, ':after')]);\n}\n\nfunction processable(node) {\n  return node.parentNode !== document.head && !~TAGNAMES_TO_SKIP_FOR_PSEUDOELEMENTS.indexOf(node.tagName.toUpperCase()) && !node.getAttribute(DATA_FA_PSEUDO_ELEMENT) && (!node.parentNode || node.parentNode.tagName !== 'svg');\n}\n\nfunction searchPseudoElements (root) {\n  if (!IS_DOM) return;\n  return new picked(function (resolve, reject) {\n    var operations = toArray(root.querySelectorAll('*')).filter(processable).map(replace);\n    var end = perf.begin('searchPseudoElements');\n    disableObservation();\n    picked.all(operations).then(function () {\n      end();\n      enableObservation();\n      resolve();\n    }).catch(function () {\n      end();\n      enableObservation();\n      reject();\n    });\n  });\n}\n\nvar baseStyles = \"svg:not(:root).svg-inline--fa {\\n  overflow: visible;\\n}\\n\\n.svg-inline--fa {\\n  display: inline-block;\\n  font-size: inherit;\\n  height: 1em;\\n  overflow: visible;\\n  vertical-align: -0.125em;\\n}\\n.svg-inline--fa.fa-lg {\\n  vertical-align: -0.225em;\\n}\\n.svg-inline--fa.fa-w-1 {\\n  width: 0.0625em;\\n}\\n.svg-inline--fa.fa-w-2 {\\n  width: 0.125em;\\n}\\n.svg-inline--fa.fa-w-3 {\\n  width: 0.1875em;\\n}\\n.svg-inline--fa.fa-w-4 {\\n  width: 0.25em;\\n}\\n.svg-inline--fa.fa-w-5 {\\n  width: 0.3125em;\\n}\\n.svg-inline--fa.fa-w-6 {\\n  width: 0.375em;\\n}\\n.svg-inline--fa.fa-w-7 {\\n  width: 0.4375em;\\n}\\n.svg-inline--fa.fa-w-8 {\\n  width: 0.5em;\\n}\\n.svg-inline--fa.fa-w-9 {\\n  width: 0.5625em;\\n}\\n.svg-inline--fa.fa-w-10 {\\n  width: 0.625em;\\n}\\n.svg-inline--fa.fa-w-11 {\\n  width: 0.6875em;\\n}\\n.svg-inline--fa.fa-w-12 {\\n  width: 0.75em;\\n}\\n.svg-inline--fa.fa-w-13 {\\n  width: 0.8125em;\\n}\\n.svg-inline--fa.fa-w-14 {\\n  width: 0.875em;\\n}\\n.svg-inline--fa.fa-w-15 {\\n  width: 0.9375em;\\n}\\n.svg-inline--fa.fa-w-16 {\\n  width: 1em;\\n}\\n.svg-inline--fa.fa-w-17 {\\n  width: 1.0625em;\\n}\\n.svg-inline--fa.fa-w-18 {\\n  width: 1.125em;\\n}\\n.svg-inline--fa.fa-w-19 {\\n  width: 1.1875em;\\n}\\n.svg-inline--fa.fa-w-20 {\\n  width: 1.25em;\\n}\\n.svg-inline--fa.fa-pull-left {\\n  margin-right: 0.3em;\\n  width: auto;\\n}\\n.svg-inline--fa.fa-pull-right {\\n  margin-left: 0.3em;\\n  width: auto;\\n}\\n.svg-inline--fa.fa-border {\\n  height: 1.5em;\\n}\\n.svg-inline--fa.fa-li {\\n  width: 2em;\\n}\\n.svg-inline--fa.fa-fw {\\n  width: 1.25em;\\n}\\n\\n.fa-layers svg.svg-inline--fa {\\n  bottom: 0;\\n  left: 0;\\n  margin: auto;\\n  position: absolute;\\n  right: 0;\\n  top: 0;\\n}\\n\\n.fa-layers {\\n  display: inline-block;\\n  height: 1em;\\n  position: relative;\\n  text-align: center;\\n  vertical-align: -0.125em;\\n  width: 1em;\\n}\\n.fa-layers svg.svg-inline--fa {\\n  -webkit-transform-origin: center center;\\n          transform-origin: center center;\\n}\\n\\n.fa-layers-counter, .fa-layers-text {\\n  display: inline-block;\\n  position: absolute;\\n  text-align: center;\\n}\\n\\n.fa-layers-text {\\n  left: 50%;\\n  top: 50%;\\n  -webkit-transform: translate(-50%, -50%);\\n          transform: translate(-50%, -50%);\\n  -webkit-transform-origin: center center;\\n          transform-origin: center center;\\n}\\n\\n.fa-layers-counter {\\n  background-color: #ff253a;\\n  border-radius: 1em;\\n  -webkit-box-sizing: border-box;\\n          box-sizing: border-box;\\n  color: #fff;\\n  height: 1.5em;\\n  line-height: 1;\\n  max-width: 5em;\\n  min-width: 1.5em;\\n  overflow: hidden;\\n  padding: 0.25em;\\n  right: 0;\\n  text-overflow: ellipsis;\\n  top: 0;\\n  -webkit-transform: scale(0.25);\\n          transform: scale(0.25);\\n  -webkit-transform-origin: top right;\\n          transform-origin: top right;\\n}\\n\\n.fa-layers-bottom-right {\\n  bottom: 0;\\n  right: 0;\\n  top: auto;\\n  -webkit-transform: scale(0.25);\\n          transform: scale(0.25);\\n  -webkit-transform-origin: bottom right;\\n          transform-origin: bottom right;\\n}\\n\\n.fa-layers-bottom-left {\\n  bottom: 0;\\n  left: 0;\\n  right: auto;\\n  top: auto;\\n  -webkit-transform: scale(0.25);\\n          transform: scale(0.25);\\n  -webkit-transform-origin: bottom left;\\n          transform-origin: bottom left;\\n}\\n\\n.fa-layers-top-right {\\n  right: 0;\\n  top: 0;\\n  -webkit-transform: scale(0.25);\\n          transform: scale(0.25);\\n  -webkit-transform-origin: top right;\\n          transform-origin: top right;\\n}\\n\\n.fa-layers-top-left {\\n  left: 0;\\n  right: auto;\\n  top: 0;\\n  -webkit-transform: scale(0.25);\\n          transform: scale(0.25);\\n  -webkit-transform-origin: top left;\\n          transform-origin: top left;\\n}\\n\\n.fa-lg {\\n  font-size: 1.3333333333em;\\n  line-height: 0.75em;\\n  vertical-align: -0.0667em;\\n}\\n\\n.fa-xs {\\n  font-size: 0.75em;\\n}\\n\\n.fa-sm {\\n  font-size: 0.875em;\\n}\\n\\n.fa-1x {\\n  font-size: 1em;\\n}\\n\\n.fa-2x {\\n  font-size: 2em;\\n}\\n\\n.fa-3x {\\n  font-size: 3em;\\n}\\n\\n.fa-4x {\\n  font-size: 4em;\\n}\\n\\n.fa-5x {\\n  font-size: 5em;\\n}\\n\\n.fa-6x {\\n  font-size: 6em;\\n}\\n\\n.fa-7x {\\n  font-size: 7em;\\n}\\n\\n.fa-8x {\\n  font-size: 8em;\\n}\\n\\n.fa-9x {\\n  font-size: 9em;\\n}\\n\\n.fa-10x {\\n  font-size: 10em;\\n}\\n\\n.fa-fw {\\n  text-align: center;\\n  width: 1.25em;\\n}\\n\\n.fa-ul {\\n  list-style-type: none;\\n  margin-left: 2.5em;\\n  padding-left: 0;\\n}\\n.fa-ul > li {\\n  position: relative;\\n}\\n\\n.fa-li {\\n  left: -2em;\\n  position: absolute;\\n  text-align: center;\\n  width: 2em;\\n  line-height: inherit;\\n}\\n\\n.fa-border {\\n  border: solid 0.08em #eee;\\n  border-radius: 0.1em;\\n  padding: 0.2em 0.25em 0.15em;\\n}\\n\\n.fa-pull-left {\\n  float: left;\\n}\\n\\n.fa-pull-right {\\n  float: right;\\n}\\n\\n.fa.fa-pull-left,\\n.fas.fa-pull-left,\\n.far.fa-pull-left,\\n.fal.fa-pull-left,\\n.fab.fa-pull-left {\\n  margin-right: 0.3em;\\n}\\n.fa.fa-pull-right,\\n.fas.fa-pull-right,\\n.far.fa-pull-right,\\n.fal.fa-pull-right,\\n.fab.fa-pull-right {\\n  margin-left: 0.3em;\\n}\\n\\n.fa-spin {\\n  -webkit-animation: fa-spin 2s infinite linear;\\n          animation: fa-spin 2s infinite linear;\\n}\\n\\n.fa-pulse {\\n  -webkit-animation: fa-spin 1s infinite steps(8);\\n          animation: fa-spin 1s infinite steps(8);\\n}\\n\\n@-webkit-keyframes fa-spin {\\n  0% {\\n    -webkit-transform: rotate(0deg);\\n            transform: rotate(0deg);\\n  }\\n  100% {\\n    -webkit-transform: rotate(360deg);\\n            transform: rotate(360deg);\\n  }\\n}\\n\\n@keyframes fa-spin {\\n  0% {\\n    -webkit-transform: rotate(0deg);\\n            transform: rotate(0deg);\\n  }\\n  100% {\\n    -webkit-transform: rotate(360deg);\\n            transform: rotate(360deg);\\n  }\\n}\\n.fa-rotate-90 {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)\\\";\\n  -webkit-transform: rotate(90deg);\\n          transform: rotate(90deg);\\n}\\n\\n.fa-rotate-180 {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)\\\";\\n  -webkit-transform: rotate(180deg);\\n          transform: rotate(180deg);\\n}\\n\\n.fa-rotate-270 {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)\\\";\\n  -webkit-transform: rotate(270deg);\\n          transform: rotate(270deg);\\n}\\n\\n.fa-flip-horizontal {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)\\\";\\n  -webkit-transform: scale(-1, 1);\\n          transform: scale(-1, 1);\\n}\\n\\n.fa-flip-vertical {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)\\\";\\n  -webkit-transform: scale(1, -1);\\n          transform: scale(1, -1);\\n}\\n\\n.fa-flip-both, .fa-flip-horizontal.fa-flip-vertical {\\n  -ms-filter: \\\"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)\\\";\\n  -webkit-transform: scale(-1, -1);\\n          transform: scale(-1, -1);\\n}\\n\\n:root .fa-rotate-90,\\n:root .fa-rotate-180,\\n:root .fa-rotate-270,\\n:root .fa-flip-horizontal,\\n:root .fa-flip-vertical,\\n:root .fa-flip-both {\\n  -webkit-filter: none;\\n          filter: none;\\n}\\n\\n.fa-stack {\\n  display: inline-block;\\n  height: 2em;\\n  position: relative;\\n  width: 2.5em;\\n}\\n\\n.fa-stack-1x,\\n.fa-stack-2x {\\n  bottom: 0;\\n  left: 0;\\n  margin: auto;\\n  position: absolute;\\n  right: 0;\\n  top: 0;\\n}\\n\\n.svg-inline--fa.fa-stack-1x {\\n  height: 1em;\\n  width: 1.25em;\\n}\\n.svg-inline--fa.fa-stack-2x {\\n  height: 2em;\\n  width: 2.5em;\\n}\\n\\n.fa-inverse {\\n  color: #fff;\\n}\\n\\n.sr-only {\\n  border: 0;\\n  clip: rect(0, 0, 0, 0);\\n  height: 1px;\\n  margin: -1px;\\n  overflow: hidden;\\n  padding: 0;\\n  position: absolute;\\n  width: 1px;\\n}\\n\\n.sr-only-focusable:active, .sr-only-focusable:focus {\\n  clip: auto;\\n  height: auto;\\n  margin: 0;\\n  overflow: visible;\\n  position: static;\\n  width: auto;\\n}\\n\\n.svg-inline--fa .fa-primary {\\n  fill: var(--fa-primary-color, currentColor);\\n  opacity: 1;\\n  opacity: var(--fa-primary-opacity, 1);\\n}\\n\\n.svg-inline--fa .fa-secondary {\\n  fill: var(--fa-secondary-color, currentColor);\\n  opacity: 0.4;\\n  opacity: var(--fa-secondary-opacity, 0.4);\\n}\\n\\n.svg-inline--fa.fa-swap-opacity .fa-primary {\\n  opacity: 0.4;\\n  opacity: var(--fa-secondary-opacity, 0.4);\\n}\\n\\n.svg-inline--fa.fa-swap-opacity .fa-secondary {\\n  opacity: 1;\\n  opacity: var(--fa-primary-opacity, 1);\\n}\\n\\n.svg-inline--fa mask .fa-primary,\\n.svg-inline--fa mask .fa-secondary {\\n  fill: black;\\n}\\n\\n.fad.fa-inverse {\\n  color: #fff;\\n}\";\n\nfunction css () {\n  var dfp = DEFAULT_FAMILY_PREFIX;\n  var drc = DEFAULT_REPLACEMENT_CLASS;\n  var fp = config.familyPrefix;\n  var rc = config.replacementClass;\n  var s = baseStyles;\n\n  if (fp !== dfp || rc !== drc) {\n    var dPatt = new RegExp(\"\\\\.\".concat(dfp, \"\\\\-\"), 'g');\n    var customPropPatt = new RegExp(\"\\\\--\".concat(dfp, \"\\\\-\"), 'g');\n    var rPatt = new RegExp(\"\\\\.\".concat(drc), 'g');\n    s = s.replace(dPatt, \".\".concat(fp, \"-\")).replace(customPropPatt, \"--\".concat(fp, \"-\")).replace(rPatt, \".\".concat(rc));\n  }\n\n  return s;\n}\n\nvar Library =\n/*#__PURE__*/\nfunction () {\n  function Library() {\n    _classCallCheck(this, Library);\n\n    this.definitions = {};\n  }\n\n  _createClass(Library, [{\n    key: \"add\",\n    value: function add() {\n      var _this = this;\n\n      for (var _len = arguments.length, definitions = new Array(_len), _key = 0; _key < _len; _key++) {\n        definitions[_key] = arguments[_key];\n      }\n\n      var additions = definitions.reduce(this._pullDefinitions, {});\n      Object.keys(additions).forEach(function (key) {\n        _this.definitions[key] = _objectSpread({}, _this.definitions[key] || {}, additions[key]);\n        defineIcons(key, additions[key]);\n        build();\n      });\n    }\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      this.definitions = {};\n    }\n  }, {\n    key: \"_pullDefinitions\",\n    value: function _pullDefinitions(additions, definition) {\n      var normalized = definition.prefix && definition.iconName && definition.icon ? {\n        0: definition\n      } : definition;\n      Object.keys(normalized).map(function (key) {\n        var _normalized$key = normalized[key],\n            prefix = _normalized$key.prefix,\n            iconName = _normalized$key.iconName,\n            icon = _normalized$key.icon;\n        if (!additions[prefix]) additions[prefix] = {};\n        additions[prefix][iconName] = icon;\n      });\n      return additions;\n    }\n  }]);\n\n  return Library;\n}();\n\nfunction ensureCss() {\n  if (config.autoAddCss && !_cssInserted) {\n    insertCss(css());\n\n    _cssInserted = true;\n  }\n}\n\nfunction apiObject(val, abstractCreator) {\n  Object.defineProperty(val, 'abstract', {\n    get: abstractCreator\n  });\n  Object.defineProperty(val, 'html', {\n    get: function get() {\n      return val.abstract.map(function (a) {\n        return toHtml(a);\n      });\n    }\n  });\n  Object.defineProperty(val, 'node', {\n    get: function get() {\n      if (!IS_DOM) return;\n      var container = DOCUMENT.createElement('div');\n      container.innerHTML = val.html;\n      return container.children;\n    }\n  });\n  return val;\n}\n\nfunction findIconDefinition(iconLookup) {\n  var _iconLookup$prefix = iconLookup.prefix,\n      prefix = _iconLookup$prefix === void 0 ? 'fa' : _iconLookup$prefix,\n      iconName = iconLookup.iconName;\n  if (!iconName) return;\n  return iconFromMapping(library.definitions, prefix, iconName) || iconFromMapping(namespace.styles, prefix, iconName);\n}\n\nfunction resolveIcons(next) {\n  return function (maybeIconDefinition) {\n    var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var iconDefinition = (maybeIconDefinition || {}).icon ? maybeIconDefinition : findIconDefinition(maybeIconDefinition || {});\n    var mask = params.mask;\n\n    if (mask) {\n      mask = (mask || {}).icon ? mask : findIconDefinition(mask || {});\n    }\n\n    return next(iconDefinition, _objectSpread({}, params, {\n      mask: mask\n    }));\n  };\n}\n\nvar library = new Library();\nvar noAuto = function noAuto() {\n  config.autoReplaceSvg = false;\n  config.observeMutations = false;\n  disconnect();\n};\nvar _cssInserted = false;\nvar dom = {\n  i2svg: function i2svg() {\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    if (IS_DOM) {\n      ensureCss();\n      var _params$node = params.node,\n          node = _params$node === void 0 ? DOCUMENT : _params$node,\n          _params$callback = params.callback,\n          callback = _params$callback === void 0 ? function () {} : _params$callback;\n\n      if (config.searchPseudoElements) {\n        searchPseudoElements(node);\n      }\n\n      return onTree(node, callback);\n    } else {\n      return picked.reject('Operation requires a DOM of some kind.');\n    }\n  },\n  css: css,\n  insertCss: function insertCss$$1() {\n    if (!_cssInserted) {\n      insertCss(css());\n\n      _cssInserted = true;\n    }\n  },\n  watch: function watch() {\n    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var autoReplaceSvgRoot = params.autoReplaceSvgRoot,\n        observeMutationsRoot = params.observeMutationsRoot;\n\n    if (config.autoReplaceSvg === false) {\n      config.autoReplaceSvg = true;\n    }\n\n    config.observeMutations = true;\n    domready(function () {\n      autoReplace({\n        autoReplaceSvgRoot: autoReplaceSvgRoot\n      });\n      observe({\n        treeCallback: onTree,\n        nodeCallback: onNode,\n        pseudoElementsCallback: searchPseudoElements,\n        observeMutationsRoot: observeMutationsRoot\n      });\n    });\n  }\n};\nvar parse = {\n  transform: function transform(transformString) {\n    return parseTransformString(transformString);\n  }\n};\nvar icon = resolveIcons(function (iconDefinition) {\n  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _params$transform = params.transform,\n      transform = _params$transform === void 0 ? meaninglessTransform : _params$transform,\n      _params$symbol = params.symbol,\n      symbol = _params$symbol === void 0 ? false : _params$symbol,\n      _params$mask = params.mask,\n      mask = _params$mask === void 0 ? null : _params$mask,\n      _params$maskId = params.maskId,\n      maskId = _params$maskId === void 0 ? null : _params$maskId,\n      _params$title = params.title,\n      title = _params$title === void 0 ? null : _params$title,\n      _params$titleId = params.titleId,\n      titleId = _params$titleId === void 0 ? null : _params$titleId,\n      _params$classes = params.classes,\n      classes = _params$classes === void 0 ? [] : _params$classes,\n      _params$attributes = params.attributes,\n      attributes = _params$attributes === void 0 ? {} : _params$attributes,\n      _params$styles = params.styles,\n      styles = _params$styles === void 0 ? {} : _params$styles;\n  if (!iconDefinition) return;\n  var prefix = iconDefinition.prefix,\n      iconName = iconDefinition.iconName,\n      icon = iconDefinition.icon;\n  return apiObject(_objectSpread({\n    type: 'icon'\n  }, iconDefinition), function () {\n    ensureCss();\n\n    if (config.autoA11y) {\n      if (title) {\n        attributes['aria-labelledby'] = \"\".concat(config.replacementClass, \"-title-\").concat(titleId || nextUniqueId());\n      } else {\n        attributes['aria-hidden'] = 'true';\n        attributes['focusable'] = 'false';\n      }\n    }\n\n    return makeInlineSvgAbstract({\n      icons: {\n        main: asFoundIcon(icon),\n        mask: mask ? asFoundIcon(mask.icon) : {\n          found: false,\n          width: null,\n          height: null,\n          icon: {}\n        }\n      },\n      prefix: prefix,\n      iconName: iconName,\n      transform: _objectSpread({}, meaninglessTransform, transform),\n      symbol: symbol,\n      title: title,\n      maskId: maskId,\n      titleId: titleId,\n      extra: {\n        attributes: attributes,\n        styles: styles,\n        classes: classes\n      }\n    });\n  });\n});\nvar text = function text(content) {\n  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _params$transform2 = params.transform,\n      transform = _params$transform2 === void 0 ? meaninglessTransform : _params$transform2,\n      _params$title2 = params.title,\n      title = _params$title2 === void 0 ? null : _params$title2,\n      _params$classes2 = params.classes,\n      classes = _params$classes2 === void 0 ? [] : _params$classes2,\n      _params$attributes2 = params.attributes,\n      attributes = _params$attributes2 === void 0 ? {} : _params$attributes2,\n      _params$styles2 = params.styles,\n      styles = _params$styles2 === void 0 ? {} : _params$styles2;\n  return apiObject({\n    type: 'text',\n    content: content\n  }, function () {\n    ensureCss();\n    return makeLayersTextAbstract({\n      content: content,\n      transform: _objectSpread({}, meaninglessTransform, transform),\n      title: title,\n      extra: {\n        attributes: attributes,\n        styles: styles,\n        classes: [\"\".concat(config.familyPrefix, \"-layers-text\")].concat(_toConsumableArray(classes))\n      }\n    });\n  });\n};\nvar counter = function counter(content) {\n  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _params$title3 = params.title,\n      title = _params$title3 === void 0 ? null : _params$title3,\n      _params$classes3 = params.classes,\n      classes = _params$classes3 === void 0 ? [] : _params$classes3,\n      _params$attributes3 = params.attributes,\n      attributes = _params$attributes3 === void 0 ? {} : _params$attributes3,\n      _params$styles3 = params.styles,\n      styles = _params$styles3 === void 0 ? {} : _params$styles3;\n  return apiObject({\n    type: 'counter',\n    content: content\n  }, function () {\n    ensureCss();\n    return makeLayersCounterAbstract({\n      content: content.toString(),\n      title: title,\n      extra: {\n        attributes: attributes,\n        styles: styles,\n        classes: [\"\".concat(config.familyPrefix, \"-layers-counter\")].concat(_toConsumableArray(classes))\n      }\n    });\n  });\n};\nvar layer = function layer(assembler) {\n  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _params$classes4 = params.classes,\n      classes = _params$classes4 === void 0 ? [] : _params$classes4;\n  return apiObject({\n    type: 'layer'\n  }, function () {\n    ensureCss();\n    var children = [];\n    assembler(function (args) {\n      Array.isArray(args) ? args.map(function (a) {\n        children = children.concat(a.abstract);\n      }) : children = children.concat(args.abstract);\n    });\n    return [{\n      tag: 'span',\n      attributes: {\n        class: [\"\".concat(config.familyPrefix, \"-layers\")].concat(_toConsumableArray(classes)).join(' ')\n      },\n      children: children\n    }];\n  });\n};\nvar api = {\n  noAuto: noAuto,\n  config: config,\n  dom: dom,\n  library: library,\n  parse: parse,\n  findIconDefinition: findIconDefinition,\n  icon: icon,\n  text: text,\n  counter: counter,\n  layer: layer,\n  toHtml: toHtml\n};\n\nvar autoReplace = function autoReplace() {\n  var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var _params$autoReplaceSv = params.autoReplaceSvgRoot,\n      autoReplaceSvgRoot = _params$autoReplaceSv === void 0 ? DOCUMENT : _params$autoReplaceSv;\n  if ((Object.keys(namespace.styles).length > 0 || config.autoFetchSvg) && IS_DOM && config.autoReplaceSvg) api.dom.i2svg({\n    node: autoReplaceSvgRoot\n  });\n};\n\nexport { icon, noAuto, config, toHtml, layer, text, counter, library, dom, parse, findIconDefinition };\n"],"sourceRoot":""}