{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/css-loader/dist/runtime/api.js","webpack:///./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack:///./src/lib/api-get-sp.js","webpack:///./src/lib/api-get-config.js","webpack:///./src/lib/api-geo.js","webpack:///./src/lib/api-facets.js","webpack:///./src/lib/api-post.js","webpack:///./src/store/basket.js","webpack:///./src/store/log.js","webpack:///./src/store/index.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/vue-style-loader/lib/listToStyles.js","webpack:///./node_modules/vue-style-loader/lib/addStylesClient.js","webpack:///./src/App.vue","webpack:///src/App.vue","webpack:///./src/App.vue?ff1e","webpack:///./src/App.vue?315a","webpack:///./node_modules/vue-router/dist/vue-router.esm.js","webpack:///./src/router/index.js","webpack:///./src/main.js","webpack:///./src/lib/api-get.js","webpack:///./node_modules/url-search-params-polyfill/index.js","webpack:///./node_modules/unfetch/polyfill/index.js","webpack:///./src/lib/initial-accommodation-set.js","webpack:///./src/store/local-storage.js","webpack:///./src/lib/getApiUrl.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./src/lib/is-tomas-id.js"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","jsonpScriptSrc","p","exports","module","l","e","promises","installedChunkData","promise","Promise","resolve","reject","onScriptComplete","script","document","createElement","charset","timeout","nc","setAttribute","src","error","Error","event","onerror","onload","clearTimeout","chunk","errorType","type","realSrc","target","message","name","request","undefined","setTimeout","head","appendChild","all","m","c","d","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","oe","err","console","jsonpArray","window","oldJsonpFunction","slice","cssWithMappingToString","item","useSourceMap","content","cssMapping","btoa","sourceMapping","toComment","sourceURLs","sources","map","source","concat","sourceRoot","join","sourceMap","base64","unescape","encodeURIComponent","JSON","stringify","list","toString","this","mediaQuery","dedupe","alreadyImportedModules","id","_i","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","options","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","apiGetSP","apiUrl","apiKey","nameOrId","apiGet","apiGetConfig","fetch","then","json","catch","reason","apiGeo","config","params","keys","k","apiFacets","apiPost","action","payload","method","headers","body","basket","namespaced","actions","sessionId","rootState","cartItemId","cartItemAdditionId","log","logUri","uri","tomasId","location","href","logCampaign","initialState","namespace","defaultValues","fixedValues","locale","favorites","ensureArray","getFromLocalStorage","getFromStorage","session","nameToIdMappings","sort","searchItem","searchRadius","radius","searchDate","searchAccommodation","bookableOnly","filterFavorites","spFeature","sFeature","accommodationType","touristicType","spClassification","sClassification","board","entriesPerPage","parseInt","start","Date","end","defaultSpFeature","f","indexOf","hiddenFilterGroups","longitude","latitude","lng","parseFloat","lat","isNaN","storedValuesExist","offSetTop","offSetTopBar","offSetTopMobile","offSetTopBarMobile","offSetTopAffix","detailUri","listUri","bookUri","configIsLoaded","serviceProviders","initialAccommodationSet","geoEntries","facets","facetsLoading","partnerState","bookable","fulltextSearch","fulltextSearchMode","sortByFeature","fixedTomasIds","tomasid","termsAndConditionsLink","privacyLink","textColor","mapPinFillColor","mapPinStrokeColor","mapPinFillColorActive","mapPinStrokeColorActive","mapRadiusColor","Vue","use","Vuex","Store","state","mutations","addFavorite","saveToLocalStorage","removeFavorite","pos","refreshFavorites","setConfig","saveToStorage","setSession","addServiceProvider","serviceProvider","url","setSearchItem","setSearchRadius","setSearchDate","setSearchAccommodation","toggleFilterFavorites","setBookableOnly","setGeoEntries","clearGeoEntries","setFacets","clearFacets","clearAllFilters","commit","clearSearch","updateSearchFromParameters","URLSearchParams","search","has","searchText","searchType","feature_id","text","featureId","rLat","rLng","rRadius","spFeatures","getAll","sFeatures","touristicTypes","accommodationTypes","spClassifications","setFilter_spFeature","ids","Array","isArray","clearFilter_spFeature","setFilter_sFeature","clearFilter_sFeature","setFilter_spClassification","clearFilter_spClassification","setFilter_sClassification","clearFilter_sClassification","setFilter_accommodationType","clearFilter_accommodationType","setFilter_touristicType","clearFilter_touristicType","setFilter_board","clearFilter_board","setSort","isTomasId","sp","getters","reset","getSearchConfig","rawFacets","quantity","getLayout","layout","layouts","getConfigItemById","getFeature","getServiceFeature","getAccommodationType","matchFeatureList","featureList","features","max","forService","fl","featureLists","flIsArray","idx","feature","includes","label","matchPartnerStateList","partnerStateList","_state$config","_state$config$partner","_state$config$partner2","partnerStateLists","getClassificationFromIdList","getClassification","split","classifications","getConfigEntry","getTouristicType","part","getLabel","labels","matchFeatureIcons","iconListName","iconList","iconsLists","usedId","matchServiceProviderFeatures","featureGroup","fg","find","fGroup","fc","searchConfig","forEach","getDefaultSorting","teaserFeaturesFuzzySearch","getDate","getMonth","getFullYear","adults","children","baseKey","childAges","getDistance","dLat","Math","PI","dLng","lat1","lat2","a","sin","cos","atan2","sqrt","distance","round","getSortings","sorting","rawSorting","vacancy","default","types","trim","getFacetById","nextTick","fn","args","arguments","platform","arch","execPath","title","pid","browser","env","argv","binding","path","cwd","chdir","dir","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","listToStyles","parentId","styles","newStyles","css","media","parts","hasDocument","DEBUG","stylesInDom","getElementsByTagName","singletonElement","singletonCounter","isProduction","noop","ssrIdKey","isOldIE","navigator","test","userAgent","toLowerCase","addStylesClient","_isProduction","_options","addStylesToDom","newList","mayRemove","domStyle","refs","addStyle","createStyleElement","styleElement","obj","update","remove","querySelector","parentNode","removeChild","styleIndex","applyToSingletonTag","applyToTag","newObj","replaceText","textStore","index","replacement","filter","Boolean","styleSheet","cssText","cssNode","createTextNode","childNodes","insertBefore","ssrId","firstChild","_vm","_c","_self","component","extend","b","encodeReserveRE","encodeReserveReplacer","charCodeAt","commaRE","encode","str","replace","decode","decodeURIComponent","resolveQuery","query","extraQuery","_parseQuery","parsedQuery","parse","parseQuery","castQueryParamValue","String","res","param","val","stringifyQuery","val2","x","trailingSlashRE","createRoute","record","redirectedFrom","router","clone","route","meta","hash","fullPath","getFullPath","matched","formatMatch","freeze","START","unshift","ref","_stringifyQuery","isSameRoute","onlyPath","isObjectEqual","aKeys","bKeys","every","aVal","bKey","bVal","isIncludedRoute","current","queryIncludes","handleRouteEntered","instances","instance","cbs","enteredCbs","i$1","_isBeingDestroyed","View","props","_","routerView","$createElement","$route","cache","_routerViewCache","depth","inactive","_routerRoot","vnodeData","keepAlive","_directInactive","_inactive","$parent","routerViewDepth","cachedData","cachedComponent","configProps","fillPropsinData","components","registerRouteInstance","vm","prepatch","vnode","componentInstance","init","propsToPass","resolveProps","attrs","resolvePath","relative","base","append","firstChar","charAt","stack","pop","segments","segment","parsePath","hashIndex","queryIndex","cleanPath","isarray","arr","pathToRegexp_1","pathToRegexp","parse_1","compile_1","compile","tokensToFunction_1","tokensToFunction","tokensToRegExp_1","tokensToRegExp","PATH_REGEXP","RegExp","tokens","defaultDelimiter","delimiter","exec","escaped","offset","next","prefix","capture","group","modifier","asterisk","partial","repeat","optional","pattern","escapeGroup","escapeString","substr","encodeURIComponentPretty","encodeURI","toUpperCase","encodeAsterisk","matches","flags","opts","pretty","token","TypeError","attachKeys","re","sensitive","regexpToRegexp","groups","match","arrayToRegexp","regexp","stringToRegexp","strict","endsWithDelimiter","regexpCompileCache","fillParams","routeMsg","filler","pathMatch","normalizeLocation","raw","_normalized","params$1","rawPath","parsedPath","basePath","_Vue","toTypes","eventTypes","Link","to","required","tag","custom","exact","exactPath","activeClass","exactActiveClass","ariaCurrentValue","this$1$1","$router","classes","globalActiveClass","linkActiveClass","globalExactActiveClass","linkExactActiveClass","activeClassFallback","exactActiveClassFallback","compareTarget","handler","guardEvent","on","click","class","scopedSlot","$scopedSlots","$hasNormal","navigate","isActive","isExactActive","findAnchor","$slots","isStatic","aData","handler$1","event$1","aAttrs","metaKey","altKey","ctrlKey","shiftKey","defaultPrevented","button","currentTarget","getAttribute","preventDefault","child","install","installed","isDef","v","registerInstance","callVal","_parentVnode","mixin","_router","util","defineReactive","history","destroyed","_route","strats","optionMergeStrategies","beforeRouteEnter","beforeRouteLeave","beforeRouteUpdate","created","inBrowser","createRouteMap","routes","oldPathList","oldPathMap","oldNameMap","parentRoute","pathList","pathMap","nameMap","addRouteRecord","matchAs","pathToRegexpOptions","normalizedPath","normalizePath","caseSensitive","regex","compileRouteRegex","alias","redirect","beforeEnter","childMatchAs","aliases","aliasRoute","createMatcher","addRoutes","addRoute","parentOrRoute","getRoutes","currentRoute","_createRoute","paramNames","record$1","matchRoute","originalRedirect","resolveRecordPath","resolvedPath","aliasedPath","aliasedMatch","aliasedRecord","len","Time","performance","now","genStateKey","toFixed","_key","getStateKey","setStateKey","positionStore","setupScroll","scrollRestoration","protocolAndPath","protocol","host","absolutePath","stateCopy","replaceState","addEventListener","handlePopState","removeEventListener","handleScroll","from","isPop","app","behavior","scrollBehavior","$nextTick","position","getScrollPosition","shouldScroll","scrollToPosition","saveScrollPosition","pageXOffset","y","pageYOffset","getElementPosition","el","docEl","documentElement","docRect","getBoundingClientRect","elRect","left","top","isValidPosition","isNumber","normalizePosition","normalizeOffset","hashStartsWithNumberRE","isObject","selector","getElementById","style","scrollTo","supportsPushState","ua","pushState","NavigationFailureType","redirected","aborted","cancelled","duplicated","createNavigationRedirectedError","createRouterError","stringifyRoute","createNavigationDuplicatedError","createNavigationCancelledError","createNavigationAbortedError","_isRouter","propertiesToLog","isError","isNavigationFailure","runQueue","queue","cb","step","resolveAsyncComponents","hasAsync","pending","flatMapComponents","def","cid","once","resolvedDef","isESModule","resolved","msg","comp","flatten","hasSymbol","called","History","normalizeBase","ready","readyCbs","readyErrorCbs","errorCbs","listeners","baseEl","resolveQueue","updated","activated","deactivated","extractGuards","records","reverse","guards","guard","extractGuard","extractLeaveGuards","bindGuard","extractUpdateHooks","extractEnterGuards","bindEnterGuard","listen","onReady","errorCb","onError","transitionTo","onComplete","onAbort","prev","confirmTransition","updateRoute","ensureURL","afterHooks","abort","lastRouteIndex","lastCurrentIndex","beforeHooks","iterator","enterGuards","resolveHooks","setupListeners","teardown","cleanupListener","HTML5History","_startLocation","getLocation","__proto__","constructor","expectScroll","supportsScroll","handleRoutingEvent","go","fromRoute","getCurrentLocation","pathname","pathLowerCase","baseLowerCase","HashHistory","fallback","checkFallback","ensureSlash","getHash","replaceHash","eventType","pushHash","getUrl","AbstractHistory","targetIndex","VueRouter","apps","matcher","prototypeAccessors","configurable","$once","handleInitialScroll","routeOrError","beforeEach","registerHook","beforeResolve","afterEach","back","forward","getMatchedComponents","createHref","normalizedTo","defineProperties","VueRouter$1","version","START_LOCATION","createRouter","process","clear","localStorage","sessionStorage","productionTip","Vuetify","$elements","getElementsByClassName","savedElements","_$el$attributes","_$el$attributes$data","$el","attributes","icons","iconfont","theme","customProperties","themes","light","primary","secondary","accent","info","success","warning","lang","locales","de","en","vuetify","settings","store","appStore","getApiUrl","App","innerHTML","$mount","endpoint","self","nativeURLSearchParams","isSupportObjectConstructor","decodesPlusesCorrectly","__URLSearchParams__","encodesAmpersandsCorrectly","ampersandTest","URLSearchParamsPolyfill","iterable","appendTo","dict","set","propValue","forSureUsePolyfill","useProxy","Proxy","construct","Function","USPProto","polyfill","callback","thisArg","parseToDict","getOwnPropertyNames","values","items","makeIterator","entries","done","pairs","prop","global","XMLHttpRequest","u","ok","status","statusText","responseURL","responseText","blob","Blob","response","open","getAllResponseHeaders","withCredentials","credentials","setRequestHeader","send","initialAccommodationEntry","getItem","setItem","returnQueryString","searchParams","queryString","addApiUrlToUrl","newUrl","addQueryParam","urlObj","URL","g","normalizeArray","allowAboveRoot","up","last","basename","matchedSlash","xs","resolvedAbsolute","normalize","isAbsolute","trailingSlash","paths","fromParts","toParts","min","samePartsLength","outputParts","sep","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","possibleId"],"mappings":"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","file":"eobuchung-app.js?h=a0d67c3fe087448dc465","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t\"app\": 0\n \t};\n\n \tvar deferredModules = [];\n\n \t// script path function\n \tfunction jsonpScriptSrc(chunkId) {\n \t\treturn __webpack_require__.p + \"eobuchung-lib-\" + chunkId + \".js?h=\" + {\"routed-book~routed-list~routed-main~routed-teaser\":\"44373c0cce1fc8a05b8c\",\"routed-book\":\"2e463e121d18817cf834\",\"routed-list~routed-main\":\"8a3ffea959e19932254a\",\"routed-list\":\"377b9bf85feede4f55e1\",\"routed-main\":\"d898a3781483ce8db2c4\",\"routed-teaser\":\"34891e3088dffc2fdb10\"}[chunkId] + \"\"\n \t}\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n \t// This file contains only the entry chunk.\n \t// The chunk loading function for additional chunks\n \t__webpack_require__.e = function requireEnsure(chunkId) {\n \t\tvar promises = [];\n\n\n \t\t// JSONP chunk loading for javascript\n\n \t\tvar installedChunkData = installedChunks[chunkId];\n \t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n \t\t\t// a Promise means \"currently loading\".\n \t\t\tif(installedChunkData) {\n \t\t\t\tpromises.push(installedChunkData[2]);\n \t\t\t} else {\n \t\t\t\t// setup Promise in chunk cache\n \t\t\t\tvar promise = new Promise(function(resolve, reject) {\n \t\t\t\t\tinstalledChunkData = installedChunks[chunkId] = [resolve, reject];\n \t\t\t\t});\n \t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n \t\t\t\t// start chunk loading\n \t\t\t\tvar script = document.createElement('script');\n \t\t\t\tvar onScriptComplete;\n\n \t\t\t\tscript.charset = 'utf-8';\n \t\t\t\tscript.timeout = 120;\n \t\t\t\tif (__webpack_require__.nc) {\n \t\t\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n \t\t\t\t}\n \t\t\t\tscript.src = jsonpScriptSrc(chunkId);\n\n \t\t\t\t// create error before stack unwound to get useful stacktrace later\n \t\t\t\tvar error = new Error();\n \t\t\t\tonScriptComplete = function (event) {\n \t\t\t\t\t// avoid mem leaks in IE.\n \t\t\t\t\tscript.onerror = script.onload = null;\n \t\t\t\t\tclearTimeout(timeout);\n \t\t\t\t\tvar chunk = installedChunks[chunkId];\n \t\t\t\t\tif(chunk !== 0) {\n \t\t\t\t\t\tif(chunk) {\n \t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n \t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n \t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n \t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n \t\t\t\t\t\t\terror.type = errorType;\n \t\t\t\t\t\t\terror.request = realSrc;\n \t\t\t\t\t\t\tchunk[1](error);\n \t\t\t\t\t\t}\n \t\t\t\t\t\tinstalledChunks[chunkId] = undefined;\n \t\t\t\t\t}\n \t\t\t\t};\n \t\t\t\tvar timeout = setTimeout(function(){\n \t\t\t\t\tonScriptComplete({ type: 'timeout', target: script });\n \t\t\t\t}, 120000);\n \t\t\t\tscript.onerror = script.onload = onScriptComplete;\n \t\t\t\tdocument.head.appendChild(script);\n \t\t\t}\n \t\t}\n \t\treturn Promise.all(promises);\n \t};\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n \t// on error function for async loading\n \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n\n \tvar jsonpArray = window[\"webpackJsonp\"] = window[\"webpackJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([\"56d7\",\"eobuchung\",\"vuetify\"]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\n// eslint-disable-next-line func-names\nmodule.exports = function (useSourceMap) {\n  var list = []; // return the list of modules as css string\n\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = cssWithMappingToString(item, useSourceMap);\n\n      if (item[2]) {\n        return \"@media \".concat(item[2], \" {\").concat(content, \"}\");\n      }\n\n      return content;\n    }).join('');\n  }; // import a list of modules into the list\n  // eslint-disable-next-line func-names\n\n\n  list.i = function (modules, mediaQuery, dedupe) {\n    if (typeof modules === 'string') {\n      // eslint-disable-next-line no-param-reassign\n      modules = [[null, modules, '']];\n    }\n\n    var alreadyImportedModules = {};\n\n    if (dedupe) {\n      for (var i = 0; i < this.length; i++) {\n        // eslint-disable-next-line prefer-destructuring\n        var id = this[i][0];\n\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n\n    for (var _i = 0; _i < modules.length; _i++) {\n      var item = [].concat(modules[_i]);\n\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      if (mediaQuery) {\n        if (!item[2]) {\n          item[2] = mediaQuery;\n        } else {\n          item[2] = \"\".concat(mediaQuery, \" and \").concat(item[2]);\n        }\n      }\n\n      list.push(item);\n    }\n  };\n\n  return list;\n};\n\nfunction cssWithMappingToString(item, useSourceMap) {\n  var content = item[1] || ''; // eslint-disable-next-line prefer-destructuring\n\n  var cssMapping = item[3];\n\n  if (!cssMapping) {\n    return content;\n  }\n\n  if (useSourceMap && typeof btoa === 'function') {\n    var sourceMapping = toComment(cssMapping);\n    var sourceURLs = cssMapping.sources.map(function (source) {\n      return \"/*# sourceURL=\".concat(cssMapping.sourceRoot || '').concat(source, \" */\");\n    });\n    return [content].concat(sourceURLs).concat([sourceMapping]).join('\\n');\n  }\n\n  return [content].join('\\n');\n} // Adapted from convert-source-map (MIT)\n\n\nfunction toComment(sourceMap) {\n  // eslint-disable-next-line no-undef\n  var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n  var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n  return \"/*# \".concat(data, \" */\");\n}","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent(\n  scriptExports,\n  render,\n  staticRenderFns,\n  functionalTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier /* server only */,\n  shadowMode /* vue-cli only */\n) {\n  // Vue.extend constructor export interop\n  var options =\n    typeof scriptExports === 'function' ? scriptExports.options : scriptExports\n\n  // render functions\n  if (render) {\n    options.render = render\n    options.staticRenderFns = staticRenderFns\n    options._compiled = true\n  }\n\n  // functional template\n  if (functionalTemplate) {\n    options.functional = true\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = 'data-v-' + scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) {\n    // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = shadowMode\n      ? function () {\n          injectStyles.call(\n            this,\n            (options.functional ? this.parent : this).$root.$options.shadowRoot\n          )\n        }\n      : injectStyles\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // for template-only hot-reload because in that case the render fn doesn't\n      // go through the normalizer\n      options._injectStyles = hook\n      // register for functional component in vue file\n      var originalRender = options.render\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context)\n        return originalRender(h, context)\n      }\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n","import apiGet from './api-get';\n\n/**\n * get service provider from api\n * @param apiUrl\n * @param apiKey\n * @param nameOrId\n * @returns {Promise<unknown>}\n */\nexport default function apiGetSP(apiUrl, apiKey, nameOrId) {\n    return apiGet(apiUrl, apiKey, nameOrId, 'etb_show.json');\n}\n","import 'unfetch/polyfill';\n\n/**\n * get config from api\n * @param apiUrl\n * @param apiKey\n * @returns {Promise<unknown>}\n */\nexport default function apiGetConfig(apiUrl, apiKey) {\n    return new Promise(function (resolve, reject) {\n        fetch(apiUrl + 'etb_config.json?apiKey=' + apiKey)\n            .then(r => r.json())\n            .then(data => {\n                resolve(data);\n            }).catch((reason) => {\n            reject(reason);\n        });\n    });\n}\n","import 'unfetch/polyfill';\n\n/**\n * get geo data from api\n * @param apiUrl\n * @param apiKey\n * @param config\n * @returns {Promise<unknown>}\n */\nexport default function apiGeo(apiUrl, apiKey, config = {}) {\n    return new Promise(function (resolve, reject) {\n        const params = Object.keys(config).map(function(k) {\n            return encodeURIComponent(k) + \"=\" + encodeURIComponent(config[k]);\n        }).join('&');\n\n        fetch(apiUrl + 'etb_geo.json?' + params + '&apiKey=' + apiKey)\n            .then(r => r.json())\n            .then(data => {\n                resolve(data);\n            }).catch((reason) => {\n            reject(reason);\n        });\n    });\n}","import 'unfetch/polyfill';\n\n/**\n * get facets from api\n * @param apiUrl\n * @param apiKey\n * @param config\n * @returns {Promise<unknown>}\n */\nexport default function apiFacets(apiUrl, apiKey, config = {}) {\n    return new Promise(function (resolve, reject) {\n        const params = Object.keys(config).map(function(k) {\n            return encodeURIComponent(k) + \"=\" + encodeURIComponent(config[k]);\n        }).join('&');\n\n        fetch(apiUrl + 'etb_facets.json?' + params + '&apiKey=' + apiKey)\n            .then(r => r.json())\n            .then(data => {\n                resolve(data);\n            }).catch((reason) => {\n            reject(reason);\n        });\n    });\n}\n","import 'unfetch/polyfill';\n\n/**\n * send POST request to api\n * @param apiUrl\n * @param apiKey\n * @param action to call (without etb_, e.g. \"addbasket\")\n * @param payload (JSON)\n * @returns {Promise<unknown>}\n */\nexport default function apiPost(apiUrl, apiKey, action, payload = {}) {\n    return new Promise(function (resolve, reject) {\n        fetch(apiUrl + 'etb_' + action + '.json?apiKey=' + apiKey, {\n            method: 'POST',\n            headers: {\n                'Content-Type': 'application/json'\n            },\n            body: JSON.stringify(payload)\n        })\n            .then(r => r.json())\n            .then(data => {\n                resolve(data);\n            }).catch((reason) => {\n            reject(reason);\n        });\n    });\n}\n","import apiPost from '../lib/api-post.js';\n\n/**\n * Basket module of Vuex\n */\nconst basket = {\n    namespaced: true,\n    actions: {\n        async addToBasket(context, payload) {\n            if (payload && payload.id && payload.sessionId) {\n                await apiPost(context.rootState.apiUrl, context.rootState.apiKey, 'addbasket', payload);\n            }\n        },\n        async removeFromBasket(context, payload) {\n            if (payload && payload.id && payload.sessionId) {\n                return await apiPost(context.rootState.apiUrl, context.rootState.apiKey, 'removebasket', payload);\n            }\n            return null;\n        },\n        async addOptionalItemToBasket(context, payload) {\n            if (payload && payload.cartItemId && payload.cartItemAdditionId && payload.sessionId) {\n                return await apiPost(context.rootState.apiUrl, context.rootState.apiKey, 'addbasket_item', payload);\n            }\n            return null;\n        },\n        async removeOptionalItemFromBasket(context, payload) {\n            if (payload && payload.cartItemId && payload.cartItemAdditionId && payload.sessionId) {\n                return await apiPost(context.rootState.apiUrl, context.rootState.apiKey, 'removebasket_item', payload);\n            }\n            return null;\n        }\n    }\n};\n\nexport default basket;\n","import 'unfetch/polyfill';\n\n/**\n * Log module of Vuex (Eberl Tomas Log)\n *\n * Add additional headers to eberl tomas log for CORS logging, if needed:\n\n ```typoscript\n tx_eberltomaslog_ajax.config.additionalHeaders >\n tx_eberltomaslog_ajax.config.additionalHeaders.10.header = Content-type:text/plain\n tx_eberltomaslog_ajax.config.additionalHeaders.20.header = Access-Control-Allow-Origin: *\n ```\n */\nconst log = {\n    namespaced: true,\n    actions: {\n        async do(context, payload) {\n            // logging uri must be defined\n            if (context.rootState.logUri) { // e.g. http://127.0.0.1:9090/?type=20975\n                const uri = context.rootState.logUri +\n                    '&tx_eberltomaslog_pi1[action]=log&tx_eberltomaslog_pi1[tomasId]=' + encodeURIComponent(payload.tomasId) +\n                    '&tx_eberltomaslog_pi1[type]=' + encodeURIComponent(payload.type) +\n                    '&tx_eberltomaslog_pi1[logAction]=' + encodeURIComponent(payload.action) +\n                    '&tx_eberltomaslog_pi1[url]=' + encodeURIComponent(window.location.href) +\n                    (context.rootState.logCampaign ? '&tx_eberltomaslog_pi1[campaign]=' + encodeURIComponent(context.rootState.logCampaign) : '');\n\n                try {\n                    await fetch(uri);\n                } catch (e) {\n                    console.log('Log error: ' + e.message);\n                }\n            }\n        }\n    }\n};\n\nexport default log;\n","import Vue from 'vue';\nimport Vuex from 'vuex';\nimport apiGetSP from '../lib/api-get-sp';\nimport isTomasId from \"../lib/is-tomas-id\";\nimport apiGetConfig from \"../lib/api-get-config\";\nimport apiGeo from \"../lib/api-geo\";\nimport apiFacets from \"../lib/api-facets\";\nimport basket from \"./basket\";\nimport log from \"./log\";\nimport {getFromStorage, saveToStorage, ensureArray, getFromLocalStorage, saveToLocalStorage} from \"./local-storage\";\nimport 'url-search-params-polyfill';\nimport initialAccommodationSet from \"../lib/initial-accommodation-set.js\";\n\nVue.use(Vuex);\n\n// load initial state from local storage\nfunction initialState(namespace = 'eobuchung', defaultValues = {}, fixedValues = {}) {\n    const locale = defaultValues.locale || 'de';\n\n    const favorites = ensureArray(getFromLocalStorage('eobuchung-favorites')); // global - no namespace!\n    const config = getFromStorage('eobuchung-config-' + locale); // localized global - no namespace!\n    const session = getFromStorage('eobuchung-session'); // global - no namespace!\n    // const serviceProviders = getFromStorage('eobuchung-sps'); // global - no namespace! takes too much space - \"quota exceeded\" was the problem (more than 10 MB)\n    const nameToIdMappings = getFromStorage('eobuchung-name-to-ids'); // global - no namespace!\n    const sort = fixedValues.sort || getFromStorage(namespace + '-filter-sort');\n    let searchItem = getFromStorage(namespace + '-filter-search-item');\n    const searchRadius = fixedValues.radius || getFromStorage(namespace + '-filter-search-radius');\n    const searchDate = getFromStorage(namespace + '-filter-search-date');\n    const searchAccommodation = getFromStorage(namespace + '-filter-search-accommodation');\n    const bookableOnly = getFromStorage(namespace + '-bookable-only');\n    const filterFavorites = getFromStorage(namespace + '-filter-favorites');\n    let spFeature = ensureArray(fixedValues.spFeature || getFromStorage(namespace + '-filter-sp-feature') || defaultValues.spFeature);\n    const sFeature = ensureArray(fixedValues.sFeature || getFromStorage(namespace + '-filter-s-feature') || defaultValues.sFeature);\n    const accommodationType = ensureArray(getFromStorage(namespace + '-filter-accommodation-type'));\n    const touristicType = ensureArray(fixedValues.touristicType || getFromStorage(namespace + '-filter-touristic-type') || defaultValues.touristicType);\n    const spClassification = ensureArray(fixedValues.spClassification || getFromStorage(namespace + '-filter-sp-classification') || defaultValues.spClassification);\n    const sClassification = ensureArray(getFromStorage(namespace + '-filter-s-classification'));\n    const board = ensureArray(getFromStorage(namespace + '-filter-board'));\n    const entriesPerPage = parseInt(fixedValues.entriesPerPage || defaultValues.entriesPerPage);\n\n    // parse search date => JSON to Javascript\n    if (searchDate && searchDate.start) {\n        searchDate.start = new Date(searchDate.start);\n    }\n    if (searchDate && searchDate.end) {\n        searchDate.end = new Date(searchDate.end);\n    }\n\n    // do we have fixed values?\n    const defaultSpFeature = ensureArray(defaultValues.spFeature) || [];\n    for (const f of defaultSpFeature) {\n        if (!spFeature) {\n            spFeature = [f];\n        } else if (spFeature.indexOf(f) === -1) {\n            spFeature.push(f);\n        }\n    }\n    const hiddenFilterGroups = ensureArray(defaultValues.hiddenFilterGroups) || [];\n\n    // e.g. teaser geo search\n    if (fixedValues.longitude && fixedValues.latitude) {\n        const lng = parseFloat(fixedValues.longitude);\n        const lat = parseFloat(fixedValues.latitude);\n\n        if (!isNaN(lng) && !isNaN(lat)) {\n            searchItem = {\n                \"text\": \"Geo\",\n                \"value\": \"Geo\",\n                lng,\n                lat,\n                type: \"geo\",\n                radius: \"\"\n            };\n        }\n    }\n\n    // do we have any saved values? Show stuff\n    const storedValuesExist = !!(favorites.length || sort || filterFavorites || searchItem || searchRadius || searchDate || searchAccommodation.length);\n\n    // offsets\n    const offSetTop = parseInt(defaultValues.offSetTop);\n    const offSetTopBar = parseInt(defaultValues.offSetTopBar);\n    const offSetTopMobile = parseInt(defaultValues.offSetTopMobile);\n    const offSetTopBarMobile = parseInt(defaultValues.offSetTopBarMobile);\n    const offSetTopAffix = parseInt(defaultValues.offSetTopAffix);\n\n    return {\n        // connection stuff\n        apiUrl: defaultValues.apiUrl || '', // API base URL\n        apiKey: defaultValues.apiKey || '', // API key\n        // tomas session\n        session: session || null,\n\n        // locale\n        locale: locale,\n\n        // targets\n        detailUri: defaultValues.detailUri || '/xxxSLUGxxx', // target URI for detail pages\n        listUri: defaultValues.listUri || '/list', // target URI for list view\n        bookUri: defaultValues.bookUri || '/book', // target URI for booking view\n        logUri: defaultValues.logUri || null, // target URI for logs\n        logCampaign: defaultValues.logCampaign || null, // campaign for logs\n\n        // user storage\n        favorites: favorites || [], // favorites of user - saved in local storage\n        config: config || {}, // configuration from API\n        configIsLoaded: !!config,\n        serviceProviders: {}, // saved service providers by tomas id\n        nameToIdMappings: nameToIdMappings || {}, // name to tomas id mappings to find service providers\n\n        // from search\n        searchItem: searchItem || null,  // keeps search item object provided by autocompleter {text: 'xx', value: 'xxx', type: 'sp'}\n        searchRadius: searchRadius || 25,  // default is 25 km\n        searchDate: searchDate || null,  // object keeping start and stop dates for search\n        searchAccommodation: searchAccommodation || initialAccommodationSet(), // keeps accommodation data\n        bookableOnly: !!bookableOnly,\n        // geo search\n        geoEntries: null, // actually [] list of results from etb_geo.json {\"id\": \"xxx\", \"name\": \"abc\", \"lat\": 0.0, \"lng\": 0.0}\n        // facets from API\n        facets: null,\n        facetsLoading: false, // loading state of facets\n\n        // filters and sorting\n        filterFavorites: filterFavorites,\n        spFeature: spFeature || [],\n        sFeature: sFeature || [],\n        accommodationType: accommodationType || [],\n        touristicType: touristicType || [], // TODO: needed or obsolete?\n        spClassification: spClassification || [],\n        sClassification: sClassification || [],\n        partnerState: ensureArray(fixedValues.partnerState || []),\n        // teaser fixed entries - start\n        bookable: fixedValues.bookable,\n        fulltextSearch: fixedValues.fulltextSearch,\n        fulltextSearchMode: fixedValues.fulltextSearchMode,\n        sortByFeature: fixedValues.sortByFeature,\n        entriesPerPage: isNaN(entriesPerPage) ? 9 : entriesPerPage,\n        fixedTomasIds: ensureArray(fixedValues.tomasid || []),\n        // teaser fixed entries - end\n        board: board || [],\n        sort: sort || '',\n\n        storedValuesExist: storedValuesExist, // flag for TYPO3\n\n        // fixed values for hiding those in output\n        defaultSpFeature,\n        hiddenFilterGroups,\n\n        // bookingLinks\n        termsAndConditionsLink: defaultValues.termsAndConditionsLink || '',\n        privacyLink: defaultValues.privacyLink || '',\n\n        // offsets\n        offSetTop: isNaN(offSetTop) ? 0 : offSetTop, // top offset, e.g. for detail on desktop\n        offSetTopBar: isNaN(offSetTopBar) ? 0 : offSetTopBar, // top offset for top bar in Desktop view\n        offSetTopMobile: isNaN(offSetTopMobile) ? 0 : offSetTopMobile, // top offset, e.g. for detail on mobile\n        offSetTopBarMobile: isNaN(offSetTopBarMobile) ? 0 : offSetTopBarMobile, // top offset for top bar in mobile view\n        offSetTopAffix: isNaN(offSetTopAffix) ? 0 : offSetTopAffix, // top offset for affix (detail)\n\n        // colors\n        textColor: defaultValues.textColor || '#333',\n\n        // map pin colors\n        mapPinFillColor: defaultValues.mapPinFillColor || '#257eca',\n        mapPinStrokeColor: defaultValues.mapPinStrokeColor || '#2d5069',\n        mapPinFillColorActive: defaultValues.mapPinFillColorActive || '#c55c52',\n        mapPinStrokeColorActive: defaultValues.mapPinStrokeColorActive || '#5d332f',\n        mapRadiusColor: defaultValues.mapRadiusColor || '#f00',\n    };\n}\n\n/**\n * Store for App.vue\n */\nexport default function (namespace = 'eobuchung', defaultValues = {}, fixedValues = {}) {\n    return new Vuex.Store({\n        state: initialState(namespace, defaultValues, fixedValues || {}),\n        mutations: {\n            /**\n             * add favorite to list\n             * @param state\n             * @param id\n             */\n            addFavorite(state, id) {\n                if (state.favorites.indexOf(id) === -1) {\n                    state.favorites.push(id);\n                    // persist to local storage\n                    saveToLocalStorage('eobuchung-favorites', state.favorites);\n                }\n            },\n            /**\n             * remove favorite from list\n             * @param state\n             * @param id\n             */\n            removeFavorite(state, id) {\n                const pos = state.favorites.indexOf(id);\n                if (pos !== -1) {\n                    state.favorites.splice(pos, 1);\n                    // persist to local storage\n                    saveToLocalStorage('eobuchung-favorites', state.favorites);\n                }\n            },\n            /**\n             * refresh favorite\n             * @param state\n             * @param favorites\n             */\n            refreshFavorites(state, favorites) {\n                state.favorites = favorites;\n            },\n            /**\n             * Save config to state\n             * @param state\n             * @param config\n             */\n            setConfig(state, config) {\n                state.configIsLoaded = true;\n                state.config = config;\n                saveToStorage('eobuchung-config-' + state.locale, state.config);\n            },\n            /**\n             * set and save tomas session id\n             * @param state\n             * @param sessionId\n             */\n            setSession(state, sessionId) {\n                state.session = sessionId;\n                saveToStorage('eobuchung-session', sessionId);\n            },\n            /**\n             * Add single service provider to cache\n             * @param state\n             * @param serviceProvider\n             */\n            addServiceProvider(state, serviceProvider) {\n                if (!(serviceProvider.id in state.serviceProviders)) {\n                    state.serviceProviders[serviceProvider.id] = serviceProvider;\n                    state.nameToIdMappings[serviceProvider.url] = serviceProvider.id;\n\n                    // persist to local storage\n                    // saveToStorage('eobuchung-sps', state.serviceProviders); // TOO large - quota exceeded will follow too often\n                    saveToStorage('eobuchung-name-to-ids', state.nameToIdMappings);\n                }\n            },\n            setSearchItem(state, searchItem) {\n                state.searchItem = searchItem;\n                // persist to local storage\n                saveToStorage(namespace + '-filter-search-item', state.searchItem);\n            },\n            setSearchRadius(state, searchRadius) {\n                state.searchRadius = searchRadius;\n\n                // persist to local storage\n                saveToStorage(namespace + '-filter-search-radius', state.searchRadius);\n            },\n            setSearchDate(state, searchDate) {\n                state.searchDate = searchDate;\n\n                // persist to local storage\n                saveToStorage(namespace + '-filter-search-date', state.searchDate);\n            },\n            setSearchAccommodation(state, searchAccommodation) {\n                state.searchAccommodation = searchAccommodation;\n\n                // persist to local storage\n                saveToStorage(namespace + '-filter-search-accommodation', state.searchAccommodation);\n            },\n            toggleFilterFavorites(state) {\n                state.filterFavorites = !state.filterFavorites;\n                // persist to local storage\n                saveToStorage(namespace + '-filter-favorites', state.filterFavorites);\n            },\n            setBookableOnly(state, bookable) {\n                state.bookableOnly = bookable;\n                // persist to local storage\n                saveToStorage(namespace + '-bookable-only', state.bookableOnly);\n            },\n            setGeoEntries(state, geoEntries) {\n                state.geoEntries = geoEntries;\n            },\n            clearGeoEntries(state) {\n                state.geoEntries = null;\n            },\n            setFacets(state, facets) {\n                state.facetsLoading = false;\n                state.facets = facets;\n            },\n            clearFacets(state) {\n                state.facetsLoading = true;\n                state.facets = null;\n            },\n            clearAllFilters(state) {\n                state.spFeature = ensureArray(defaultValues.spFeature) || [];\n                state.sFeature = ensureArray(defaultValues.sFeature) || [];\n                state.spClassification = ensureArray(defaultValues.spClassification) || [];\n                state.sClassification = [];\n                state.accommodationType = [];\n                state.touristicType = ensureArray(defaultValues.touristicType) || [];\n                state.board = [];\n\n                saveToStorage(namespace + '-filter-sp-feature', state.spFeature);\n                saveToStorage(namespace + '-filter-s-feature', state.sFeature);\n                saveToStorage(namespace + '-filter-sp-classification', state.spClassification);\n                saveToStorage(namespace + '-filter-s-classification', state.sClassification);\n                saveToStorage(namespace + '-filter-accommodation-type', state.accommodationType);\n                saveToStorage(namespace + '-filter-touristic-type', state.touristicType);\n                saveToStorage(namespace + '-filter-board', state.board);\n\n                // reset sorting, too\n                this.commit('setSort', '');\n            },\n            clearSearch() {\n                this.commit('clearAllFilters');\n\n                this.commit('setSearchItem', null);\n                this.commit('setSearchRadius', 25);\n                this.commit('setSearchDate', null);\n                this.commit('setSearchAccommodation', initialAccommodationSet());\n                this.commit('clearGeoEntries'); // clear geo entries\n            },\n            // we will check for certain get parameters and pre-populate search data accordingly\n            updateSearchFromParameters() {\n                // read stuff from search parameters\n                const params = new URLSearchParams(window.location.search);\n\n                // clear search\n                if (params.has('eob')) {\n                    this.commit('clearSearch');\n                }\n\n                // text search - a bit more complex, because we can have feature_id, text, type, value and lat, lng set\n                const searchText = params.get('eob_s');\n\n                if (searchText) {\n                    const searchType = params.get('eob_st');\n\n                    switch (searchType) {\n                        case 'sp': // service provider search\n                        case 'sp_name': // service provider name\n                        case null: // fallback 1\n                        case '': // fallback 2\n                            this.commit('setSearchItem', {\n                                feature_id: null,\n                                text: searchText,\n                                value: searchText,\n                                type: searchType || 'sp_name'\n                            });\n                            break;\n                        case 'region': // search by region/service provider feature\n                            const featureId = params.get('eob_sr'); //eslint-disable-line no-case-declarations\n                            if (featureId) {\n                                this.commit('setSearchItem', {\n                                    feature_id: featureId,\n                                    text: searchText,\n                                    value: searchText,\n                                    type: 'region'\n                                });\n                            }\n                            break;\n                        case 'geo':\n                            const lat = params.get('eob_lat'); //eslint-disable-line no-case-declarations\n                            const lng = params.get('eob_lng'); //eslint-disable-line no-case-declarations\n                            if (lat && lng) {\n                                const rLat = parseFloat(lat);\n                                const rLng = parseFloat(lng);\n                                if (!isNaN(rLat) && !isNaN(rLng)) {\n                                    this.commit('setSearchItem', {\n                                        feature_id: null,\n                                        text: searchText,\n                                        value: searchText,\n                                        type: 'geo',\n                                        lat: rLat,\n                                        lng: rLng,\n                                    });\n                                }\n                            }\n                            break;\n                    }\n                }\n                // text search - end\n\n                // search radius\n                const radius = params.get('eob_radius');\n                if (radius) {\n                    const rRadius = parseFloat(radius);\n                    if (!isNaN(radius)) {\n                        this.commit('setSearchRadius', rRadius);\n                    }\n                }\n\n                // service provider features\n                const spFeatures = params.getAll('eob_f');\n                if (spFeatures && spFeatures.length) {\n                    this.commit('setFilter_spFeature', spFeatures);\n                }\n\n                // service features\n                const sFeatures = params.getAll('eob_sf');\n                if (sFeatures && sFeatures.length) {\n                    this.commit('setFilter_sFeature', sFeatures);\n                }\n\n                // touristic types\n                const touristicTypes = params.getAll('eob_tt');\n                if (touristicTypes && touristicTypes.length) {\n                    this.commit('setFilter_touristicType', touristicTypes);\n                }\n\n                // accommodation types\n                const accommodationTypes = params.getAll('eob_ac');\n                if (accommodationTypes && accommodationTypes.length) {\n                    this.commit('setFilter_accommodationType', accommodationTypes);\n                }\n\n                // service provider classifications\n                const spClassifications = params.getAll('eob_c');\n                if (spClassifications && spClassifications.length) {\n                    this.commit('setFilter_spClassification', spClassifications);\n                }\n\n                // bookable only?\n                if (params.has('eob_bookable')) {\n                    this.commit('setBookableOnly', true);\n                }\n\n                // fuzzySearch TODO: needed here?\n            },\n            setFilter_spFeature(state, ids) {\n                if (Array.isArray(ids)) {\n                    state.spFeature = ids;\n                } else if (state.spFeature.indexOf(ids) === -1) {\n                    state.spFeature.push(ids);\n                }\n                // persist to local storage\n                saveToStorage(namespace + '-filter-sp-feature', state.spFeature);\n            },\n            clearFilter_spFeature(state, ids) {\n                const pos = state.spFeature.indexOf(ids);\n                if (pos !== -1) {\n                    state.spFeature.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-sp-feature', state.spFeature);\n                }\n            },\n            setFilter_sFeature(state, ids) {\n                if (Array.isArray(ids)) {\n                    state.sFeature = ids;\n                } else if (state.sFeature.indexOf(ids) === -1) {\n                    state.sFeature.push(ids);\n                }\n                // persist to local storage\n                saveToStorage(namespace + '-filter-s-feature', state.sFeature);\n            },\n            clearFilter_sFeature(state, ids) {\n                const pos = state.sFeature.indexOf(ids);\n                if (pos !== -1) {\n                    state.sFeature.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-s-feature', state.sFeature);\n                }\n            },\n            setFilter_spClassification(state, ids) {\n                if (Array.isArray(ids)) {\n                    state.spClassification = ids;\n                } else if (state.spClassification.indexOf(ids) === -1) {\n                    state.spClassification.push(ids);\n                }\n                // persist to local storage\n                saveToStorage(namespace + '-filter-sp-classification', state.spClassification);\n            },\n            clearFilter_spClassification(state, ids) {\n                const pos = state.spClassification.indexOf(ids);\n                if (pos !== -1) {\n                    state.spClassification.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-sp-classification', state.spClassification);\n                }\n            },\n            setFilter_sClassification(state, ids) {\n                if (state.sClassification.indexOf(ids) === -1) {\n                    state.sClassification.push(ids);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-s-classification', state.sClassification);\n                }\n            },\n            clearFilter_sClassification(state, ids) {\n                const pos = state.sClassification.indexOf(ids);\n                if (pos !== -1) {\n                    state.sClassification.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-s-classification', state.sClassification);\n                }\n            },\n            setFilter_accommodationType(state, ids) {\n                if (Array.isArray(ids)) {\n                    state.accommodationType = ids;\n                } else if (state.accommodationType.indexOf(ids) === -1) {\n                    state.accommodationType.push(ids);\n                 }\n                // persist to local storage\n                saveToStorage(namespace + '-filter-accommodation-type', state.accommodationType);\n            },\n            clearFilter_accommodationType(state, ids) {\n                const pos = state.accommodationType.indexOf(ids);\n                if (pos !== -1) {\n                    state.accommodationType.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-accommodation-type', state.accommodationType);\n                }\n            },\n            setFilter_touristicType(state, ids) {\n                if (Array.isArray(ids)) {\n                    state.touristicType = ids;\n                } else if (state.touristicType.indexOf(ids) === -1) {\n                    state.touristicType.push(ids);\n                }\n                // persist to local storage\n                saveToStorage(namespace + '-filter-touristic-type', state.touristicType);\n            },\n            clearFilter_touristicType(state, ids) {\n                const pos = state.touristicType.indexOf(ids);\n                if (pos !== -1) {\n                    state.touristicType.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-touristic-type', state.touristicType);\n                }\n            },\n            setFilter_board(state, ids) {\n                if (state.board.indexOf(ids) === -1) {\n                    state.board.push(ids);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-board', state.board);\n                }\n            },\n            clearFilter_board(state, ids) {\n                const pos = state.board.indexOf(ids);\n                if (pos !== -1) {\n                    state.board.splice(pos, 1);\n                    // persist to local storage\n                    saveToStorage(namespace + '-filter-board', state.board);\n                }\n            },\n            setSort(state, sort) {\n                state.sort = sort;\n\n                // persist to local storage\n                saveToStorage(namespace + '-filter-sort', state.sort);\n            },\n        },\n        actions: {\n            /**\n             * Load config from API - if not loaded already\n             * @param state\n             * @param commit\n             */\n            async loadConfig({state, commit}) {\n                if (!state.configIsLoaded) {\n                    // try to get config from API\n                    let config = await apiGetConfig(state.apiUrl, state.apiKey);\n                    // commit sp\n                    commit('setConfig', config);\n                }\n            },\n            /**\n             * Load one service provider from API\n             * @param state\n             * @param commit\n             * @param nameOrId\n             * @returns {Promise<*|*>}\n             */\n            async getServiceProvider({state, commit}, nameOrId) {\n                // try to get id from storage\n                if (isTomasId(nameOrId) && nameOrId in state.serviceProviders) {\n                    return state.serviceProviders[nameOrId];\n                }\n                // if it is a name, try to get mapping\n                if (nameOrId in state.nameToIdMappings) {\n                    const id = state.nameToIdMappings[nameOrId];\n                    if (id in state.serviceProviders) {\n                        return state.serviceProviders[id];\n                    }\n                }\n\n                // get from api and save\n                const sp = await apiGetSP(state.apiUrl, state.apiKey, nameOrId);\n\n                // commit sp\n                commit('addServiceProvider', sp);\n\n                return sp;\n            },\n            /**\n             * load geo data from API using current search config\n             * @param state\n             * @param commit\n             * @param getters\n             * @param reset true for reset\n             * @return {Promise<*|null|unknown|[]|*>}\n             */\n            async loadGeoData({state, commit, getters}, reset) {\n                if (reset || state.geoEntries === null) {\n                    try {\n                        const geoEntries = await apiGeo(state.apiUrl, state.apiKey, getters.getSearchConfig());\n\n                        commit('setGeoEntries', geoEntries);\n\n                        return geoEntries;\n                    } catch (e) {\n                        // console.log(e);\n                        return e;\n                    }\n                }\n                return state.geoEntries;\n            },\n            async getFacets({state, commit, getters}, reset) {\n                if (reset || state.facets === null) {\n                    try {\n                        const rawFacets = await apiFacets(state.apiUrl, state.apiKey, getters.getSearchConfig());\n\n                        const facets = {};\n                        for (let key in rawFacets) {\n                            for (let ids in rawFacets[key]) {\n                                if (rawFacets[key][ids].quantity) {\n                                    facets[ids] = rawFacets[key][ids].quantity;\n                                }\n                            }\n                        }\n\n                        commit('setFacets', facets);\n\n                        return facets;\n                    } catch (e) {\n                        // set facets to empty\n                        commit('setFacets', {});\n                        // console.log(e);\n                        return e;\n                    }\n                }\n                return state.facets;\n            },\n        },\n        getters: {\n            /**\n             * Get layout setting from config\n             * @param state\n             * @returns {(function(*): (*))|*}\n             */\n            getLayout: (state) => (layout) => {\n                if (state && state.config && state.config.layouts) {\n                    return state.config.layouts[layout];\n                }\n                return undefined;\n            },\n            getConfigItemById: (state, getters) => (id, type) => {\n                switch (type) {\n                    case 'spFeature':\n                        return getters.getFeature(id);\n                    case 'sFeature':\n                        return getters.getServiceFeature(id);\n                    case 'accommodationType':\n                        return getters.getAccommodationType(id);\n                }\n                return undefined;\n            },\n            /**\n             * match features against featureList in settings\n             * @param state\n             * @param getters\n             * @returns {(function(*, *, *): (*[]))|*} list of strings\n             */\n            matchFeatureList: (state, getters) => (featureList, features, max, forService) => {\n                const fl = state && state.config && state.config.featureLists && state.config.featureLists[featureList];\n                const list = [];\n                const flIsArray = Array.isArray(fl); // is it an array?\n                if (fl && features) {\n                    for (const idx in fl) {\n                        const feature = flIsArray ? fl[idx] : idx;\n                        if (features.includes(feature)) {\n                            if (flIsArray) {\n                                // in case of array\n                                // get entry from feature list - either for service provider or for service\n                                const f = forService ? getters.getServiceFeature(feature) : getters.getFeature(feature);\n                                if (f) {\n                                    list.push(f.label);\n                                    if (max > 0 && list.length >= max) {\n                                        return list;\n                                    }\n                                }\n                            } else {\n                                // in case of object -> take value of this key and add it\n                                list.push(fl[feature]);\n                                if (max > 0 && list.length >= max) {\n                                    return list;\n                                }\n                            }\n                        }\n                    }\n                }\n                return list;\n            },\n            matchPartnerStateList: (state) => (partnerStateList, partnerState) => {\n                return state?.config?.partnerStateLists?.[partnerStateList]?.[partnerState];\n            },\n            getClassificationFromIdList: (state, getters) => (ids) => {\n                return getters.getClassification(ids.split(',').shift());\n            },\n            /**\n             * get single classification\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getClassification: (state) => (id) => {\n                if (state && state.config && state.config.classifications) {\n                    return state.config.classifications[id];\n                }\n            },\n            /**\n             * get single service provider feature\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getFeature: (state, getters) => (id) => {\n                return getters.getConfigEntry(id, 'features');\n            },\n            /**\n             * get single service feature\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getServiceFeature: (state, getters) => (id) => {\n                return getters.getConfigEntry(id, 'serviceFeatures');\n            },\n            /**\n             * get single accommodation type\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getAccommodationType: (state, getters) => (id) => {\n                const label = getters.getConfigEntry(id, 'accommodationTypes');\n                return label ? { label: label } : undefined;\n            },\n            /**\n             * get single toruistic type\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getTouristicType: (state, getters) => (id) => {\n                const label = getters.getConfigEntry(id, 'touristicTypes');\n                return label ? { label: label } : undefined;\n            },\n            getConfigEntry: (state) => (id, part) => {\n                if (state && state.config && state.config[part]) {\n                    return state.config[part][id];\n                }\n            },\n            /**\n             * get label from config\n             * @param state\n             * @returns {(function(*): (*|undefined))|*}\n             */\n            getLabel: (state) => (id) => {\n                if (state && state.config && state.config.labels) {\n                    return state.config.labels[id];\n                }\n            },\n            matchFeatureIcons: (state, getters) => (iconListName, features, max) => {\n                const iconList = state && state.config && state.config.iconsLists && state.config.iconsLists[iconListName];\n                const list = [];\n                const usedId = {};\n                if (iconList && features) {\n                    for (const featureId of Object.keys(iconList)) {\n                        if (features.indexOf(featureId) > -1) {\n                            // get entry, or - in case of a mapped entry - original one\n                            const id = iconList[featureId].map ? iconList[featureId].map : featureId;\n                            // already added (in case of multiple playgrounds, etc.)\n                            if (usedId[id]) continue;\n\n                            if (!iconList[id].label) {\n                                const f = getters.getFeature(id);\n                                const n = {...iconList[id]};\n                                n.label = f.label ? f.label : id;\n                                list.push(n);\n                            } else {\n                                list.push(iconList[id]);\n                            }\n\n                            if (max > 0 && list.length > max) {\n                                return list;\n                            }\n\n                            // flag as used\n                            usedId[id] = true;\n                        }\n                    }\n                }\n\n                return list;\n            },\n\n            /**\n             * Match features defined in features with feature list, but return objects from config feature list (with image references, etc.)\n             * @param state\n             * @return {function(*, *, *): *[]}\n             */\n            matchServiceProviderFeatures: (state) => (featureList, features, max) => {\n                // feature list to match\n                const fl = state && state.config && state.config.featureLists && state.config.featureLists[featureList];\n                const list = [];\n                if (fl && features && state.config.featureList) {\n                    for (const featureGroup of Object.keys(fl)) {\n                        // feature group containing objects\n                        const fg = state.config.featureList.find(fGroup => fGroup.tomasId === featureGroup);\n                        if (fg) {\n                            if (featureGroup in features) {\n                                for (const feature of Object.keys(fl[featureGroup])) {\n                                    if (features[featureGroup]['groups'][feature]) {\n                                        // find feature in feature group\n                                        const f = fg.spFeatures.find(f => f.tomasId === feature);\n                                        if (f) {\n                                            const label = fl[featureGroup][feature] || features[featureGroup]['groups'][feature]['desc'];\n                                            if (label !== f.name) {\n                                                // add clone\n                                                const fc = {...f};\n                                                fc.name = label;\n                                                list.push(fc);\n                                            } else {\n                                                // add reference\n                                                list.push(f);\n                                            }\n                                            if (max > 0 && list.length > max) {\n                                                return list;\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                return list;\n            },\n            /**\n             * create search configuration -> tomasId can be provided to search for vacancies of one service provider only\n             * @param state\n             * @param getters\n             * @return {function(*=): {}}\n             */\n            getSearchConfig: (state, getters) => (tomasId = null) => {\n                const searchConfig = {};\n\n                if (state) {\n                    // we will just need tomas id\n                    if (tomasId) {\n                        searchConfig['tomasid'] = tomasId;\n                    } else {\n                        // search text and geo\n                        if (state.searchItem && state.searchItem.type && state.searchItem.value) {\n                            searchConfig['search_text'] = state.searchItem.value;\n                            searchConfig['search_text_type'] = state.searchItem.type;\n                        }\n                        if (searchConfig['search_text_type'] === 'geo') {\n                            searchConfig['search_text_lng'] = state.searchItem.lng;\n                            searchConfig['search_text_lat'] = state.searchItem.lat;\n                            searchConfig['radius'] = state.searchRadius;\n                        }\n                        // TODO: additional_search_text\n\n                        // filters\n                        ['spFeature', 'sFeature', 'spClassification', 'sClassification', 'accommodationType', 'touristicType', 'board', 'partnerState'].forEach(function (f) {\n                            if (state[f] && state[f].length) {\n                                for (let i = 0; i < state[f].length; i++) {\n                                    searchConfig[f + '[' + i + ']'] = state[f][i];\n                                }\n                            }\n                        });\n\n                        // favorites?\n                        if (state.filterFavorites) {\n                            if (state.favorites && state.favorites.length) {\n                                for (let i = 0; i < state.favorites.length; i++) {\n                                    searchConfig['tomasid[' + i + ']'] = state.favorites[i];\n                                }\n                            } else {\n                                // dummy search - nonexisting feature\n                                searchConfig['spFeature[0]'] = 'GER10020060142687003';\n                            }\n                        }\n\n                        // sorting\n                        const sort = state.sort && state.sort !== '' && state.sort;\n                        searchConfig['sort'] = (sort || sort === 0) ? sort : getters.getDefaultSorting();\n                        if (state.sortByFeature) {\n                            searchConfig['sortByFeature'] = state.sortByFeature;\n                        }\n\n                        // settings generally set by teaser\n                        if (state.bookable || state.bookableOnly) {\n                            searchConfig['bookable'] = '1';\n                        }\n                        if (state.entriesPerPage) {\n                            searchConfig['entries_per_page'] = state.entriesPerPage;\n                        }\n                        if (state.teaserFeaturesFuzzySearch) {\n                            searchConfig['teaserFeaturesFuzzySearch'] = state.teaserFeaturesFuzzySearch;\n                        }\n                        if (state.fulltextSearch) {\n                            searchConfig['fulltextSearch'] = state.fulltextSearch;\n                            searchConfig['fulltextSearchMode'] = state.fulltextSearchMode;\n                        }\n                        if (state.fixedTomasIds && state.fixedTomasIds.length && !searchConfig['tomasid[0]']) {\n                            for (let i = 0; i < state.fixedTomasIds.length; i++) {\n                                searchConfig['tomasid[' + i + ']'] = state.fixedTomasIds[i];\n                            }\n                        }\n                    }\n\n                    // date aka vacancy search\n                    if (state.searchDate && state.searchDate.start && state.searchDate.end) {\n                        searchConfig['book_from_formated'] = state.searchDate.start.getDate() + '.' + (state.searchDate.start.getMonth() + 1) + '.' + state.searchDate.start.getFullYear();\n                        searchConfig['book_to_formated'] = state.searchDate.end.getDate() + '.' + (state.searchDate.end.getMonth() + 1) + '.' + state.searchDate.end.getFullYear();\n\n                        // add known tomas session\n                        if (state.session) {\n                            searchConfig['session_id'] = state.session;\n                        }\n                    }\n\n                    // occupations\n                    if (state.searchAccommodation && state.searchAccommodation.length) {\n                        let adults = 0;\n                        let children = 0;\n\n                        if (state.searchAccommodation.length > 1) {\n                            for (let i = 0; i < state.searchAccommodation.length; i++) {\n                                const baseKey = 'occupation[' + i + ']';\n                                searchConfig[baseKey + '[active]'] = '1';\n                                searchConfig[baseKey + '[adults]'] = state.searchAccommodation[i].adults;\n                                searchConfig[baseKey + '[children]'] = state.searchAccommodation[i].children;\n\n                                if (state.searchAccommodation[i].childAges && state.searchAccommodation[i].childAges.length) {\n                                    for (let j = 0; j < state.searchAccommodation[i].childAges.length; j++) {\n                                        searchConfig[baseKey + '[childAge][' + (j + 1) + ']'] = state.searchAccommodation[i].childAges[j];\n                                    }\n                                }\n\n                                adults += state.searchAccommodation[i].adults;\n                                children += state.searchAccommodation[i].children;\n                            }\n                        } else {\n                            adults = state.searchAccommodation[0].adults;\n                            children = state.searchAccommodation[0].children;\n\n                            if (state.searchAccommodation[0].childAges && state.searchAccommodation[0].childAges.length) {\n                                for (let j = 0; j < state.searchAccommodation[0].childAges.length; j++) {\n                                    searchConfig['child' + (j + 1)] = state.searchAccommodation[0].childAges[j];\n                                }\n                            }\n                        }\n\n                        searchConfig['adults'] = adults;\n                        searchConfig['children'] = children;\n                        // searchConfig['units'] = state.searchAccommodation.length;\n                    }\n                }\n                return searchConfig;\n            },\n            getDistance: (state) => (lat, lng) => {\n                if (state && lat && lng && state.searchItem && state.searchItem.type === 'geo' && state.searchItem.lng && state.searchItem.lat) {\n                    const dLat = (lat - state.searchItem.lat) * Math.PI / 180;\n                    const dLng = (lng - state.searchItem.lng) * Math.PI / 180;\n                    const lat1 = state.searchItem.lat * Math.PI / 180;\n                    const lat2 = lat * Math.PI / 180;\n\n                    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n                        Math.sin(dLng / 2) * Math.sin(dLng / 2) * Math.cos(lat1) * Math.cos(lat2);\n                    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n                    const distance = 6371 /* km */ * c;\n                    if (distance < 1) { // round to 10m\n                        return Math.round(distance * 100) / 100;\n                    }\n\n                    return Math.round(distance);\n                }\n                return 0;\n            },\n            /**\n             * get sorting entries of current search mode\n             * @param state\n             * @return {(function(): (*[]|[]))|*}\n             */\n            getSortings: (state) => () => {\n                if (state && state.config && state.config.sorting) {\n                    const rawSorting = (state.searchDate && state.config.sorting.vacancy) ||\n                        state.config.sorting.default;\n                    if (rawSorting && rawSorting.types && rawSorting.labels) {\n                        const sorting = [];\n                        for (let key of rawSorting.types.split(',')) {\n                            key = key.trim();\n                            sorting.push({value: key, text: rawSorting.labels[key] || key});\n                        }\n                        return sorting;\n                    }\n                }\n                return [];\n            },\n            getDefaultSorting: (state) => () => {\n                if (state && state.config && state.config.sorting) {\n                    // geo sort?\n                    if (state.searchItem && state.searchItem.type === 'geo') {\n                        return '10';\n                    }\n\n                    return (state.searchDate && state.config.sorting.vacancy && state.config.sorting.vacancy.default)\n                        || (state.config.sorting.default && state.config.sorting.default.default) || '0';\n                }\n                return '0';\n            },\n            getFacetById: (state) => (ids) => {\n                return state.facets[ids] || 0;\n            }\n        },\n        modules: {\n            basket,\n            log\n        }\n    });\n}\n\n","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","/**\n * Translates the list format produced by css-loader into something\n * easier to manipulate.\n */\nexport default function listToStyles (parentId, list) {\n  var styles = []\n  var newStyles = {}\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i]\n    var id = item[0]\n    var css = item[1]\n    var media = item[2]\n    var sourceMap = item[3]\n    var part = {\n      id: parentId + ':' + i,\n      css: css,\n      media: media,\n      sourceMap: sourceMap\n    }\n    if (!newStyles[id]) {\n      styles.push(newStyles[id] = { id: id, parts: [part] })\n    } else {\n      newStyles[id].parts.push(part)\n    }\n  }\n  return styles\n}\n","/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n  Modified by Evan You @yyx990803\n*/\n\nimport listToStyles from './listToStyles'\n\nvar hasDocument = typeof document !== 'undefined'\n\nif (typeof DEBUG !== 'undefined' && DEBUG) {\n  if (!hasDocument) {\n    throw new Error(\n    'vue-style-loader cannot be used in a non-browser environment. ' +\n    \"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.\"\n  ) }\n}\n\n/*\ntype StyleObject = {\n  id: number;\n  parts: Array<StyleObjectPart>\n}\n\ntype StyleObjectPart = {\n  css: string;\n  media: string;\n  sourceMap: ?string\n}\n*/\n\nvar stylesInDom = {/*\n  [id: number]: {\n    id: number,\n    refs: number,\n    parts: Array<(obj?: StyleObjectPart) => void>\n  }\n*/}\n\nvar head = hasDocument && (document.head || document.getElementsByTagName('head')[0])\nvar singletonElement = null\nvar singletonCounter = 0\nvar isProduction = false\nvar noop = function () {}\nvar options = null\nvar ssrIdKey = 'data-vue-ssr-id'\n\n// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>\n// tags it will allow on a page\nvar isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase())\n\nexport default function addStylesClient (parentId, list, _isProduction, _options) {\n  isProduction = _isProduction\n\n  options = _options || {}\n\n  var styles = listToStyles(parentId, list)\n  addStylesToDom(styles)\n\n  return function update (newList) {\n    var mayRemove = []\n    for (var i = 0; i < styles.length; i++) {\n      var item = styles[i]\n      var domStyle = stylesInDom[item.id]\n      domStyle.refs--\n      mayRemove.push(domStyle)\n    }\n    if (newList) {\n      styles = listToStyles(parentId, newList)\n      addStylesToDom(styles)\n    } else {\n      styles = []\n    }\n    for (var i = 0; i < mayRemove.length; i++) {\n      var domStyle = mayRemove[i]\n      if (domStyle.refs === 0) {\n        for (var j = 0; j < domStyle.parts.length; j++) {\n          domStyle.parts[j]()\n        }\n        delete stylesInDom[domStyle.id]\n      }\n    }\n  }\n}\n\nfunction addStylesToDom (styles /* Array<StyleObject> */) {\n  for (var i = 0; i < styles.length; i++) {\n    var item = styles[i]\n    var domStyle = stylesInDom[item.id]\n    if (domStyle) {\n      domStyle.refs++\n      for (var j = 0; j < domStyle.parts.length; j++) {\n        domStyle.parts[j](item.parts[j])\n      }\n      for (; j < item.parts.length; j++) {\n        domStyle.parts.push(addStyle(item.parts[j]))\n      }\n      if (domStyle.parts.length > item.parts.length) {\n        domStyle.parts.length = item.parts.length\n      }\n    } else {\n      var parts = []\n      for (var j = 0; j < item.parts.length; j++) {\n        parts.push(addStyle(item.parts[j]))\n      }\n      stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }\n    }\n  }\n}\n\nfunction createStyleElement () {\n  var styleElement = document.createElement('style')\n  styleElement.type = 'text/css'\n  head.appendChild(styleElement)\n  return styleElement\n}\n\nfunction addStyle (obj /* StyleObjectPart */) {\n  var update, remove\n  var styleElement = document.querySelector('style[' + ssrIdKey + '~=\"' + obj.id + '\"]')\n\n  if (styleElement) {\n    if (isProduction) {\n      // has SSR styles and in production mode.\n      // simply do nothing.\n      return noop\n    } else {\n      // has SSR styles but in dev mode.\n      // for some reason Chrome can't handle source map in server-rendered\n      // style tags - source maps in <style> only works if the style tag is\n      // created and inserted dynamically. So we remove the server rendered\n      // styles and inject new ones.\n      styleElement.parentNode.removeChild(styleElement)\n    }\n  }\n\n  if (isOldIE) {\n    // use singleton mode for IE9.\n    var styleIndex = singletonCounter++\n    styleElement = singletonElement || (singletonElement = createStyleElement())\n    update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)\n    remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)\n  } else {\n    // use multi-style-tag mode in all other cases\n    styleElement = createStyleElement()\n    update = applyToTag.bind(null, styleElement)\n    remove = function () {\n      styleElement.parentNode.removeChild(styleElement)\n    }\n  }\n\n  update(obj)\n\n  return function updateStyle (newObj /* StyleObjectPart */) {\n    if (newObj) {\n      if (newObj.css === obj.css &&\n          newObj.media === obj.media &&\n          newObj.sourceMap === obj.sourceMap) {\n        return\n      }\n      update(obj = newObj)\n    } else {\n      remove()\n    }\n  }\n}\n\nvar replaceText = (function () {\n  var textStore = []\n\n  return function (index, replacement) {\n    textStore[index] = replacement\n    return textStore.filter(Boolean).join('\\n')\n  }\n})()\n\nfunction applyToSingletonTag (styleElement, index, remove, obj) {\n  var css = remove ? '' : obj.css\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = replaceText(index, css)\n  } else {\n    var cssNode = document.createTextNode(css)\n    var childNodes = styleElement.childNodes\n    if (childNodes[index]) styleElement.removeChild(childNodes[index])\n    if (childNodes.length) {\n      styleElement.insertBefore(cssNode, childNodes[index])\n    } else {\n      styleElement.appendChild(cssNode)\n    }\n  }\n}\n\nfunction applyToTag (styleElement, obj) {\n  var css = obj.css\n  var media = obj.media\n  var sourceMap = obj.sourceMap\n\n  if (media) {\n    styleElement.setAttribute('media', media)\n  }\n  if (options.ssrId) {\n    styleElement.setAttribute(ssrIdKey, obj.id)\n  }\n\n  if (sourceMap) {\n    // https://developer.chrome.com/devtools/docs/javascript-debugging\n    // this makes source maps inside style tags work properly in Chrome\n    css += '\\n/*# sourceURL=' + sourceMap.sources[0] + ' */'\n    // http://stackoverflow.com/a/26603875\n    css += '\\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'\n  }\n\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild)\n    }\n    styleElement.appendChild(document.createTextNode(css))\n  }\n}\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',[_c('router-view')],1)\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\n  <div>\n    <router-view />\n  </div>\n</template>\n\n<script>\nexport default {\n  name: 'app'\n};\n</script>\n","import mod from \"-!../node_modules/cache-loader/dist/cjs.js??ref--13-0!../node_modules/thread-loader/dist/cjs.js!../node_modules/babel-loader/lib/index.js!../node_modules/cache-loader/dist/cjs.js??ref--1-0!../node_modules/vue-loader/lib/index.js??vue-loader-options!./App.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../node_modules/cache-loader/dist/cjs.js??ref--13-0!../node_modules/thread-loader/dist/cjs.js!../node_modules/babel-loader/lib/index.js!../node_modules/cache-loader/dist/cjs.js??ref--1-0!../node_modules/vue-loader/lib/index.js??vue-loader-options!./App.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./App.vue?vue&type=template&id=dc91653e&\"\nimport script from \"./App.vue?vue&type=script&lang=js&\"\nexport * from \"./App.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","/*!\n  * vue-router v3.6.5\n  * (c) 2022 Evan You\n  * @license MIT\n  */\n/*  */\n\nfunction assert (condition, message) {\n  if (!condition) {\n    throw new Error((\"[vue-router] \" + message))\n  }\n}\n\nfunction warn (condition, message) {\n  if (!condition) {\n    typeof console !== 'undefined' && console.warn((\"[vue-router] \" + message));\n  }\n}\n\nfunction extend (a, b) {\n  for (var key in b) {\n    a[key] = b[key];\n  }\n  return a\n}\n\n/*  */\n\nvar encodeReserveRE = /[!'()*]/g;\nvar encodeReserveReplacer = function (c) { return '%' + c.charCodeAt(0).toString(16); };\nvar commaRE = /%2C/g;\n\n// fixed encodeURIComponent which is more conformant to RFC3986:\n// - escapes [!'()*]\n// - preserve commas\nvar encode = function (str) { return encodeURIComponent(str)\n    .replace(encodeReserveRE, encodeReserveReplacer)\n    .replace(commaRE, ','); };\n\nfunction decode (str) {\n  try {\n    return decodeURIComponent(str)\n  } catch (err) {\n    if (process.env.NODE_ENV !== 'production') {\n      warn(false, (\"Error decoding \\\"\" + str + \"\\\". Leaving it intact.\"));\n    }\n  }\n  return str\n}\n\nfunction resolveQuery (\n  query,\n  extraQuery,\n  _parseQuery\n) {\n  if ( extraQuery === void 0 ) extraQuery = {};\n\n  var parse = _parseQuery || parseQuery;\n  var parsedQuery;\n  try {\n    parsedQuery = parse(query || '');\n  } catch (e) {\n    process.env.NODE_ENV !== 'production' && warn(false, e.message);\n    parsedQuery = {};\n  }\n  for (var key in extraQuery) {\n    var value = extraQuery[key];\n    parsedQuery[key] = Array.isArray(value)\n      ? value.map(castQueryParamValue)\n      : castQueryParamValue(value);\n  }\n  return parsedQuery\n}\n\nvar castQueryParamValue = function (value) { return (value == null || typeof value === 'object' ? value : String(value)); };\n\nfunction parseQuery (query) {\n  var res = {};\n\n  query = query.trim().replace(/^(\\?|#|&)/, '');\n\n  if (!query) {\n    return res\n  }\n\n  query.split('&').forEach(function (param) {\n    var parts = param.replace(/\\+/g, ' ').split('=');\n    var key = decode(parts.shift());\n    var val = parts.length > 0 ? decode(parts.join('=')) : null;\n\n    if (res[key] === undefined) {\n      res[key] = val;\n    } else if (Array.isArray(res[key])) {\n      res[key].push(val);\n    } else {\n      res[key] = [res[key], val];\n    }\n  });\n\n  return res\n}\n\nfunction stringifyQuery (obj) {\n  var res = obj\n    ? Object.keys(obj)\n      .map(function (key) {\n        var val = obj[key];\n\n        if (val === undefined) {\n          return ''\n        }\n\n        if (val === null) {\n          return encode(key)\n        }\n\n        if (Array.isArray(val)) {\n          var result = [];\n          val.forEach(function (val2) {\n            if (val2 === undefined) {\n              return\n            }\n            if (val2 === null) {\n              result.push(encode(key));\n            } else {\n              result.push(encode(key) + '=' + encode(val2));\n            }\n          });\n          return result.join('&')\n        }\n\n        return encode(key) + '=' + encode(val)\n      })\n      .filter(function (x) { return x.length > 0; })\n      .join('&')\n    : null;\n  return res ? (\"?\" + res) : ''\n}\n\n/*  */\n\nvar trailingSlashRE = /\\/?$/;\n\nfunction createRoute (\n  record,\n  location,\n  redirectedFrom,\n  router\n) {\n  var stringifyQuery = router && router.options.stringifyQuery;\n\n  var query = location.query || {};\n  try {\n    query = clone(query);\n  } catch (e) {}\n\n  var route = {\n    name: location.name || (record && record.name),\n    meta: (record && record.meta) || {},\n    path: location.path || '/',\n    hash: location.hash || '',\n    query: query,\n    params: location.params || {},\n    fullPath: getFullPath(location, stringifyQuery),\n    matched: record ? formatMatch(record) : []\n  };\n  if (redirectedFrom) {\n    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery);\n  }\n  return Object.freeze(route)\n}\n\nfunction clone (value) {\n  if (Array.isArray(value)) {\n    return value.map(clone)\n  } else if (value && typeof value === 'object') {\n    var res = {};\n    for (var key in value) {\n      res[key] = clone(value[key]);\n    }\n    return res\n  } else {\n    return value\n  }\n}\n\n// the starting route that represents the initial state\nvar START = createRoute(null, {\n  path: '/'\n});\n\nfunction formatMatch (record) {\n  var res = [];\n  while (record) {\n    res.unshift(record);\n    record = record.parent;\n  }\n  return res\n}\n\nfunction getFullPath (\n  ref,\n  _stringifyQuery\n) {\n  var path = ref.path;\n  var query = ref.query; if ( query === void 0 ) query = {};\n  var hash = ref.hash; if ( hash === void 0 ) hash = '';\n\n  var stringify = _stringifyQuery || stringifyQuery;\n  return (path || '/') + stringify(query) + hash\n}\n\nfunction isSameRoute (a, b, onlyPath) {\n  if (b === START) {\n    return a === b\n  } else if (!b) {\n    return false\n  } else if (a.path && b.path) {\n    return a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') && (onlyPath ||\n      a.hash === b.hash &&\n      isObjectEqual(a.query, b.query))\n  } else if (a.name && b.name) {\n    return (\n      a.name === b.name &&\n      (onlyPath || (\n        a.hash === b.hash &&\n      isObjectEqual(a.query, b.query) &&\n      isObjectEqual(a.params, b.params))\n      )\n    )\n  } else {\n    return false\n  }\n}\n\nfunction isObjectEqual (a, b) {\n  if ( a === void 0 ) a = {};\n  if ( b === void 0 ) b = {};\n\n  // handle null value #1566\n  if (!a || !b) { return a === b }\n  var aKeys = Object.keys(a).sort();\n  var bKeys = Object.keys(b).sort();\n  if (aKeys.length !== bKeys.length) {\n    return false\n  }\n  return aKeys.every(function (key, i) {\n    var aVal = a[key];\n    var bKey = bKeys[i];\n    if (bKey !== key) { return false }\n    var bVal = b[key];\n    // query values can be null and undefined\n    if (aVal == null || bVal == null) { return aVal === bVal }\n    // check nested equality\n    if (typeof aVal === 'object' && typeof bVal === 'object') {\n      return isObjectEqual(aVal, bVal)\n    }\n    return String(aVal) === String(bVal)\n  })\n}\n\nfunction isIncludedRoute (current, target) {\n  return (\n    current.path.replace(trailingSlashRE, '/').indexOf(\n      target.path.replace(trailingSlashRE, '/')\n    ) === 0 &&\n    (!target.hash || current.hash === target.hash) &&\n    queryIncludes(current.query, target.query)\n  )\n}\n\nfunction queryIncludes (current, target) {\n  for (var key in target) {\n    if (!(key in current)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction handleRouteEntered (route) {\n  for (var i = 0; i < route.matched.length; i++) {\n    var record = route.matched[i];\n    for (var name in record.instances) {\n      var instance = record.instances[name];\n      var cbs = record.enteredCbs[name];\n      if (!instance || !cbs) { continue }\n      delete record.enteredCbs[name];\n      for (var i$1 = 0; i$1 < cbs.length; i$1++) {\n        if (!instance._isBeingDestroyed) { cbs[i$1](instance); }\n      }\n    }\n  }\n}\n\nvar View = {\n  name: 'RouterView',\n  functional: true,\n  props: {\n    name: {\n      type: String,\n      default: 'default'\n    }\n  },\n  render: function render (_, ref) {\n    var props = ref.props;\n    var children = ref.children;\n    var parent = ref.parent;\n    var data = ref.data;\n\n    // used by devtools to display a router-view badge\n    data.routerView = true;\n\n    // directly use parent context's createElement() function\n    // so that components rendered by router-view can resolve named slots\n    var h = parent.$createElement;\n    var name = props.name;\n    var route = parent.$route;\n    var cache = parent._routerViewCache || (parent._routerViewCache = {});\n\n    // determine current view depth, also check to see if the tree\n    // has been toggled inactive but kept-alive.\n    var depth = 0;\n    var inactive = false;\n    while (parent && parent._routerRoot !== parent) {\n      var vnodeData = parent.$vnode ? parent.$vnode.data : {};\n      if (vnodeData.routerView) {\n        depth++;\n      }\n      if (vnodeData.keepAlive && parent._directInactive && parent._inactive) {\n        inactive = true;\n      }\n      parent = parent.$parent;\n    }\n    data.routerViewDepth = depth;\n\n    // render previous view if the tree is inactive and kept-alive\n    if (inactive) {\n      var cachedData = cache[name];\n      var cachedComponent = cachedData && cachedData.component;\n      if (cachedComponent) {\n        // #2301\n        // pass props\n        if (cachedData.configProps) {\n          fillPropsinData(cachedComponent, data, cachedData.route, cachedData.configProps);\n        }\n        return h(cachedComponent, data, children)\n      } else {\n        // render previous empty view\n        return h()\n      }\n    }\n\n    var matched = route.matched[depth];\n    var component = matched && matched.components[name];\n\n    // render empty node if no matched route or no config component\n    if (!matched || !component) {\n      cache[name] = null;\n      return h()\n    }\n\n    // cache component\n    cache[name] = { component: component };\n\n    // attach instance registration hook\n    // this will be called in the instance's injected lifecycle hooks\n    data.registerRouteInstance = function (vm, val) {\n      // val could be undefined for unregistration\n      var current = matched.instances[name];\n      if (\n        (val && current !== vm) ||\n        (!val && current === vm)\n      ) {\n        matched.instances[name] = val;\n      }\n    }\n\n    // also register instance in prepatch hook\n    // in case the same component instance is reused across different routes\n    ;(data.hook || (data.hook = {})).prepatch = function (_, vnode) {\n      matched.instances[name] = vnode.componentInstance;\n    };\n\n    // register instance in init hook\n    // in case kept-alive component be actived when routes changed\n    data.hook.init = function (vnode) {\n      if (vnode.data.keepAlive &&\n        vnode.componentInstance &&\n        vnode.componentInstance !== matched.instances[name]\n      ) {\n        matched.instances[name] = vnode.componentInstance;\n      }\n\n      // if the route transition has already been confirmed then we weren't\n      // able to call the cbs during confirmation as the component was not\n      // registered yet, so we call it here.\n      handleRouteEntered(route);\n    };\n\n    var configProps = matched.props && matched.props[name];\n    // save route and configProps in cache\n    if (configProps) {\n      extend(cache[name], {\n        route: route,\n        configProps: configProps\n      });\n      fillPropsinData(component, data, route, configProps);\n    }\n\n    return h(component, data, children)\n  }\n};\n\nfunction fillPropsinData (component, data, route, configProps) {\n  // resolve props\n  var propsToPass = data.props = resolveProps(route, configProps);\n  if (propsToPass) {\n    // clone to prevent mutation\n    propsToPass = data.props = extend({}, propsToPass);\n    // pass non-declared props as attrs\n    var attrs = data.attrs = data.attrs || {};\n    for (var key in propsToPass) {\n      if (!component.props || !(key in component.props)) {\n        attrs[key] = propsToPass[key];\n        delete propsToPass[key];\n      }\n    }\n  }\n}\n\nfunction resolveProps (route, config) {\n  switch (typeof config) {\n    case 'undefined':\n      return\n    case 'object':\n      return config\n    case 'function':\n      return config(route)\n    case 'boolean':\n      return config ? route.params : undefined\n    default:\n      if (process.env.NODE_ENV !== 'production') {\n        warn(\n          false,\n          \"props in \\\"\" + (route.path) + \"\\\" is a \" + (typeof config) + \", \" +\n          \"expecting an object, function or boolean.\"\n        );\n      }\n  }\n}\n\n/*  */\n\nfunction resolvePath (\n  relative,\n  base,\n  append\n) {\n  var firstChar = relative.charAt(0);\n  if (firstChar === '/') {\n    return relative\n  }\n\n  if (firstChar === '?' || firstChar === '#') {\n    return base + relative\n  }\n\n  var stack = base.split('/');\n\n  // remove trailing segment if:\n  // - not appending\n  // - appending to trailing slash (last segment is empty)\n  if (!append || !stack[stack.length - 1]) {\n    stack.pop();\n  }\n\n  // resolve relative path\n  var segments = relative.replace(/^\\//, '').split('/');\n  for (var i = 0; i < segments.length; i++) {\n    var segment = segments[i];\n    if (segment === '..') {\n      stack.pop();\n    } else if (segment !== '.') {\n      stack.push(segment);\n    }\n  }\n\n  // ensure leading slash\n  if (stack[0] !== '') {\n    stack.unshift('');\n  }\n\n  return stack.join('/')\n}\n\nfunction parsePath (path) {\n  var hash = '';\n  var query = '';\n\n  var hashIndex = path.indexOf('#');\n  if (hashIndex >= 0) {\n    hash = path.slice(hashIndex);\n    path = path.slice(0, hashIndex);\n  }\n\n  var queryIndex = path.indexOf('?');\n  if (queryIndex >= 0) {\n    query = path.slice(queryIndex + 1);\n    path = path.slice(0, queryIndex);\n  }\n\n  return {\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\nfunction cleanPath (path) {\n  return path.replace(/\\/(?:\\s*\\/)+/g, '/')\n}\n\nvar isarray = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n\n/**\n * Expose `pathToRegexp`.\n */\nvar pathToRegexp_1 = pathToRegexp;\nvar parse_1 = parse;\nvar compile_1 = compile;\nvar tokensToFunction_1 = tokensToFunction;\nvar tokensToRegExp_1 = tokensToRegExp;\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g');\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = [];\n  var key = 0;\n  var index = 0;\n  var path = '';\n  var defaultDelimiter = options && options.delimiter || '/';\n  var res;\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0];\n    var escaped = res[1];\n    var offset = res.index;\n    path += str.slice(index, offset);\n    index = offset + m.length;\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1];\n      continue\n    }\n\n    var next = str[index];\n    var prefix = res[2];\n    var name = res[3];\n    var capture = res[4];\n    var group = res[5];\n    var modifier = res[6];\n    var asterisk = res[7];\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path);\n      path = '';\n    }\n\n    var partial = prefix != null && next != null && next !== prefix;\n    var repeat = modifier === '+' || modifier === '*';\n    var optional = modifier === '?' || modifier === '*';\n    var delimiter = res[2] || defaultDelimiter;\n    var pattern = capture || group;\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    });\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index);\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path);\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length);\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options));\n    }\n  }\n\n  return function (obj, opts) {\n    var path = '';\n    var data = obj || {};\n    var options = opts || {};\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i];\n\n      if (typeof token === 'string') {\n        path += token;\n\n        continue\n      }\n\n      var value = data[token.name];\n      var segment;\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix;\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j]);\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment;\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value);\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment;\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys;\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g);\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      });\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = [];\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source);\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  var strict = options.strict;\n  var end = options.end !== false;\n  var route = '';\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i];\n\n    if (typeof token === 'string') {\n      route += escapeString(token);\n    } else {\n      var prefix = escapeString(token.prefix);\n      var capture = '(?:' + token.pattern + ')';\n\n      keys.push(token);\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*';\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?';\n        } else {\n          capture = prefix + '(' + capture + ')?';\n        }\n      } else {\n        capture = prefix + '(' + capture + ')';\n      }\n\n      route += capture;\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/');\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';\n  }\n\n  if (end) {\n    route += '$';\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options);\n    keys = [];\n  }\n\n  options = options || {};\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\npathToRegexp_1.parse = parse_1;\npathToRegexp_1.compile = compile_1;\npathToRegexp_1.tokensToFunction = tokensToFunction_1;\npathToRegexp_1.tokensToRegExp = tokensToRegExp_1;\n\n/*  */\n\n// $flow-disable-line\nvar regexpCompileCache = Object.create(null);\n\nfunction fillParams (\n  path,\n  params,\n  routeMsg\n) {\n  params = params || {};\n  try {\n    var filler =\n      regexpCompileCache[path] ||\n      (regexpCompileCache[path] = pathToRegexp_1.compile(path));\n\n    // Fix #2505 resolving asterisk routes { name: 'not-found', params: { pathMatch: '/not-found' }}\n    // and fix #3106 so that you can work with location descriptor object having params.pathMatch equal to empty string\n    if (typeof params.pathMatch === 'string') { params[0] = params.pathMatch; }\n\n    return filler(params, { pretty: true })\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      // Fix #3072 no warn if `pathMatch` is string\n      warn(typeof params.pathMatch === 'string', (\"missing param for \" + routeMsg + \": \" + (e.message)));\n    }\n    return ''\n  } finally {\n    // delete the 0 if it was added\n    delete params[0];\n  }\n}\n\n/*  */\n\nfunction normalizeLocation (\n  raw,\n  current,\n  append,\n  router\n) {\n  var next = typeof raw === 'string' ? { path: raw } : raw;\n  // named target\n  if (next._normalized) {\n    return next\n  } else if (next.name) {\n    next = extend({}, raw);\n    var params = next.params;\n    if (params && typeof params === 'object') {\n      next.params = extend({}, params);\n    }\n    return next\n  }\n\n  // relative params\n  if (!next.path && next.params && current) {\n    next = extend({}, next);\n    next._normalized = true;\n    var params$1 = extend(extend({}, current.params), next.params);\n    if (current.name) {\n      next.name = current.name;\n      next.params = params$1;\n    } else if (current.matched.length) {\n      var rawPath = current.matched[current.matched.length - 1].path;\n      next.path = fillParams(rawPath, params$1, (\"path \" + (current.path)));\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn(false, \"relative params navigation requires a current route.\");\n    }\n    return next\n  }\n\n  var parsedPath = parsePath(next.path || '');\n  var basePath = (current && current.path) || '/';\n  var path = parsedPath.path\n    ? resolvePath(parsedPath.path, basePath, append || next.append)\n    : basePath;\n\n  var query = resolveQuery(\n    parsedPath.query,\n    next.query,\n    router && router.options.parseQuery\n  );\n\n  var hash = next.hash || parsedPath.hash;\n  if (hash && hash.charAt(0) !== '#') {\n    hash = \"#\" + hash;\n  }\n\n  return {\n    _normalized: true,\n    path: path,\n    query: query,\n    hash: hash\n  }\n}\n\n/*  */\n\n// work around weird flow bug\nvar toTypes = [String, Object];\nvar eventTypes = [String, Array];\n\nvar noop = function () {};\n\nvar warnedCustomSlot;\nvar warnedTagProp;\nvar warnedEventProp;\n\nvar Link = {\n  name: 'RouterLink',\n  props: {\n    to: {\n      type: toTypes,\n      required: true\n    },\n    tag: {\n      type: String,\n      default: 'a'\n    },\n    custom: Boolean,\n    exact: Boolean,\n    exactPath: Boolean,\n    append: Boolean,\n    replace: Boolean,\n    activeClass: String,\n    exactActiveClass: String,\n    ariaCurrentValue: {\n      type: String,\n      default: 'page'\n    },\n    event: {\n      type: eventTypes,\n      default: 'click'\n    }\n  },\n  render: function render (h) {\n    var this$1$1 = this;\n\n    var router = this.$router;\n    var current = this.$route;\n    var ref = router.resolve(\n      this.to,\n      current,\n      this.append\n    );\n    var location = ref.location;\n    var route = ref.route;\n    var href = ref.href;\n\n    var classes = {};\n    var globalActiveClass = router.options.linkActiveClass;\n    var globalExactActiveClass = router.options.linkExactActiveClass;\n    // Support global empty active class\n    var activeClassFallback =\n      globalActiveClass == null ? 'router-link-active' : globalActiveClass;\n    var exactActiveClassFallback =\n      globalExactActiveClass == null\n        ? 'router-link-exact-active'\n        : globalExactActiveClass;\n    var activeClass =\n      this.activeClass == null ? activeClassFallback : this.activeClass;\n    var exactActiveClass =\n      this.exactActiveClass == null\n        ? exactActiveClassFallback\n        : this.exactActiveClass;\n\n    var compareTarget = route.redirectedFrom\n      ? createRoute(null, normalizeLocation(route.redirectedFrom), null, router)\n      : route;\n\n    classes[exactActiveClass] = isSameRoute(current, compareTarget, this.exactPath);\n    classes[activeClass] = this.exact || this.exactPath\n      ? classes[exactActiveClass]\n      : isIncludedRoute(current, compareTarget);\n\n    var ariaCurrentValue = classes[exactActiveClass] ? this.ariaCurrentValue : null;\n\n    var handler = function (e) {\n      if (guardEvent(e)) {\n        if (this$1$1.replace) {\n          router.replace(location, noop);\n        } else {\n          router.push(location, noop);\n        }\n      }\n    };\n\n    var on = { click: guardEvent };\n    if (Array.isArray(this.event)) {\n      this.event.forEach(function (e) {\n        on[e] = handler;\n      });\n    } else {\n      on[this.event] = handler;\n    }\n\n    var data = { class: classes };\n\n    var scopedSlot =\n      !this.$scopedSlots.$hasNormal &&\n      this.$scopedSlots.default &&\n      this.$scopedSlots.default({\n        href: href,\n        route: route,\n        navigate: handler,\n        isActive: classes[activeClass],\n        isExactActive: classes[exactActiveClass]\n      });\n\n    if (scopedSlot) {\n      if (process.env.NODE_ENV !== 'production' && !this.custom) {\n        !warnedCustomSlot && warn(false, 'In Vue Router 4, the v-slot API will by default wrap its content with an <a> element. Use the custom prop to remove this warning:\\n<router-link v-slot=\"{ navigate, href }\" custom></router-link>\\n');\n        warnedCustomSlot = true;\n      }\n      if (scopedSlot.length === 1) {\n        return scopedSlot[0]\n      } else if (scopedSlot.length > 1 || !scopedSlot.length) {\n        if (process.env.NODE_ENV !== 'production') {\n          warn(\n            false,\n            (\"<router-link> with to=\\\"\" + (this.to) + \"\\\" is trying to use a scoped slot but it didn't provide exactly one child. Wrapping the content with a span element.\")\n          );\n        }\n        return scopedSlot.length === 0 ? h() : h('span', {}, scopedSlot)\n      }\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if ('tag' in this.$options.propsData && !warnedTagProp) {\n        warn(\n          false,\n          \"<router-link>'s tag prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link.\"\n        );\n        warnedTagProp = true;\n      }\n      if ('event' in this.$options.propsData && !warnedEventProp) {\n        warn(\n          false,\n          \"<router-link>'s event prop is deprecated and has been removed in Vue Router 4. Use the v-slot API to remove this warning: https://next.router.vuejs.org/guide/migration/#removal-of-event-and-tag-props-in-router-link.\"\n        );\n        warnedEventProp = true;\n      }\n    }\n\n    if (this.tag === 'a') {\n      data.on = on;\n      data.attrs = { href: href, 'aria-current': ariaCurrentValue };\n    } else {\n      // find the first <a> child and apply listener and href\n      var a = findAnchor(this.$slots.default);\n      if (a) {\n        // in case the <a> is a static node\n        a.isStatic = false;\n        var aData = (a.data = extend({}, a.data));\n        aData.on = aData.on || {};\n        // transform existing events in both objects into arrays so we can push later\n        for (var event in aData.on) {\n          var handler$1 = aData.on[event];\n          if (event in on) {\n            aData.on[event] = Array.isArray(handler$1) ? handler$1 : [handler$1];\n          }\n        }\n        // append new listeners for router-link\n        for (var event$1 in on) {\n          if (event$1 in aData.on) {\n            // on[event] is always a function\n            aData.on[event$1].push(on[event$1]);\n          } else {\n            aData.on[event$1] = handler;\n          }\n        }\n\n        var aAttrs = (a.data.attrs = extend({}, a.data.attrs));\n        aAttrs.href = href;\n        aAttrs['aria-current'] = ariaCurrentValue;\n      } else {\n        // doesn't have <a> child, apply listener to self\n        data.on = on;\n      }\n    }\n\n    return h(this.tag, data, this.$slots.default)\n  }\n};\n\nfunction guardEvent (e) {\n  // don't redirect with control keys\n  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) { return }\n  // don't redirect when preventDefault called\n  if (e.defaultPrevented) { return }\n  // don't redirect on right click\n  if (e.button !== undefined && e.button !== 0) { return }\n  // don't redirect if `target=\"_blank\"`\n  if (e.currentTarget && e.currentTarget.getAttribute) {\n    var target = e.currentTarget.getAttribute('target');\n    if (/\\b_blank\\b/i.test(target)) { return }\n  }\n  // this may be a Weex event which doesn't have this method\n  if (e.preventDefault) {\n    e.preventDefault();\n  }\n  return true\n}\n\nfunction findAnchor (children) {\n  if (children) {\n    var child;\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      if (child.tag === 'a') {\n        return child\n      }\n      if (child.children && (child = findAnchor(child.children))) {\n        return child\n      }\n    }\n  }\n}\n\nvar _Vue;\n\nfunction install (Vue) {\n  if (install.installed && _Vue === Vue) { return }\n  install.installed = true;\n\n  _Vue = Vue;\n\n  var isDef = function (v) { return v !== undefined; };\n\n  var registerInstance = function (vm, callVal) {\n    var i = vm.$options._parentVnode;\n    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {\n      i(vm, callVal);\n    }\n  };\n\n  Vue.mixin({\n    beforeCreate: function beforeCreate () {\n      if (isDef(this.$options.router)) {\n        this._routerRoot = this;\n        this._router = this.$options.router;\n        this._router.init(this);\n        Vue.util.defineReactive(this, '_route', this._router.history.current);\n      } else {\n        this._routerRoot = (this.$parent && this.$parent._routerRoot) || this;\n      }\n      registerInstance(this, this);\n    },\n    destroyed: function destroyed () {\n      registerInstance(this);\n    }\n  });\n\n  Object.defineProperty(Vue.prototype, '$router', {\n    get: function get () { return this._routerRoot._router }\n  });\n\n  Object.defineProperty(Vue.prototype, '$route', {\n    get: function get () { return this._routerRoot._route }\n  });\n\n  Vue.component('RouterView', View);\n  Vue.component('RouterLink', Link);\n\n  var strats = Vue.config.optionMergeStrategies;\n  // use the same hook merging strategy for route hooks\n  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created;\n}\n\n/*  */\n\nvar inBrowser = typeof window !== 'undefined';\n\n/*  */\n\nfunction createRouteMap (\n  routes,\n  oldPathList,\n  oldPathMap,\n  oldNameMap,\n  parentRoute\n) {\n  // the path list is used to control path matching priority\n  var pathList = oldPathList || [];\n  // $flow-disable-line\n  var pathMap = oldPathMap || Object.create(null);\n  // $flow-disable-line\n  var nameMap = oldNameMap || Object.create(null);\n\n  routes.forEach(function (route) {\n    addRouteRecord(pathList, pathMap, nameMap, route, parentRoute);\n  });\n\n  // ensure wildcard routes are always at the end\n  for (var i = 0, l = pathList.length; i < l; i++) {\n    if (pathList[i] === '*') {\n      pathList.push(pathList.splice(i, 1)[0]);\n      l--;\n      i--;\n    }\n  }\n\n  if (process.env.NODE_ENV === 'development') {\n    // warn if routes do not include leading slashes\n    var found = pathList\n    // check for missing leading slash\n      .filter(function (path) { return path && path.charAt(0) !== '*' && path.charAt(0) !== '/'; });\n\n    if (found.length > 0) {\n      var pathNames = found.map(function (path) { return (\"- \" + path); }).join('\\n');\n      warn(false, (\"Non-nested routes must include a leading slash character. Fix the following routes: \\n\" + pathNames));\n    }\n  }\n\n  return {\n    pathList: pathList,\n    pathMap: pathMap,\n    nameMap: nameMap\n  }\n}\n\nfunction addRouteRecord (\n  pathList,\n  pathMap,\n  nameMap,\n  route,\n  parent,\n  matchAs\n) {\n  var path = route.path;\n  var name = route.name;\n  if (process.env.NODE_ENV !== 'production') {\n    assert(path != null, \"\\\"path\\\" is required in a route configuration.\");\n    assert(\n      typeof route.component !== 'string',\n      \"route config \\\"component\\\" for path: \" + (String(\n        path || name\n      )) + \" cannot be a \" + \"string id. Use an actual component instead.\"\n    );\n\n    warn(\n      // eslint-disable-next-line no-control-regex\n      !/[^\\u0000-\\u007F]+/.test(path),\n      \"Route with path \\\"\" + path + \"\\\" contains unencoded characters, make sure \" +\n        \"your path is correctly encoded before passing it to the router. Use \" +\n        \"encodeURI to encode static segments of your path.\"\n    );\n  }\n\n  var pathToRegexpOptions =\n    route.pathToRegexpOptions || {};\n  var normalizedPath = normalizePath(path, parent, pathToRegexpOptions.strict);\n\n  if (typeof route.caseSensitive === 'boolean') {\n    pathToRegexpOptions.sensitive = route.caseSensitive;\n  }\n\n  var record = {\n    path: normalizedPath,\n    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),\n    components: route.components || { default: route.component },\n    alias: route.alias\n      ? typeof route.alias === 'string'\n        ? [route.alias]\n        : route.alias\n      : [],\n    instances: {},\n    enteredCbs: {},\n    name: name,\n    parent: parent,\n    matchAs: matchAs,\n    redirect: route.redirect,\n    beforeEnter: route.beforeEnter,\n    meta: route.meta || {},\n    props:\n      route.props == null\n        ? {}\n        : route.components\n          ? route.props\n          : { default: route.props }\n  };\n\n  if (route.children) {\n    // Warn if route is named, does not redirect and has a default child route.\n    // If users navigate to this route by name, the default child will\n    // not be rendered (GH Issue #629)\n    if (process.env.NODE_ENV !== 'production') {\n      if (\n        route.name &&\n        !route.redirect &&\n        route.children.some(function (child) { return /^\\/?$/.test(child.path); })\n      ) {\n        warn(\n          false,\n          \"Named Route '\" + (route.name) + \"' has a default child route. \" +\n            \"When navigating to this named route (:to=\\\"{name: '\" + (route.name) + \"'}\\\"), \" +\n            \"the default child route will not be rendered. Remove the name from \" +\n            \"this route and use the name of the default child route for named \" +\n            \"links instead.\"\n        );\n      }\n    }\n    route.children.forEach(function (child) {\n      var childMatchAs = matchAs\n        ? cleanPath((matchAs + \"/\" + (child.path)))\n        : undefined;\n      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs);\n    });\n  }\n\n  if (!pathMap[record.path]) {\n    pathList.push(record.path);\n    pathMap[record.path] = record;\n  }\n\n  if (route.alias !== undefined) {\n    var aliases = Array.isArray(route.alias) ? route.alias : [route.alias];\n    for (var i = 0; i < aliases.length; ++i) {\n      var alias = aliases[i];\n      if (process.env.NODE_ENV !== 'production' && alias === path) {\n        warn(\n          false,\n          (\"Found an alias with the same value as the path: \\\"\" + path + \"\\\". You have to remove that alias. It will be ignored in development.\")\n        );\n        // skip in dev to make it work\n        continue\n      }\n\n      var aliasRoute = {\n        path: alias,\n        children: route.children\n      };\n      addRouteRecord(\n        pathList,\n        pathMap,\n        nameMap,\n        aliasRoute,\n        parent,\n        record.path || '/' // matchAs\n      );\n    }\n  }\n\n  if (name) {\n    if (!nameMap[name]) {\n      nameMap[name] = record;\n    } else if (process.env.NODE_ENV !== 'production' && !matchAs) {\n      warn(\n        false,\n        \"Duplicate named routes definition: \" +\n          \"{ name: \\\"\" + name + \"\\\", path: \\\"\" + (record.path) + \"\\\" }\"\n      );\n    }\n  }\n}\n\nfunction compileRouteRegex (\n  path,\n  pathToRegexpOptions\n) {\n  var regex = pathToRegexp_1(path, [], pathToRegexpOptions);\n  if (process.env.NODE_ENV !== 'production') {\n    var keys = Object.create(null);\n    regex.keys.forEach(function (key) {\n      warn(\n        !keys[key.name],\n        (\"Duplicate param keys in route with path: \\\"\" + path + \"\\\"\")\n      );\n      keys[key.name] = true;\n    });\n  }\n  return regex\n}\n\nfunction normalizePath (\n  path,\n  parent,\n  strict\n) {\n  if (!strict) { path = path.replace(/\\/$/, ''); }\n  if (path[0] === '/') { return path }\n  if (parent == null) { return path }\n  return cleanPath(((parent.path) + \"/\" + path))\n}\n\n/*  */\n\n\n\nfunction createMatcher (\n  routes,\n  router\n) {\n  var ref = createRouteMap(routes);\n  var pathList = ref.pathList;\n  var pathMap = ref.pathMap;\n  var nameMap = ref.nameMap;\n\n  function addRoutes (routes) {\n    createRouteMap(routes, pathList, pathMap, nameMap);\n  }\n\n  function addRoute (parentOrRoute, route) {\n    var parent = (typeof parentOrRoute !== 'object') ? nameMap[parentOrRoute] : undefined;\n    // $flow-disable-line\n    createRouteMap([route || parentOrRoute], pathList, pathMap, nameMap, parent);\n\n    // add aliases of parent\n    if (parent && parent.alias.length) {\n      createRouteMap(\n        // $flow-disable-line route is defined if parent is\n        parent.alias.map(function (alias) { return ({ path: alias, children: [route] }); }),\n        pathList,\n        pathMap,\n        nameMap,\n        parent\n      );\n    }\n  }\n\n  function getRoutes () {\n    return pathList.map(function (path) { return pathMap[path]; })\n  }\n\n  function match (\n    raw,\n    currentRoute,\n    redirectedFrom\n  ) {\n    var location = normalizeLocation(raw, currentRoute, false, router);\n    var name = location.name;\n\n    if (name) {\n      var record = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        warn(record, (\"Route with name '\" + name + \"' does not exist\"));\n      }\n      if (!record) { return _createRoute(null, location) }\n      var paramNames = record.regex.keys\n        .filter(function (key) { return !key.optional; })\n        .map(function (key) { return key.name; });\n\n      if (typeof location.params !== 'object') {\n        location.params = {};\n      }\n\n      if (currentRoute && typeof currentRoute.params === 'object') {\n        for (var key in currentRoute.params) {\n          if (!(key in location.params) && paramNames.indexOf(key) > -1) {\n            location.params[key] = currentRoute.params[key];\n          }\n        }\n      }\n\n      location.path = fillParams(record.path, location.params, (\"named route \\\"\" + name + \"\\\"\"));\n      return _createRoute(record, location, redirectedFrom)\n    } else if (location.path) {\n      location.params = {};\n      for (var i = 0; i < pathList.length; i++) {\n        var path = pathList[i];\n        var record$1 = pathMap[path];\n        if (matchRoute(record$1.regex, location.path, location.params)) {\n          return _createRoute(record$1, location, redirectedFrom)\n        }\n      }\n    }\n    // no match\n    return _createRoute(null, location)\n  }\n\n  function redirect (\n    record,\n    location\n  ) {\n    var originalRedirect = record.redirect;\n    var redirect = typeof originalRedirect === 'function'\n      ? originalRedirect(createRoute(record, location, null, router))\n      : originalRedirect;\n\n    if (typeof redirect === 'string') {\n      redirect = { path: redirect };\n    }\n\n    if (!redirect || typeof redirect !== 'object') {\n      if (process.env.NODE_ENV !== 'production') {\n        warn(\n          false, (\"invalid redirect option: \" + (JSON.stringify(redirect)))\n        );\n      }\n      return _createRoute(null, location)\n    }\n\n    var re = redirect;\n    var name = re.name;\n    var path = re.path;\n    var query = location.query;\n    var hash = location.hash;\n    var params = location.params;\n    query = re.hasOwnProperty('query') ? re.query : query;\n    hash = re.hasOwnProperty('hash') ? re.hash : hash;\n    params = re.hasOwnProperty('params') ? re.params : params;\n\n    if (name) {\n      // resolved named direct\n      var targetRecord = nameMap[name];\n      if (process.env.NODE_ENV !== 'production') {\n        assert(targetRecord, (\"redirect failed: named route \\\"\" + name + \"\\\" not found.\"));\n      }\n      return match({\n        _normalized: true,\n        name: name,\n        query: query,\n        hash: hash,\n        params: params\n      }, undefined, location)\n    } else if (path) {\n      // 1. resolve relative redirect\n      var rawPath = resolveRecordPath(path, record);\n      // 2. resolve params\n      var resolvedPath = fillParams(rawPath, params, (\"redirect route with path \\\"\" + rawPath + \"\\\"\"));\n      // 3. rematch with existing query and hash\n      return match({\n        _normalized: true,\n        path: resolvedPath,\n        query: query,\n        hash: hash\n      }, undefined, location)\n    } else {\n      if (process.env.NODE_ENV !== 'production') {\n        warn(false, (\"invalid redirect option: \" + (JSON.stringify(redirect))));\n      }\n      return _createRoute(null, location)\n    }\n  }\n\n  function alias (\n    record,\n    location,\n    matchAs\n  ) {\n    var aliasedPath = fillParams(matchAs, location.params, (\"aliased route with path \\\"\" + matchAs + \"\\\"\"));\n    var aliasedMatch = match({\n      _normalized: true,\n      path: aliasedPath\n    });\n    if (aliasedMatch) {\n      var matched = aliasedMatch.matched;\n      var aliasedRecord = matched[matched.length - 1];\n      location.params = aliasedMatch.params;\n      return _createRoute(aliasedRecord, location)\n    }\n    return _createRoute(null, location)\n  }\n\n  function _createRoute (\n    record,\n    location,\n    redirectedFrom\n  ) {\n    if (record && record.redirect) {\n      return redirect(record, redirectedFrom || location)\n    }\n    if (record && record.matchAs) {\n      return alias(record, location, record.matchAs)\n    }\n    return createRoute(record, location, redirectedFrom, router)\n  }\n\n  return {\n    match: match,\n    addRoute: addRoute,\n    getRoutes: getRoutes,\n    addRoutes: addRoutes\n  }\n}\n\nfunction matchRoute (\n  regex,\n  path,\n  params\n) {\n  var m = path.match(regex);\n\n  if (!m) {\n    return false\n  } else if (!params) {\n    return true\n  }\n\n  for (var i = 1, len = m.length; i < len; ++i) {\n    var key = regex.keys[i - 1];\n    if (key) {\n      // Fix #1994: using * with props: true generates a param named 0\n      params[key.name || 'pathMatch'] = typeof m[i] === 'string' ? decode(m[i]) : m[i];\n    }\n  }\n\n  return true\n}\n\nfunction resolveRecordPath (path, record) {\n  return resolvePath(path, record.parent ? record.parent.path : '/', true)\n}\n\n/*  */\n\n// use User Timing api (if present) for more accurate key precision\nvar Time =\n  inBrowser && window.performance && window.performance.now\n    ? window.performance\n    : Date;\n\nfunction genStateKey () {\n  return Time.now().toFixed(3)\n}\n\nvar _key = genStateKey();\n\nfunction getStateKey () {\n  return _key\n}\n\nfunction setStateKey (key) {\n  return (_key = key)\n}\n\n/*  */\n\nvar positionStore = Object.create(null);\n\nfunction setupScroll () {\n  // Prevent browser scroll behavior on History popstate\n  if ('scrollRestoration' in window.history) {\n    window.history.scrollRestoration = 'manual';\n  }\n  // Fix for #1585 for Firefox\n  // Fix for #2195 Add optional third attribute to workaround a bug in safari https://bugs.webkit.org/show_bug.cgi?id=182678\n  // Fix for #2774 Support for apps loaded from Windows file shares not mapped to network drives: replaced location.origin with\n  // window.location.protocol + '//' + window.location.host\n  // location.host contains the port and location.hostname doesn't\n  var protocolAndPath = window.location.protocol + '//' + window.location.host;\n  var absolutePath = window.location.href.replace(protocolAndPath, '');\n  // preserve existing history state as it could be overriden by the user\n  var stateCopy = extend({}, window.history.state);\n  stateCopy.key = getStateKey();\n  window.history.replaceState(stateCopy, '', absolutePath);\n  window.addEventListener('popstate', handlePopState);\n  return function () {\n    window.removeEventListener('popstate', handlePopState);\n  }\n}\n\nfunction handleScroll (\n  router,\n  to,\n  from,\n  isPop\n) {\n  if (!router.app) {\n    return\n  }\n\n  var behavior = router.options.scrollBehavior;\n  if (!behavior) {\n    return\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    assert(typeof behavior === 'function', \"scrollBehavior must be a function\");\n  }\n\n  // wait until re-render finishes before scrolling\n  router.app.$nextTick(function () {\n    var position = getScrollPosition();\n    var shouldScroll = behavior.call(\n      router,\n      to,\n      from,\n      isPop ? position : null\n    );\n\n    if (!shouldScroll) {\n      return\n    }\n\n    if (typeof shouldScroll.then === 'function') {\n      shouldScroll\n        .then(function (shouldScroll) {\n          scrollToPosition((shouldScroll), position);\n        })\n        .catch(function (err) {\n          if (process.env.NODE_ENV !== 'production') {\n            assert(false, err.toString());\n          }\n        });\n    } else {\n      scrollToPosition(shouldScroll, position);\n    }\n  });\n}\n\nfunction saveScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    positionStore[key] = {\n      x: window.pageXOffset,\n      y: window.pageYOffset\n    };\n  }\n}\n\nfunction handlePopState (e) {\n  saveScrollPosition();\n  if (e.state && e.state.key) {\n    setStateKey(e.state.key);\n  }\n}\n\nfunction getScrollPosition () {\n  var key = getStateKey();\n  if (key) {\n    return positionStore[key]\n  }\n}\n\nfunction getElementPosition (el, offset) {\n  var docEl = document.documentElement;\n  var docRect = docEl.getBoundingClientRect();\n  var elRect = el.getBoundingClientRect();\n  return {\n    x: elRect.left - docRect.left - offset.x,\n    y: elRect.top - docRect.top - offset.y\n  }\n}\n\nfunction isValidPosition (obj) {\n  return isNumber(obj.x) || isNumber(obj.y)\n}\n\nfunction normalizePosition (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : window.pageXOffset,\n    y: isNumber(obj.y) ? obj.y : window.pageYOffset\n  }\n}\n\nfunction normalizeOffset (obj) {\n  return {\n    x: isNumber(obj.x) ? obj.x : 0,\n    y: isNumber(obj.y) ? obj.y : 0\n  }\n}\n\nfunction isNumber (v) {\n  return typeof v === 'number'\n}\n\nvar hashStartsWithNumberRE = /^#\\d/;\n\nfunction scrollToPosition (shouldScroll, position) {\n  var isObject = typeof shouldScroll === 'object';\n  if (isObject && typeof shouldScroll.selector === 'string') {\n    // getElementById would still fail if the selector contains a more complicated query like #main[data-attr]\n    // but at the same time, it doesn't make much sense to select an element with an id and an extra selector\n    var el = hashStartsWithNumberRE.test(shouldScroll.selector) // $flow-disable-line\n      ? document.getElementById(shouldScroll.selector.slice(1)) // $flow-disable-line\n      : document.querySelector(shouldScroll.selector);\n\n    if (el) {\n      var offset =\n        shouldScroll.offset && typeof shouldScroll.offset === 'object'\n          ? shouldScroll.offset\n          : {};\n      offset = normalizeOffset(offset);\n      position = getElementPosition(el, offset);\n    } else if (isValidPosition(shouldScroll)) {\n      position = normalizePosition(shouldScroll);\n    }\n  } else if (isObject && isValidPosition(shouldScroll)) {\n    position = normalizePosition(shouldScroll);\n  }\n\n  if (position) {\n    // $flow-disable-line\n    if ('scrollBehavior' in document.documentElement.style) {\n      window.scrollTo({\n        left: position.x,\n        top: position.y,\n        // $flow-disable-line\n        behavior: shouldScroll.behavior\n      });\n    } else {\n      window.scrollTo(position.x, position.y);\n    }\n  }\n}\n\n/*  */\n\nvar supportsPushState =\n  inBrowser &&\n  (function () {\n    var ua = window.navigator.userAgent;\n\n    if (\n      (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&\n      ua.indexOf('Mobile Safari') !== -1 &&\n      ua.indexOf('Chrome') === -1 &&\n      ua.indexOf('Windows Phone') === -1\n    ) {\n      return false\n    }\n\n    return window.history && typeof window.history.pushState === 'function'\n  })();\n\nfunction pushState (url, replace) {\n  saveScrollPosition();\n  // try...catch the pushState call to get around Safari\n  // DOM Exception 18 where it limits to 100 pushState calls\n  var history = window.history;\n  try {\n    if (replace) {\n      // preserve existing history state as it could be overriden by the user\n      var stateCopy = extend({}, history.state);\n      stateCopy.key = getStateKey();\n      history.replaceState(stateCopy, '', url);\n    } else {\n      history.pushState({ key: setStateKey(genStateKey()) }, '', url);\n    }\n  } catch (e) {\n    window.location[replace ? 'replace' : 'assign'](url);\n  }\n}\n\nfunction replaceState (url) {\n  pushState(url, true);\n}\n\n// When changing thing, also edit router.d.ts\nvar NavigationFailureType = {\n  redirected: 2,\n  aborted: 4,\n  cancelled: 8,\n  duplicated: 16\n};\n\nfunction createNavigationRedirectedError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.redirected,\n    (\"Redirected when going from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (stringifyRoute(\n      to\n    )) + \"\\\" via a navigation guard.\")\n  )\n}\n\nfunction createNavigationDuplicatedError (from, to) {\n  var error = createRouterError(\n    from,\n    to,\n    NavigationFailureType.duplicated,\n    (\"Avoided redundant navigation to current location: \\\"\" + (from.fullPath) + \"\\\".\")\n  );\n  // backwards compatible with the first introduction of Errors\n  error.name = 'NavigationDuplicated';\n  return error\n}\n\nfunction createNavigationCancelledError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.cancelled,\n    (\"Navigation cancelled from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (to.fullPath) + \"\\\" with a new navigation.\")\n  )\n}\n\nfunction createNavigationAbortedError (from, to) {\n  return createRouterError(\n    from,\n    to,\n    NavigationFailureType.aborted,\n    (\"Navigation aborted from \\\"\" + (from.fullPath) + \"\\\" to \\\"\" + (to.fullPath) + \"\\\" via a navigation guard.\")\n  )\n}\n\nfunction createRouterError (from, to, type, message) {\n  var error = new Error(message);\n  error._isRouter = true;\n  error.from = from;\n  error.to = to;\n  error.type = type;\n\n  return error\n}\n\nvar propertiesToLog = ['params', 'query', 'hash'];\n\nfunction stringifyRoute (to) {\n  if (typeof to === 'string') { return to }\n  if ('path' in to) { return to.path }\n  var location = {};\n  propertiesToLog.forEach(function (key) {\n    if (key in to) { location[key] = to[key]; }\n  });\n  return JSON.stringify(location, null, 2)\n}\n\nfunction isError (err) {\n  return Object.prototype.toString.call(err).indexOf('Error') > -1\n}\n\nfunction isNavigationFailure (err, errorType) {\n  return (\n    isError(err) &&\n    err._isRouter &&\n    (errorType == null || err.type === errorType)\n  )\n}\n\n/*  */\n\nfunction runQueue (queue, fn, cb) {\n  var step = function (index) {\n    if (index >= queue.length) {\n      cb();\n    } else {\n      if (queue[index]) {\n        fn(queue[index], function () {\n          step(index + 1);\n        });\n      } else {\n        step(index + 1);\n      }\n    }\n  };\n  step(0);\n}\n\n/*  */\n\nfunction resolveAsyncComponents (matched) {\n  return function (to, from, next) {\n    var hasAsync = false;\n    var pending = 0;\n    var error = null;\n\n    flatMapComponents(matched, function (def, _, match, key) {\n      // if it's a function and doesn't have cid attached,\n      // assume it's an async component resolve function.\n      // we are not using Vue's default async resolving mechanism because\n      // we want to halt the navigation until the incoming component has been\n      // resolved.\n      if (typeof def === 'function' && def.cid === undefined) {\n        hasAsync = true;\n        pending++;\n\n        var resolve = once(function (resolvedDef) {\n          if (isESModule(resolvedDef)) {\n            resolvedDef = resolvedDef.default;\n          }\n          // save resolved on async factory in case it's used elsewhere\n          def.resolved = typeof resolvedDef === 'function'\n            ? resolvedDef\n            : _Vue.extend(resolvedDef);\n          match.components[key] = resolvedDef;\n          pending--;\n          if (pending <= 0) {\n            next();\n          }\n        });\n\n        var reject = once(function (reason) {\n          var msg = \"Failed to resolve async component \" + key + \": \" + reason;\n          process.env.NODE_ENV !== 'production' && warn(false, msg);\n          if (!error) {\n            error = isError(reason)\n              ? reason\n              : new Error(msg);\n            next(error);\n          }\n        });\n\n        var res;\n        try {\n          res = def(resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n        if (res) {\n          if (typeof res.then === 'function') {\n            res.then(resolve, reject);\n          } else {\n            // new syntax in Vue 2.3\n            var comp = res.component;\n            if (comp && typeof comp.then === 'function') {\n              comp.then(resolve, reject);\n            }\n          }\n        }\n      }\n    });\n\n    if (!hasAsync) { next(); }\n  }\n}\n\nfunction flatMapComponents (\n  matched,\n  fn\n) {\n  return flatten(matched.map(function (m) {\n    return Object.keys(m.components).map(function (key) { return fn(\n      m.components[key],\n      m.instances[key],\n      m, key\n    ); })\n  }))\n}\n\nfunction flatten (arr) {\n  return Array.prototype.concat.apply([], arr)\n}\n\nvar hasSymbol =\n  typeof Symbol === 'function' &&\n  typeof Symbol.toStringTag === 'symbol';\n\nfunction isESModule (obj) {\n  return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module')\n}\n\n// in Webpack 2, require.ensure now also returns a Promise\n// so the resolve/reject functions may get called an extra time\n// if the user uses an arrow function shorthand that happens to\n// return that Promise.\nfunction once (fn) {\n  var called = false;\n  return function () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    if (called) { return }\n    called = true;\n    return fn.apply(this, args)\n  }\n}\n\n/*  */\n\nvar History = function History (router, base) {\n  this.router = router;\n  this.base = normalizeBase(base);\n  // start with a route object that stands for \"nowhere\"\n  this.current = START;\n  this.pending = null;\n  this.ready = false;\n  this.readyCbs = [];\n  this.readyErrorCbs = [];\n  this.errorCbs = [];\n  this.listeners = [];\n};\n\nHistory.prototype.listen = function listen (cb) {\n  this.cb = cb;\n};\n\nHistory.prototype.onReady = function onReady (cb, errorCb) {\n  if (this.ready) {\n    cb();\n  } else {\n    this.readyCbs.push(cb);\n    if (errorCb) {\n      this.readyErrorCbs.push(errorCb);\n    }\n  }\n};\n\nHistory.prototype.onError = function onError (errorCb) {\n  this.errorCbs.push(errorCb);\n};\n\nHistory.prototype.transitionTo = function transitionTo (\n  location,\n  onComplete,\n  onAbort\n) {\n    var this$1$1 = this;\n\n  var route;\n  // catch redirect option https://github.com/vuejs/vue-router/issues/3201\n  try {\n    route = this.router.match(location, this.current);\n  } catch (e) {\n    this.errorCbs.forEach(function (cb) {\n      cb(e);\n    });\n    // Exception should still be thrown\n    throw e\n  }\n  var prev = this.current;\n  this.confirmTransition(\n    route,\n    function () {\n      this$1$1.updateRoute(route);\n      onComplete && onComplete(route);\n      this$1$1.ensureURL();\n      this$1$1.router.afterHooks.forEach(function (hook) {\n        hook && hook(route, prev);\n      });\n\n      // fire ready cbs once\n      if (!this$1$1.ready) {\n        this$1$1.ready = true;\n        this$1$1.readyCbs.forEach(function (cb) {\n          cb(route);\n        });\n      }\n    },\n    function (err) {\n      if (onAbort) {\n        onAbort(err);\n      }\n      if (err && !this$1$1.ready) {\n        // Initial redirection should not mark the history as ready yet\n        // because it's triggered by the redirection instead\n        // https://github.com/vuejs/vue-router/issues/3225\n        // https://github.com/vuejs/vue-router/issues/3331\n        if (!isNavigationFailure(err, NavigationFailureType.redirected) || prev !== START) {\n          this$1$1.ready = true;\n          this$1$1.readyErrorCbs.forEach(function (cb) {\n            cb(err);\n          });\n        }\n      }\n    }\n  );\n};\n\nHistory.prototype.confirmTransition = function confirmTransition (route, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  var current = this.current;\n  this.pending = route;\n  var abort = function (err) {\n    // changed after adding errors with\n    // https://github.com/vuejs/vue-router/pull/3047 before that change,\n    // redirect and aborted navigation would produce an err == null\n    if (!isNavigationFailure(err) && isError(err)) {\n      if (this$1$1.errorCbs.length) {\n        this$1$1.errorCbs.forEach(function (cb) {\n          cb(err);\n        });\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn(false, 'uncaught error during route navigation:');\n        }\n        console.error(err);\n      }\n    }\n    onAbort && onAbort(err);\n  };\n  var lastRouteIndex = route.matched.length - 1;\n  var lastCurrentIndex = current.matched.length - 1;\n  if (\n    isSameRoute(route, current) &&\n    // in the case the route map has been dynamically appended to\n    lastRouteIndex === lastCurrentIndex &&\n    route.matched[lastRouteIndex] === current.matched[lastCurrentIndex]\n  ) {\n    this.ensureURL();\n    if (route.hash) {\n      handleScroll(this.router, current, route, false);\n    }\n    return abort(createNavigationDuplicatedError(current, route))\n  }\n\n  var ref = resolveQueue(\n    this.current.matched,\n    route.matched\n  );\n    var updated = ref.updated;\n    var deactivated = ref.deactivated;\n    var activated = ref.activated;\n\n  var queue = [].concat(\n    // in-component leave guards\n    extractLeaveGuards(deactivated),\n    // global before hooks\n    this.router.beforeHooks,\n    // in-component update hooks\n    extractUpdateHooks(updated),\n    // in-config enter guards\n    activated.map(function (m) { return m.beforeEnter; }),\n    // async components\n    resolveAsyncComponents(activated)\n  );\n\n  var iterator = function (hook, next) {\n    if (this$1$1.pending !== route) {\n      return abort(createNavigationCancelledError(current, route))\n    }\n    try {\n      hook(route, current, function (to) {\n        if (to === false) {\n          // next(false) -> abort navigation, ensure current URL\n          this$1$1.ensureURL(true);\n          abort(createNavigationAbortedError(current, route));\n        } else if (isError(to)) {\n          this$1$1.ensureURL(true);\n          abort(to);\n        } else if (\n          typeof to === 'string' ||\n          (typeof to === 'object' &&\n            (typeof to.path === 'string' || typeof to.name === 'string'))\n        ) {\n          // next('/') or next({ path: '/' }) -> redirect\n          abort(createNavigationRedirectedError(current, route));\n          if (typeof to === 'object' && to.replace) {\n            this$1$1.replace(to);\n          } else {\n            this$1$1.push(to);\n          }\n        } else {\n          // confirm transition and pass on the value\n          next(to);\n        }\n      });\n    } catch (e) {\n      abort(e);\n    }\n  };\n\n  runQueue(queue, iterator, function () {\n    // wait until async components are resolved before\n    // extracting in-component enter guards\n    var enterGuards = extractEnterGuards(activated);\n    var queue = enterGuards.concat(this$1$1.router.resolveHooks);\n    runQueue(queue, iterator, function () {\n      if (this$1$1.pending !== route) {\n        return abort(createNavigationCancelledError(current, route))\n      }\n      this$1$1.pending = null;\n      onComplete(route);\n      if (this$1$1.router.app) {\n        this$1$1.router.app.$nextTick(function () {\n          handleRouteEntered(route);\n        });\n      }\n    });\n  });\n};\n\nHistory.prototype.updateRoute = function updateRoute (route) {\n  this.current = route;\n  this.cb && this.cb(route);\n};\n\nHistory.prototype.setupListeners = function setupListeners () {\n  // Default implementation is empty\n};\n\nHistory.prototype.teardown = function teardown () {\n  // clean up event listeners\n  // https://github.com/vuejs/vue-router/issues/2341\n  this.listeners.forEach(function (cleanupListener) {\n    cleanupListener();\n  });\n  this.listeners = [];\n\n  // reset current history route\n  // https://github.com/vuejs/vue-router/issues/3294\n  this.current = START;\n  this.pending = null;\n};\n\nfunction normalizeBase (base) {\n  if (!base) {\n    if (inBrowser) {\n      // respect <base> tag\n      var baseEl = document.querySelector('base');\n      base = (baseEl && baseEl.getAttribute('href')) || '/';\n      // strip full URL origin\n      base = base.replace(/^https?:\\/\\/[^\\/]+/, '');\n    } else {\n      base = '/';\n    }\n  }\n  // make sure there's the starting slash\n  if (base.charAt(0) !== '/') {\n    base = '/' + base;\n  }\n  // remove trailing slash\n  return base.replace(/\\/$/, '')\n}\n\nfunction resolveQueue (\n  current,\n  next\n) {\n  var i;\n  var max = Math.max(current.length, next.length);\n  for (i = 0; i < max; i++) {\n    if (current[i] !== next[i]) {\n      break\n    }\n  }\n  return {\n    updated: next.slice(0, i),\n    activated: next.slice(i),\n    deactivated: current.slice(i)\n  }\n}\n\nfunction extractGuards (\n  records,\n  name,\n  bind,\n  reverse\n) {\n  var guards = flatMapComponents(records, function (def, instance, match, key) {\n    var guard = extractGuard(def, name);\n    if (guard) {\n      return Array.isArray(guard)\n        ? guard.map(function (guard) { return bind(guard, instance, match, key); })\n        : bind(guard, instance, match, key)\n    }\n  });\n  return flatten(reverse ? guards.reverse() : guards)\n}\n\nfunction extractGuard (\n  def,\n  key\n) {\n  if (typeof def !== 'function') {\n    // extend now so that global mixins are applied.\n    def = _Vue.extend(def);\n  }\n  return def.options[key]\n}\n\nfunction extractLeaveGuards (deactivated) {\n  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)\n}\n\nfunction extractUpdateHooks (updated) {\n  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)\n}\n\nfunction bindGuard (guard, instance) {\n  if (instance) {\n    return function boundRouteGuard () {\n      return guard.apply(instance, arguments)\n    }\n  }\n}\n\nfunction extractEnterGuards (\n  activated\n) {\n  return extractGuards(\n    activated,\n    'beforeRouteEnter',\n    function (guard, _, match, key) {\n      return bindEnterGuard(guard, match, key)\n    }\n  )\n}\n\nfunction bindEnterGuard (\n  guard,\n  match,\n  key\n) {\n  return function routeEnterGuard (to, from, next) {\n    return guard(to, from, function (cb) {\n      if (typeof cb === 'function') {\n        if (!match.enteredCbs[key]) {\n          match.enteredCbs[key] = [];\n        }\n        match.enteredCbs[key].push(cb);\n      }\n      next(cb);\n    })\n  }\n}\n\n/*  */\n\nvar HTML5History = /*@__PURE__*/(function (History) {\n  function HTML5History (router, base) {\n    History.call(this, router, base);\n\n    this._startLocation = getLocation(this.base);\n  }\n\n  if ( History ) HTML5History.__proto__ = History;\n  HTML5History.prototype = Object.create( History && History.prototype );\n  HTML5History.prototype.constructor = HTML5History;\n\n  HTML5History.prototype.setupListeners = function setupListeners () {\n    var this$1$1 = this;\n\n    if (this.listeners.length > 0) {\n      return\n    }\n\n    var router = this.router;\n    var expectScroll = router.options.scrollBehavior;\n    var supportsScroll = supportsPushState && expectScroll;\n\n    if (supportsScroll) {\n      this.listeners.push(setupScroll());\n    }\n\n    var handleRoutingEvent = function () {\n      var current = this$1$1.current;\n\n      // Avoiding first `popstate` event dispatched in some browsers but first\n      // history route not updated since async guard at the same time.\n      var location = getLocation(this$1$1.base);\n      if (this$1$1.current === START && location === this$1$1._startLocation) {\n        return\n      }\n\n      this$1$1.transitionTo(location, function (route) {\n        if (supportsScroll) {\n          handleScroll(router, route, current, true);\n        }\n      });\n    };\n    window.addEventListener('popstate', handleRoutingEvent);\n    this.listeners.push(function () {\n      window.removeEventListener('popstate', handleRoutingEvent);\n    });\n  };\n\n  HTML5History.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HTML5History.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      pushState(cleanPath(this$1$1.base + route.fullPath));\n      handleScroll(this$1$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(location, function (route) {\n      replaceState(cleanPath(this$1$1.base + route.fullPath));\n      handleScroll(this$1$1.router, route, fromRoute, false);\n      onComplete && onComplete(route);\n    }, onAbort);\n  };\n\n  HTML5History.prototype.ensureURL = function ensureURL (push) {\n    if (getLocation(this.base) !== this.current.fullPath) {\n      var current = cleanPath(this.base + this.current.fullPath);\n      push ? pushState(current) : replaceState(current);\n    }\n  };\n\n  HTML5History.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getLocation(this.base)\n  };\n\n  return HTML5History;\n}(History));\n\nfunction getLocation (base) {\n  var path = window.location.pathname;\n  var pathLowerCase = path.toLowerCase();\n  var baseLowerCase = base.toLowerCase();\n  // base=\"/a\" shouldn't turn path=\"/app\" into \"/a/pp\"\n  // https://github.com/vuejs/vue-router/issues/3555\n  // so we ensure the trailing slash in the base\n  if (base && ((pathLowerCase === baseLowerCase) ||\n    (pathLowerCase.indexOf(cleanPath(baseLowerCase + '/')) === 0))) {\n    path = path.slice(base.length);\n  }\n  return (path || '/') + window.location.search + window.location.hash\n}\n\n/*  */\n\nvar HashHistory = /*@__PURE__*/(function (History) {\n  function HashHistory (router, base, fallback) {\n    History.call(this, router, base);\n    // check history fallback deeplinking\n    if (fallback && checkFallback(this.base)) {\n      return\n    }\n    ensureSlash();\n  }\n\n  if ( History ) HashHistory.__proto__ = History;\n  HashHistory.prototype = Object.create( History && History.prototype );\n  HashHistory.prototype.constructor = HashHistory;\n\n  // this is delayed until the app mounts\n  // to avoid the hashchange listener being fired too early\n  HashHistory.prototype.setupListeners = function setupListeners () {\n    var this$1$1 = this;\n\n    if (this.listeners.length > 0) {\n      return\n    }\n\n    var router = this.router;\n    var expectScroll = router.options.scrollBehavior;\n    var supportsScroll = supportsPushState && expectScroll;\n\n    if (supportsScroll) {\n      this.listeners.push(setupScroll());\n    }\n\n    var handleRoutingEvent = function () {\n      var current = this$1$1.current;\n      if (!ensureSlash()) {\n        return\n      }\n      this$1$1.transitionTo(getHash(), function (route) {\n        if (supportsScroll) {\n          handleScroll(this$1$1.router, route, current, true);\n        }\n        if (!supportsPushState) {\n          replaceHash(route.fullPath);\n        }\n      });\n    };\n    var eventType = supportsPushState ? 'popstate' : 'hashchange';\n    window.addEventListener(\n      eventType,\n      handleRoutingEvent\n    );\n    this.listeners.push(function () {\n      window.removeEventListener(eventType, handleRoutingEvent);\n    });\n  };\n\n  HashHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(\n      location,\n      function (route) {\n        pushHash(route.fullPath);\n        handleScroll(this$1$1.router, route, fromRoute, false);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  HashHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    var ref = this;\n    var fromRoute = ref.current;\n    this.transitionTo(\n      location,\n      function (route) {\n        replaceHash(route.fullPath);\n        handleScroll(this$1$1.router, route, fromRoute, false);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  HashHistory.prototype.go = function go (n) {\n    window.history.go(n);\n  };\n\n  HashHistory.prototype.ensureURL = function ensureURL (push) {\n    var current = this.current.fullPath;\n    if (getHash() !== current) {\n      push ? pushHash(current) : replaceHash(current);\n    }\n  };\n\n  HashHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    return getHash()\n  };\n\n  return HashHistory;\n}(History));\n\nfunction checkFallback (base) {\n  var location = getLocation(base);\n  if (!/^\\/#/.test(location)) {\n    window.location.replace(cleanPath(base + '/#' + location));\n    return true\n  }\n}\n\nfunction ensureSlash () {\n  var path = getHash();\n  if (path.charAt(0) === '/') {\n    return true\n  }\n  replaceHash('/' + path);\n  return false\n}\n\nfunction getHash () {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var index = href.indexOf('#');\n  // empty path\n  if (index < 0) { return '' }\n\n  href = href.slice(index + 1);\n\n  return href\n}\n\nfunction getUrl (path) {\n  var href = window.location.href;\n  var i = href.indexOf('#');\n  var base = i >= 0 ? href.slice(0, i) : href;\n  return (base + \"#\" + path)\n}\n\nfunction pushHash (path) {\n  if (supportsPushState) {\n    pushState(getUrl(path));\n  } else {\n    window.location.hash = path;\n  }\n}\n\nfunction replaceHash (path) {\n  if (supportsPushState) {\n    replaceState(getUrl(path));\n  } else {\n    window.location.replace(getUrl(path));\n  }\n}\n\n/*  */\n\nvar AbstractHistory = /*@__PURE__*/(function (History) {\n  function AbstractHistory (router, base) {\n    History.call(this, router, base);\n    this.stack = [];\n    this.index = -1;\n  }\n\n  if ( History ) AbstractHistory.__proto__ = History;\n  AbstractHistory.prototype = Object.create( History && History.prototype );\n  AbstractHistory.prototype.constructor = AbstractHistory;\n\n  AbstractHistory.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    this.transitionTo(\n      location,\n      function (route) {\n        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index + 1).concat(route);\n        this$1$1.index++;\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  AbstractHistory.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n    this.transitionTo(\n      location,\n      function (route) {\n        this$1$1.stack = this$1$1.stack.slice(0, this$1$1.index).concat(route);\n        onComplete && onComplete(route);\n      },\n      onAbort\n    );\n  };\n\n  AbstractHistory.prototype.go = function go (n) {\n    var this$1$1 = this;\n\n    var targetIndex = this.index + n;\n    if (targetIndex < 0 || targetIndex >= this.stack.length) {\n      return\n    }\n    var route = this.stack[targetIndex];\n    this.confirmTransition(\n      route,\n      function () {\n        var prev = this$1$1.current;\n        this$1$1.index = targetIndex;\n        this$1$1.updateRoute(route);\n        this$1$1.router.afterHooks.forEach(function (hook) {\n          hook && hook(route, prev);\n        });\n      },\n      function (err) {\n        if (isNavigationFailure(err, NavigationFailureType.duplicated)) {\n          this$1$1.index = targetIndex;\n        }\n      }\n    );\n  };\n\n  AbstractHistory.prototype.getCurrentLocation = function getCurrentLocation () {\n    var current = this.stack[this.stack.length - 1];\n    return current ? current.fullPath : '/'\n  };\n\n  AbstractHistory.prototype.ensureURL = function ensureURL () {\n    // noop\n  };\n\n  return AbstractHistory;\n}(History));\n\n/*  */\n\n\n\nvar VueRouter = function VueRouter (options) {\n  if ( options === void 0 ) options = {};\n\n  if (process.env.NODE_ENV !== 'production') {\n    warn(this instanceof VueRouter, \"Router must be called with the new operator.\");\n  }\n  this.app = null;\n  this.apps = [];\n  this.options = options;\n  this.beforeHooks = [];\n  this.resolveHooks = [];\n  this.afterHooks = [];\n  this.matcher = createMatcher(options.routes || [], this);\n\n  var mode = options.mode || 'hash';\n  this.fallback =\n    mode === 'history' && !supportsPushState && options.fallback !== false;\n  if (this.fallback) {\n    mode = 'hash';\n  }\n  if (!inBrowser) {\n    mode = 'abstract';\n  }\n  this.mode = mode;\n\n  switch (mode) {\n    case 'history':\n      this.history = new HTML5History(this, options.base);\n      break\n    case 'hash':\n      this.history = new HashHistory(this, options.base, this.fallback);\n      break\n    case 'abstract':\n      this.history = new AbstractHistory(this, options.base);\n      break\n    default:\n      if (process.env.NODE_ENV !== 'production') {\n        assert(false, (\"invalid mode: \" + mode));\n      }\n  }\n};\n\nvar prototypeAccessors = { currentRoute: { configurable: true } };\n\nVueRouter.prototype.match = function match (raw, current, redirectedFrom) {\n  return this.matcher.match(raw, current, redirectedFrom)\n};\n\nprototypeAccessors.currentRoute.get = function () {\n  return this.history && this.history.current\n};\n\nVueRouter.prototype.init = function init (app /* Vue component instance */) {\n    var this$1$1 = this;\n\n  process.env.NODE_ENV !== 'production' &&\n    assert(\n      install.installed,\n      \"not installed. Make sure to call `Vue.use(VueRouter)` \" +\n        \"before creating root instance.\"\n    );\n\n  this.apps.push(app);\n\n  // set up app destroyed handler\n  // https://github.com/vuejs/vue-router/issues/2639\n  app.$once('hook:destroyed', function () {\n    // clean out app from this.apps array once destroyed\n    var index = this$1$1.apps.indexOf(app);\n    if (index > -1) { this$1$1.apps.splice(index, 1); }\n    // ensure we still have a main app or null if no apps\n    // we do not release the router so it can be reused\n    if (this$1$1.app === app) { this$1$1.app = this$1$1.apps[0] || null; }\n\n    if (!this$1$1.app) { this$1$1.history.teardown(); }\n  });\n\n  // main app previously initialized\n  // return as we don't need to set up new history listener\n  if (this.app) {\n    return\n  }\n\n  this.app = app;\n\n  var history = this.history;\n\n  if (history instanceof HTML5History || history instanceof HashHistory) {\n    var handleInitialScroll = function (routeOrError) {\n      var from = history.current;\n      var expectScroll = this$1$1.options.scrollBehavior;\n      var supportsScroll = supportsPushState && expectScroll;\n\n      if (supportsScroll && 'fullPath' in routeOrError) {\n        handleScroll(this$1$1, routeOrError, from, false);\n      }\n    };\n    var setupListeners = function (routeOrError) {\n      history.setupListeners();\n      handleInitialScroll(routeOrError);\n    };\n    history.transitionTo(\n      history.getCurrentLocation(),\n      setupListeners,\n      setupListeners\n    );\n  }\n\n  history.listen(function (route) {\n    this$1$1.apps.forEach(function (app) {\n      app._route = route;\n    });\n  });\n};\n\nVueRouter.prototype.beforeEach = function beforeEach (fn) {\n  return registerHook(this.beforeHooks, fn)\n};\n\nVueRouter.prototype.beforeResolve = function beforeResolve (fn) {\n  return registerHook(this.resolveHooks, fn)\n};\n\nVueRouter.prototype.afterEach = function afterEach (fn) {\n  return registerHook(this.afterHooks, fn)\n};\n\nVueRouter.prototype.onReady = function onReady (cb, errorCb) {\n  this.history.onReady(cb, errorCb);\n};\n\nVueRouter.prototype.onError = function onError (errorCb) {\n  this.history.onError(errorCb);\n};\n\nVueRouter.prototype.push = function push (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  // $flow-disable-line\n  if (!onComplete && !onAbort && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve, reject) {\n      this$1$1.history.push(location, resolve, reject);\n    })\n  } else {\n    this.history.push(location, onComplete, onAbort);\n  }\n};\n\nVueRouter.prototype.replace = function replace (location, onComplete, onAbort) {\n    var this$1$1 = this;\n\n  // $flow-disable-line\n  if (!onComplete && !onAbort && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve, reject) {\n      this$1$1.history.replace(location, resolve, reject);\n    })\n  } else {\n    this.history.replace(location, onComplete, onAbort);\n  }\n};\n\nVueRouter.prototype.go = function go (n) {\n  this.history.go(n);\n};\n\nVueRouter.prototype.back = function back () {\n  this.go(-1);\n};\n\nVueRouter.prototype.forward = function forward () {\n  this.go(1);\n};\n\nVueRouter.prototype.getMatchedComponents = function getMatchedComponents (to) {\n  var route = to\n    ? to.matched\n      ? to\n      : this.resolve(to).route\n    : this.currentRoute;\n  if (!route) {\n    return []\n  }\n  return [].concat.apply(\n    [],\n    route.matched.map(function (m) {\n      return Object.keys(m.components).map(function (key) {\n        return m.components[key]\n      })\n    })\n  )\n};\n\nVueRouter.prototype.resolve = function resolve (\n  to,\n  current,\n  append\n) {\n  current = current || this.history.current;\n  var location = normalizeLocation(to, current, append, this);\n  var route = this.match(location, current);\n  var fullPath = route.redirectedFrom || route.fullPath;\n  var base = this.history.base;\n  var href = createHref(base, fullPath, this.mode);\n  return {\n    location: location,\n    route: route,\n    href: href,\n    // for backwards compat\n    normalizedTo: location,\n    resolved: route\n  }\n};\n\nVueRouter.prototype.getRoutes = function getRoutes () {\n  return this.matcher.getRoutes()\n};\n\nVueRouter.prototype.addRoute = function addRoute (parentOrRoute, route) {\n  this.matcher.addRoute(parentOrRoute, route);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nVueRouter.prototype.addRoutes = function addRoutes (routes) {\n  if (process.env.NODE_ENV !== 'production') {\n    warn(false, 'router.addRoutes() is deprecated and has been removed in Vue Router 4. Use router.addRoute() instead.');\n  }\n  this.matcher.addRoutes(routes);\n  if (this.history.current !== START) {\n    this.history.transitionTo(this.history.getCurrentLocation());\n  }\n};\n\nObject.defineProperties( VueRouter.prototype, prototypeAccessors );\n\nvar VueRouter$1 = VueRouter;\n\nfunction registerHook (list, fn) {\n  list.push(fn);\n  return function () {\n    var i = list.indexOf(fn);\n    if (i > -1) { list.splice(i, 1); }\n  }\n}\n\nfunction createHref (base, fullPath, mode) {\n  var path = mode === 'hash' ? '#' + fullPath : fullPath;\n  return base ? cleanPath(base + '/' + path) : path\n}\n\n// We cannot remove this as it would be a breaking change\nVueRouter.install = install;\nVueRouter.version = '3.6.5';\nVueRouter.isNavigationFailure = isNavigationFailure;\nVueRouter.NavigationFailureType = NavigationFailureType;\nVueRouter.START_LOCATION = START;\n\nif (inBrowser && window.Vue) {\n  window.Vue.use(VueRouter);\n}\n\nvar version = '3.6.5';\n\nexport { NavigationFailureType, Link as RouterLink, View as RouterView, START as START_LOCATION, VueRouter$1 as default, isNavigationFailure, version };\n","import Vue from 'vue';\nimport VueRouter from 'vue-router';\nVue.use(VueRouter);\n\nexport default function createRouter (props = {}) {\n  const routes = [\n    {\n      path: '/',\n      component: () => import(/* webpackChunkName: \"routed-main\" */ '../Search.vue'),\n      props: props\n    },\n    {\n      path: '/list',\n      component: () => import(/* webpackChunkName: \"routed-list\" */ '../List.vue'),\n      props: props\n    },\n    {\n      path: '/teaser',\n      component: () => import(/* webpackChunkName: \"routed-teaser\" */ '../Teaser.vue'),\n      props: props\n    },\n    {\n      path: '/book',\n      component: () => import(/* webpackChunkName: \"routed-book\" */ '../Book.vue'),\n      props: props\n    },\n    {\n      path: '/:nameOrId',\n      component: () => import(/* webpackChunkName: \"routed-main\" */ '../Detail.vue'),\n      props: (route) => ({\n        id: props.id,\n        nameOrId: route.params.nameOrId\n      })\n    },\n  ];\n\n  const router = new VueRouter({\n    mode: 'history',\n    base: process.env.BASE_URL,\n    routes\n  });\n  //add optional clear storage get-param to all routes ( f.e. http://localhost:8081/teaser?apiUrl=blabla&clear=1 )\n  router.beforeEach((to, from, next) => {\n    if(to.query.clear) {\n      localStorage.clear();\n      sessionStorage.clear();\n      delete to.query.clear;\n      console.log(\"cleared local storage + session storage\");\n      next(to); //redirect to same page without &clear=1\n    }\n    else\n      next();\n  });\n  return router;\n}\n","import Vue from 'vue';\nimport App from './App.vue';\nimport createRouter from './router';\nimport appStore from './store';\nimport Vuetify from 'vuetify/lib/framework';\nimport de from 'vuetify/es5/locale/de';\nimport en from 'vuetify/es5/locale/en';\nimport {getFromLocalStorage} from \"@/store/local-storage\";\nimport {getApiUrl} from \"@/lib/getApiUrl\";\n\nVue.config.productionTip = false;\nVue.use(Vuetify);\n\n// loading wrapper for each instance\nconst $elements = document.getElementsByClassName('eobuchung-widget');\nconst savedElements = []; // save elements to array, since array will otherwise be reduce while looping\nfor (let i = 0; i < $elements.length; i++) {\n  savedElements.push($elements[i]);\n}\n\nfor (let i = 0; i < savedElements.length; i++) {\n  const $el = savedElements[i];\n\n  const locale = ($el.attributes['data-locale'] && $el.attributes['data-locale'].value) || 'de-de';\n\n  // build vuetify instance using certain colors\n  const opts = {\n    icons: {\n      iconfont: 'mdiSvg'\n    },\n    theme: {\n      options: {\n        customProperties: true\n      },\n      themes: {\n        light: {\n          primary: ($el.attributes['data-color-primary'] && $el.attributes['data-color-primary'].value) || '#f9af00',\n          secondary: ($el.attributes['data-color-secondary'] && $el.attributes['data-color-secondary'].value) || '#9e9e9e',\n          accent: ($el.attributes['data-color-accent'] && $el.attributes['data-color-accent'].value) || '#97bd0f',\n          error: ($el.attributes['data-color-error'] && $el.attributes['data-color-error'].value) || '#c55c52',\n          info: ($el.attributes['data-color-info'] && $el.attributes['data-color-info'].value) || '#314d57',\n          success: ($el.attributes['data-color-success'] && $el.attributes['data-color-success'].value) || '#97bd0f',\n          warning: ($el.attributes['data-color-warning'] && $el.attributes['data-color-warning'].value) || '#e2d7af'\n        }\n      }\n    },\n    lang: {\n      locales: { de, en },\n      current: locale\n    }\n  };\n  const vuetify = new Vuetify(opts);\n\n  // do we have initial data?\n  const data = $el.querySelector('.eobuchung-app-widget-initial-data');\n  const settings = $el.querySelector('.eobuchung-app-widget-settings');\n\n  // set as constants to avoid overwriting of settings below\n  const id = $el.attributes.id && $el.attributes.id.value;\n  const namespace = ($el.attributes['data-namespace'] && $el.attributes['data-namespace'].value) || 'eobuchung';\n  // create store\n  const store = appStore(namespace, {\n    locale,\n    apiUrl: getApiUrl() || $el.attributes?.['data-api-url']?.value,\n    apiKey: $el.attributes['data-api-key'] && $el.attributes['data-api-key'].value,\n    detailUri: $el.attributes['data-detail-uri'] && $el.attributes['data-detail-uri'].value || '/xxxSLUGxxx',\n    listUri: $el.attributes['data-list-uri'] && $el.attributes['data-list-uri'].value || '/list',\n    bookUri: $el.attributes['data-book-uri'] && $el.attributes['data-book-uri'].value || '/book',\n    logUri: $el.attributes['data-log-uri'] && $el.attributes['data-log-uri'].value || null,\n    logCampaign: $el.attributes['data-log-campaign'] && $el.attributes['data-log-campaign'].value || null,\n    spFeature: ($el.attributes['data-sp-features'] && $el.attributes['data-sp-features'].value) || null,\n    hiddenFilterGroups: ($el.attributes['data-hide-filter-groups'] && $el.attributes['data-hide-filter-groups'].value) || null,\n    textColor: ($el.attributes['data-color-text'] && $el.attributes['data-color-text'].value) || '#333',\n    mapPinFillColor: ($el.attributes['data-map-pin-fill-color'] && $el.attributes['data-map-pin-fill-color'].value) || '#257eca',\n    mapPinStrokeColor: ($el.attributes['data-map-pin-stroke-color'] && $el.attributes['data-map-pin-stroke-color'].value) || '#2d5069',\n    mapPinFillColorActive: ($el.attributes['data-map-pin-fill-color-active'] && $el.attributes['data-map-pin-fill-color-active'].value) || '#c55c52',\n    mapPinStrokeColorActive: ($el.attributes['data-map-pin-stroke-color-active'] && $el.attributes['data-map-pin-stroke-color-active'].value) || '#5d332f',\n    mapRadiusColor: ($el.attributes['data-map-radius-color'] && $el.attributes['data-map-radius-color'].value) || '#f00',\n    termsAndConditionsLink: ($el.attributes['data-terms-link'] && $el.attributes['data-terms-link'].value) || 'https://www.blauergockel.de/fileadmin/user_upload/agb.pdf',\n    privacyLink: ($el.attributes['data-privacy-link'] && $el.attributes['data-privacy-link'].value) || 'https://www.blauergockel.de/datenschutz/',\n    offSetTop: $el.attributes['data-offset-top'] && $el.attributes['data-offset-top'].value || 0,\n    offSetTopBar: $el.attributes['data-offset-top-bar'] && $el.attributes['data-offset-top-bar'].value || 0,\n    offSetTopMobile: $el.attributes['data-offset-top-mobile'] && $el.attributes['data-offset-top-mobile'].value || 0,\n    offSetTopBarMobile: $el.attributes['data-offset-top-bar-mobile'] && $el.attributes['data-offset-top-bar-mobile'].value || 0,\n    offSetTopAffix: $el.attributes['data-offset-top-affix'] && $el.attributes['data-offset-top-affix'].value || 0,\n    entriesPerPage: ($el.attributes['data-entries-per-page'] && $el.attributes['data-entries-per-page'].value) || 9,\n  });\n\n  // fetch possible get or post parameters - in live this makes only sense in list.js\n  store.commit('updateSearchFromParameters');\n\n  // create router\n  const router = createRouter({\n    id: store.state.id,\n    apiUrl: store.state.apiUrl,\n    apiKey: store.state.apiKey,\n    detailUri: store.state.detailUri,\n    listUri: store.state.listUri,\n    locale,\n    textColor: store.state.textColor\n  });\n\n  // tell other tabs eobuchung-favorites changed\n  window.addEventListener('storage', (event) => {\n    if(event.key === 'eobuchung-favorites') {\n      store.commit(\"refreshFavorites\",getFromLocalStorage('eobuchung-favorites'));\n    }\n  });\n\n  new Vue({\n    router,\n    store,\n    vuetify,\n    render: h => h(App, {\n      props: {\n        id: id,\n        'initial-data': (data && JSON.parse(data.innerHTML)) || undefined,\n        'initial-settings': (settings && JSON.parse(settings.innerHTML)) || undefined,\n      }\n    })\n  }).$mount($el);\n}\n","import 'unfetch/polyfill';\nimport isTomasId from './is-tomas-id';\n\n/**\n * get service provider from api - set endpoint\n * @param apiUrl\n * @param apiKey\n * @param nameOrId\n * @param endpoint\n * @returns {Promise<unknown>}\n */\nexport default function apiGet(apiUrl, apiKey, nameOrId, endpoint) {\n    return new Promise(function (resolve, reject) {\n        const params = isTomasId(nameOrId) ? 'tomasid=' + nameOrId : 'name=' + encodeURIComponent(nameOrId);\n\n        fetch(apiUrl + endpoint + '?' + params + '&apiKey=' + apiKey)\n            .then(r => r.json())\n            .then(data => {\n                resolve(data);\n            }).catch((reason) => {\n            reject(reason);\n        });\n    });\n}\n","/**\n *\n *\n * @author Jerry Bendy <jerry@icewingcc.com>\n * @licence MIT\n *\n */\n\n(function(self) {\n    'use strict';\n\n    var nativeURLSearchParams = (function() {\n            // #41 Fix issue in RN\n            try {\n                if (self.URLSearchParams && (new self.URLSearchParams('foo=bar')).get('foo') === 'bar') {\n                    return self.URLSearchParams;\n                }\n            } catch (e) {}\n            return null;\n        })(),\n        isSupportObjectConstructor = nativeURLSearchParams && (new nativeURLSearchParams({a: 1})).toString() === 'a=1',\n        // There is a bug in safari 10.1 (and earlier) that incorrectly decodes `%2B` as an empty space and not a plus.\n        decodesPlusesCorrectly = nativeURLSearchParams && (new nativeURLSearchParams('s=%2B').get('s') === '+'),\n        __URLSearchParams__ = \"__URLSearchParams__\",\n        // Fix bug in Edge which cannot encode ' &' correctly\n        encodesAmpersandsCorrectly = nativeURLSearchParams ? (function() {\n            var ampersandTest = new nativeURLSearchParams();\n            ampersandTest.append('s', ' &');\n            return ampersandTest.toString() === 's=+%26';\n        })() : true,\n        prototype = URLSearchParamsPolyfill.prototype,\n        iterable = !!(self.Symbol && self.Symbol.iterator);\n\n    if (nativeURLSearchParams && isSupportObjectConstructor && decodesPlusesCorrectly && encodesAmpersandsCorrectly) {\n        return;\n    }\n\n\n    /**\n     * Make a URLSearchParams instance\n     *\n     * @param {object|string|URLSearchParams} search\n     * @constructor\n     */\n    function URLSearchParamsPolyfill(search) {\n        search = search || \"\";\n\n        // support construct object with another URLSearchParams instance\n        if (search instanceof URLSearchParams || search instanceof URLSearchParamsPolyfill) {\n            search = search.toString();\n        }\n        this [__URLSearchParams__] = parseToDict(search);\n    }\n\n\n    /**\n     * Appends a specified key/value pair as a new search parameter.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.append = function(name, value) {\n        appendTo(this [__URLSearchParams__], name, value);\n    };\n\n    /**\n     * Deletes the given search parameter, and its associated value,\n     * from the list of all search parameters.\n     *\n     * @param {string} name\n     */\n    prototype['delete'] = function(name) {\n        delete this [__URLSearchParams__] [name];\n    };\n\n    /**\n     * Returns the first value associated to the given search parameter.\n     *\n     * @param {string} name\n     * @returns {string|null}\n     */\n    prototype.get = function(name) {\n        var dict = this [__URLSearchParams__];\n        return this.has(name) ? dict[name][0] : null;\n    };\n\n    /**\n     * Returns all the values association with a given search parameter.\n     *\n     * @param {string} name\n     * @returns {Array}\n     */\n    prototype.getAll = function(name) {\n        var dict = this [__URLSearchParams__];\n        return this.has(name) ? dict [name].slice(0) : [];\n    };\n\n    /**\n     * Returns a Boolean indicating if such a search parameter exists.\n     *\n     * @param {string} name\n     * @returns {boolean}\n     */\n    prototype.has = function(name) {\n        return hasOwnProperty(this [__URLSearchParams__], name);\n    };\n\n    /**\n     * Sets the value associated to a given search parameter to\n     * the given value. If there were several values, delete the\n     * others.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.set = function set(name, value) {\n        this [__URLSearchParams__][name] = ['' + value];\n    };\n\n    /**\n     * Returns a string containg a query string suitable for use in a URL.\n     *\n     * @returns {string}\n     */\n    prototype.toString = function() {\n        var dict = this[__URLSearchParams__], query = [], i, key, name, value;\n        for (key in dict) {\n            name = encode(key);\n            for (i = 0, value = dict[key]; i < value.length; i++) {\n                query.push(name + '=' + encode(value[i]));\n            }\n        }\n        return query.join('&');\n    };\n\n    // There is a bug in Safari 10.1 and `Proxy`ing it is not enough.\n    var forSureUsePolyfill = !decodesPlusesCorrectly;\n    var useProxy = (!forSureUsePolyfill && nativeURLSearchParams && !isSupportObjectConstructor && self.Proxy);\n    var propValue; \n    if (useProxy) {\n        // Safari 10.0 doesn't support Proxy, so it won't extend URLSearchParams on safari 10.0\n        propValue = new Proxy(nativeURLSearchParams, {\n            construct: function (target, args) {\n                return new target((new URLSearchParamsPolyfill(args[0]).toString()));\n            }\n        })\n        // Chrome <=60 .toString() on a function proxy got error \"Function.prototype.toString is not generic\"\n        propValue.toString = Function.prototype.toString.bind(URLSearchParamsPolyfill);\n    } else {\n        propValue = URLSearchParamsPolyfill;\n    }\n    /*\n     * Apply polifill to global object and append other prototype into it\n     */\n    Object.defineProperty(self, 'URLSearchParams', {\n        value: propValue\n    });\n\n    var USPProto = self.URLSearchParams.prototype;\n\n    USPProto.polyfill = true;\n\n    /**\n     *\n     * @param {function} callback\n     * @param {object} thisArg\n     */\n    USPProto.forEach = USPProto.forEach || function(callback, thisArg) {\n        var dict = parseToDict(this.toString());\n        Object.getOwnPropertyNames(dict).forEach(function(name) {\n            dict[name].forEach(function(value) {\n                callback.call(thisArg, value, name, this);\n            }, this);\n        }, this);\n    };\n\n    /**\n     * Sort all name-value pairs\n     */\n    USPProto.sort = USPProto.sort || function() {\n        var dict = parseToDict(this.toString()), keys = [], k, i, j;\n        for (k in dict) {\n            keys.push(k);\n        }\n        keys.sort();\n\n        for (i = 0; i < keys.length; i++) {\n            this['delete'](keys[i]);\n        }\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i], values = dict[key];\n            for (j = 0; j < values.length; j++) {\n                this.append(key, values[j]);\n            }\n        }\n    };\n\n    /**\n     * Returns an iterator allowing to go through all keys of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.keys = USPProto.keys || function() {\n        var items = [];\n        this.forEach(function(item, name) {\n            items.push(name);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all values of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.values = USPProto.values || function() {\n        var items = [];\n        this.forEach(function(item) {\n            items.push(item);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all key/value\n     * pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.entries = USPProto.entries || function() {\n        var items = [];\n        this.forEach(function(item, name) {\n            items.push([name, item]);\n        });\n        return makeIterator(items);\n    };\n\n\n    if (iterable) {\n        USPProto[self.Symbol.iterator] = USPProto[self.Symbol.iterator] || USPProto.entries;\n    }\n\n\n    function encode(str) {\n        var replace = {\n            '!': '%21',\n            \"'\": '%27',\n            '(': '%28',\n            ')': '%29',\n            '~': '%7E',\n            '%20': '+',\n            '%00': '\\x00'\n        };\n        return encodeURIComponent(str).replace(/[!'\\(\\)~]|%20|%00/g, function(match) {\n            return replace[match];\n        });\n    }\n\n    function decode(str) {\n        return str\n            .replace(/[ +]/g, '%20')\n            .replace(/(%[a-f0-9]{2})+/ig, function(match) {\n                return decodeURIComponent(match);\n            });\n    }\n\n    function makeIterator(arr) {\n        var iterator = {\n            next: function() {\n                var value = arr.shift();\n                return {done: value === undefined, value: value};\n            }\n        };\n\n        if (iterable) {\n            iterator[self.Symbol.iterator] = function() {\n                return iterator;\n            };\n        }\n\n        return iterator;\n    }\n\n    function parseToDict(search) {\n        var dict = {};\n\n        if (typeof search === \"object\") {\n            // if `search` is an array, treat it as a sequence\n            if (isArray(search)) {\n                for (var i = 0; i < search.length; i++) {\n                    var item = search[i];\n                    if (isArray(item) && item.length === 2) {\n                        appendTo(dict, item[0], item[1]);\n                    } else {\n                        throw new TypeError(\"Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements\");\n                    }\n                }\n\n            } else {\n                for (var key in search) {\n                    if (search.hasOwnProperty(key)) {\n                        appendTo(dict, key, search[key]);\n                    }\n                }\n            }\n\n        } else {\n            // remove first '?'\n            if (search.indexOf(\"?\") === 0) {\n                search = search.slice(1);\n            }\n\n            var pairs = search.split(\"&\");\n            for (var j = 0; j < pairs.length; j++) {\n                var value = pairs [j],\n                    index = value.indexOf('=');\n\n                if (-1 < index) {\n                    appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));\n\n                } else {\n                    if (value) {\n                        appendTo(dict, decode(value), '');\n                    }\n                }\n            }\n        }\n\n        return dict;\n    }\n\n    function appendTo(dict, name, value) {\n        var val = typeof value === 'string' ? value : (\n            value !== null && value !== undefined && typeof value.toString === 'function' ? value.toString() : JSON.stringify(value)\n        );\n\n        // #47 Prevent using `hasOwnProperty` as a property name\n        if (hasOwnProperty(dict, name)) {\n            dict[name].push(val);\n        } else {\n            dict[name] = [val];\n        }\n    }\n\n    function isArray(val) {\n        return !!val && '[object Array]' === Object.prototype.toString.call(val);\n    }\n\n    function hasOwnProperty(obj, prop) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    }\n\n})(typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : this));\n","self.fetch||(self.fetch=function(e,n){return n=n||{},new Promise(function(t,s){var r=new XMLHttpRequest,o=[],u=[],i={},a=function(){return{ok:2==(r.status/100|0),statusText:r.statusText,status:r.status,url:r.responseURL,text:function(){return Promise.resolve(r.responseText)},json:function(){return Promise.resolve(r.responseText).then(JSON.parse)},blob:function(){return Promise.resolve(new Blob([r.response]))},clone:a,headers:{keys:function(){return o},entries:function(){return u},get:function(e){return i[e.toLowerCase()]},has:function(e){return e.toLowerCase()in i}}}};for(var c in r.open(n.method||\"get\",e,!0),r.onload=function(){r.getAllResponseHeaders().replace(/^(.*?):[^\\S\\n]*([\\s\\S]*?)$/gm,function(e,n,t){o.push(n=n.toLowerCase()),u.push([n,t]),i[n]=i[n]?i[n]+\",\"+t:t}),t(a())},r.onerror=s,r.withCredentials=\"include\"==n.credentials,n.headers)r.setRequestHeader(c,n.headers[c]);r.send(n.body||null)})});\n","export default function initialAccommodationSet() {\n\treturn [initialAccommodationEntry()];\n}\n\nexport function initialAccommodationEntry() {\n\treturn {\n\t\tadults: 2,\n\t\tchildren: 0,\n\t\tchildAges: [],\n\t};\n}\n","// helper to get data from session storage\nexport function getFromStorage(key) {\n    const data = sessionStorage.getItem(key);\n    try {\n        return data ? JSON.parse(data) : false;\n    } catch (e) { // if no JSON - do not fail\n        return false;\n    }\n}\n\n// helper to write boolean data to session storage\nexport function saveToStorage(key, value) {\n    sessionStorage.setItem(key, JSON.stringify(value));\n}\nexport function saveToLocalStorage(key, value) {\n    localStorage.setItem(key, JSON.stringify(value));\n}\nexport function getFromLocalStorage(key) {\n  const data = localStorage.getItem(key);\n  try {\n    return data ? JSON.parse(data) : false;\n  } catch (e) { // if no JSON - do not fail\n    return false;\n  }\n}\n\nexport function ensureArray(value) {\n    if (value && !Array.isArray(value)) {\n        return value.split(',');\n    }\n    return value;\n}\n","function getApiUrl(returnQueryString = false) {\n  const searchParams = new URLSearchParams(window.location.search);\n  const apiUrl = searchParams.get('apiUrl');\n  const queryString = apiUrl ? '?apiUrl=' + encodeURIComponent(apiUrl) : '';\n  if(returnQueryString)\n    return queryString;\n  return apiUrl;\n}\nfunction addApiUrlToUrl(url) {\n  const apiUrl = getApiUrl();\n  let newUrl = \"\";\n  if (apiUrl) {\n    newUrl = addQueryParam(url, 'apiUrl', apiUrl);\n  }\n  return newUrl || url;\n}\nfunction addQueryParam(url, param, value) {\n  if(!url.includes(window.location.host))\n    url = `${location.protocol}//${location.host}${url}`;\n  const urlObj = new URL(url);\n  urlObj.searchParams.set(param, value);\n  return urlObj.toString();\n}\n\nexport { getApiUrl, addApiUrlToUrl};","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","const re = new RegExp('^[A-Z]{3}[0-9]{17}$');\n\n/**\n * Tests parameter for tomas id\n * @param possibleId\n * @returns {boolean}\n */\nexport default function isTomasId(possibleId) {\n    return typeof possibleId === 'string' && re.test(possibleId.toUpperCase());\n}\n"],"sourceRoot":""}