{"version":3,"sources":["webpack:///./node_modules/vue-application-insights/dist/vue-application-insights.js","webpack:///./node_modules/vue-meta/node_modules/deepmerge/dist/cjs.js","webpack:///./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack:///./node_modules/vue-meta/dist/vue-meta.esm.js"],"names":["Object","defineProperty","exports","value","_applicationinsightsWeb","install","Vue","options","config","appInsightsConfig","instrumentationKey","id","appInsights","ApplicationInsights","loadAppInsights","onAfterScriptLoaded","router","trackInitialPageView","setupPageTracking","onReady","prototype","get","baseName","beforeEach","route","from","next","name","startTrackPage","afterEach","url","location","protocol","host","fullPath","stopTrackPage","flush","window","use","default","isMergeableObject","isNonNullObject","isSpecial","stringValue","toString","call","isReactElement","canUseSymbol","Symbol","for","REACT_ELEMENT_TYPE","$$typeof","emptyTarget","val","Array","isArray","cloneUnlessOtherwiseSpecified","clone","deepmerge","defaultArrayMerge","target","source","concat","map","element","getMergeFunction","key","customMerge","getEnumerableOwnPropertySymbols","getOwnPropertySymbols","filter","symbol","propertyIsEnumerable","getKeys","keys","propertyIsOnObject","object","property","_","propertyIsUnsafe","hasOwnProperty","mergeObject","destination","forEach","arrayMerge","sourceIsArray","targetIsArray","sourceAndTargetTypesMatch","all","array","Error","reduce","prev","deepmerge_1","module","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","_compiled","functional","_scopeId","context","this","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","version","_typeof","obj","iterator","constructor","_defineProperty","enumerable","configurable","writable","ownKeys","enumerableOnly","symbols","sym","getOwnPropertyDescriptor","push","apply","_objectSpread2","i","arguments","length","getOwnPropertyDescriptors","defineProperties","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","_arrayLikeToArray","iter","o","minLen","n","slice","test","len","arr2","TypeError","_createForOfIteratorHelper","allowArrayLike","it","F","s","done","e","f","err","normalCompletion","didErr","step","return","arg","isUndefined","isObject","isPureObject","isFunction","isString","hasGlobalWindowFn","hasGlobalWindow","_global","global","console","warn","str","showWarningNotSupported","defaultInfo","title","undefined","titleChunk","titleTemplate","htmlAttrs","bodyAttrs","headAttrs","base","link","meta","style","script","noscript","__dangerouslyDisableSanitizers","__dangerouslyDisableSanitizersByTagID","rootConfigKey","keyName","attribute","ssrAttribute","tagIDKeyName","metaTemplateKeyName","contentKeyName","ssrAppId","debounceWait","waitOnDestroyed","defaultOptions","defaultInfoKeys","disableOptionKeys","metaInfoOptionKeys","metaInfoAttributeKeys","tagsSupportingOnload","tagsWithoutEndTag","tagsWithInnerContent","tagAttributeAsInnerContent","tagProperties","commonDataAttributes","booleanHtmlAttributes","batchId","triggerUpdate","_ref","rootVm","hookName","initialized","initializing","pausing","batchUpdate","$meta","refresh","callback","timeout","clearTimeout","setTimeout","find","predicate","thisArg","idx","findIndex","toArray","includes","querySelector","el","document","querySelectorAll","getTag","tags","tag","getElementsByTagName","getElementsKey","body","pbody","queryElements","parentNode","_ref2","attributes","appId","type","queries","query","attributeValue","join","removeElementsByAppId","_ref3","remove","removeAttribute","attributeName","hasMetaInfo","vm","inMetaInfoBranch","pause","resume","addNavGuards","$router","navGuards","to","$nextTick","_resume","metaInfo","afterNavigation","createMixin","updateOnLifecycleHook","wasServerRendered","_this2","rootKey","devtoolsEnabled","devtools","deprecationWarningShown","$once","$el","nodeType","hasAttribute","htmlTag","child","$children","c","fnOptions","$parent","computed","$metaInfo","$isServer","$on","$watch","initializedSsr","_$root$$meta$refresh","refreshOnceOnNavigation","_this","_hasMetaInfo","offsetParent","interval","setInterval","clearInterval","lifecycleHook","setOptions","getOptions","optionsCopy","ensureIsArray","serverSequences","clientSequences","escape","info","escapeOptions","escapeKeys","_escapeOptions$doEsca","doEscape","v","escaped","disableKey","tagId","escapedKey","escapeMetaInfo","escapeSequences","seq","replace","index","applyTemplate","headObject","template","chunk","component","_arrayMerge","targetItem","targetIndex","sourceIndex","item","sourceItem","innerHTML","splice","targetTemplate","sourceTemplate","warningShown","merge","attrKey","t","getComponentMetaInfo","getComponentOption","result","_inactive","_options","data","childComponent","callbacks","isDOMComplete","d","readyState","addCallback","addCallbacks","autoAddListeners","hasAsyncCallback","addListeners","applyCallbacks","onreadystatechange","matchElement","args","selector","elements","matches","__vm_cb","onload","__vm_l","__vm_ev","addEventListener","appsMetaInfo","attributeMap","updateAttribute","attrs","vueMetaAttrString","getAttribute","JSON","parse","decodeURI","toUpdate","attr","_attr","attrData","_i","_toUpdate","_attr2","_attrData","attrValues","_appId","attrValue","some","Boolean","setAttribute","updateTitle","updateTag","head","dataAttributes","newElements","queryOptions","currentElements","found","x","k","stringify","res","skip","newElement","createElement","once","isBooleanAttribute","styleSheet","cssText","appendChild","createTextNode","json","indexToDelete","oldElements","hasEqualElement","existingTag","isEqualNode","_type","removeChild","insertBefore","firstChild","oldTags","newTags","updateClientMetaInfo","newInfo","addLoadListeners","tagsAdded","tagsRemoved","tagName","substr","_updateTag","addApp","set","setMetaInfo","removeMetaInfo","_step","_iterator","clearAppsMetaInfo","getAppsMetaInfo","force","getMetaInfo","metaItem","hasVmid","isFirstItemForVmid","metaObject","rawInfo","changed","addedTags","removedTags","additionalAppId","attributeGenerator","addSsrAttribute","attributeStr","encodeURI","titleGenerator","generatorOptions","ln","tagGenerator","_ref2$isSSR","isSSR","_ref2$body","_ref2$pbody","_ref2$ln","tagsStr","tagKeys","prefix","isBooleanAttr","content","hasEndTag","hasContent","generateServerInjector","globalInjectOptions","serverInjector","extraData","addInfo","callInjectors","opts","m","injectors","text","bodyPrepend","bodyAppend","_loop","injectOptions","attributeData","_data","_appId2","_data2","extraStr","inject","newOptions","refreshNavKey","debounceWaitKey","parseInt","isNaN","waitOnDestroyedKey","generate","__vuemeta_installed","mixin"],"mappings":"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","file":"js/chunk-vendors~6ff199a4.678292c9.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _applicationinsightsWeb = require('@microsoft/applicationinsights-web');\n\n/**\r\n * Install function passed to Vue.use() show documentation on vue.js website.\r\n *\r\n * @param Vue\r\n * @param options\r\n */\nfunction install(Vue, options) {\n\n  var config = options.appInsightsConfig || {};\n  config.instrumentationKey = config.instrumentationKey || options.id;\n\n  if (options.appInsights) {\n    Vue.appInsights = options.appInsights;\n  } else {\n    Vue.appInsights = new _applicationinsightsWeb.ApplicationInsights({ config: config });\n    Vue.appInsights.loadAppInsights();\n    if (typeof options.onAfterScriptLoaded === 'function') {\n      options.onAfterScriptLoaded(Vue.appInsights);\n    }\n  }\n\n  var router = options.router;\n\n  // Watch route event if router option is defined.\n  if (router) {\n\n    if (options.trackInitialPageView !== false) {\n      setupPageTracking(options, Vue);\n    } else {\n      router.onReady(function () {\n        return setupPageTracking(options, Vue);\n      });\n    }\n  }\n\n  Object.defineProperty(Vue.prototype, '$appInsights', {\n    get: function get() {\n      return Vue.appInsights;\n    }\n  });\n}\n\n/**\r\n * Track route changes as page views with AppInsights\r\n * @param options \r\n */\nfunction setupPageTracking(options, Vue) {\n\n  var router = options.router;\n\n  var baseName = options.baseName || '(Vue App)';\n\n  router.beforeEach(function (route, from, next) {\n    var name = baseName + ' / ' + route.name;\n    Vue.appInsights.startTrackPage(name);\n    next();\n  });\n\n  router.afterEach(function (route) {\n    var name = baseName + ' / ' + route.name;\n    var url = location.protocol + '//' + location.host + route.fullPath;\n    Vue.appInsights.stopTrackPage(name, url);\n    Vue.appInsights.flush();\n  });\n}\n\n// auto install for navigator\nif (typeof window !== 'undefined' && window.Vue) {\n  window.Vue.use(install);\n}\n\nexports.default = install;\n","'use strict';\n\nvar isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction getMergeFunction(key, options) {\n\tif (!options.customMerge) {\n\t\treturn deepmerge\n\t}\n\tvar customMerge = options.customMerge(key);\n\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n}\n\nfunction getEnumerableOwnPropertySymbols(target) {\n\treturn Object.getOwnPropertySymbols\n\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\treturn target.propertyIsEnumerable(symbol)\n\t\t})\n\t\t: []\n}\n\nfunction getKeys(target) {\n\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n}\n\nfunction propertyIsOnObject(object, property) {\n\ttry {\n\t\treturn property in object\n\t} catch(_) {\n\t\treturn false\n\t}\n}\n\n// Protects from prototype poisoning and unexpected merging up the prototype chain.\nfunction propertyIsUnsafe(target, key) {\n\treturn propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,\n\t\t&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,\n\t\t\t&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tgetKeys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tgetKeys(source).forEach(function(key) {\n\t\tif (propertyIsUnsafe(target, key)) {\n\t\t\treturn\n\t\t}\n\n\t\tif (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {\n\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\t// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()\n\t// implementations can use it. The caller may not replace it.\n\toptions.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nmodule.exports = deepmerge_1;\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 = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : 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) { // 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\n        ? [].concat(existing, hook)\n        : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n","/**\n * vue-meta v2.4.0\n * (c) 2020\n * - Declan de Wet\n * - Sébastien Chopin (@Atinux)\n * - Pim (@pimlie)\n * - All the amazing contributors\n * @license MIT\n */\n\nimport deepmerge from 'deepmerge';\n\nvar version = \"2.4.0\";\n\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function () {};\n\n      return {\n        s: F,\n        n: function () {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function (e) {\n          throw e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function () {\n      it = o[Symbol.iterator]();\n    },\n    n: function () {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function (e) {\n      didErr = true;\n      err = e;\n    },\n    f: function () {\n      try {\n        if (!normalCompletion && it.return != null) it.return();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\n\n/**\n * checks if passed argument is an array\n * @param  {any}  arg - the object to check\n * @return {Boolean} - true if `arg` is an array\n */\nfunction isArray(arg) {\n  return Array.isArray(arg);\n}\nfunction isUndefined(arg) {\n  return typeof arg === 'undefined';\n}\nfunction isObject(arg) {\n  return _typeof(arg) === 'object';\n}\nfunction isPureObject(arg) {\n  return _typeof(arg) === 'object' && arg !== null;\n}\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\n\nfunction hasGlobalWindowFn() {\n  try {\n    return !isUndefined(window);\n  } catch (e) {\n    return false;\n  }\n}\nvar hasGlobalWindow = hasGlobalWindowFn();\n\nvar _global = hasGlobalWindow ? window : global;\n\nvar console = _global.console || {};\nfunction warn(str) {\n  /* istanbul ignore next */\n  if (!console || !console.warn) {\n    return;\n  }\n\n  console.warn(str);\n}\nvar showWarningNotSupported = function showWarningNotSupported() {\n  return warn('This vue app/component has no vue-meta configuration');\n};\n\n/**\n * These are constant variables used throughout the application.\n */\n// set some sane defaults\nvar defaultInfo = {\n  title: undefined,\n  titleChunk: '',\n  titleTemplate: '%s',\n  htmlAttrs: {},\n  bodyAttrs: {},\n  headAttrs: {},\n  base: [],\n  link: [],\n  meta: [],\n  style: [],\n  script: [],\n  noscript: [],\n  __dangerouslyDisableSanitizers: [],\n  __dangerouslyDisableSanitizersByTagID: {}\n};\nvar rootConfigKey = '_vueMeta'; // This is the name of the component option that contains all the information that\n// gets converted to the various meta tags & attributes for the page.\n\nvar keyName = 'metaInfo'; // This is the attribute vue-meta arguments on elements to know which it should\n// manage and which it should ignore.\n\nvar attribute = 'data-vue-meta'; // This is the attribute that goes on the `html` tag to inform `vue-meta`\n// that the server has already generated the meta tags for the initial render.\n\nvar ssrAttribute = 'data-vue-meta-server-rendered'; // This is the property that tells vue-meta to overwrite (instead of append)\n// an item in a tag list. For example, if you have two `meta` tag list items\n// that both have `vmid` of \"description\", then vue-meta will overwrite the\n// shallowest one with the deepest one.\n\nvar tagIDKeyName = 'vmid'; // This is the key name for possible meta templates\n\nvar metaTemplateKeyName = 'template'; // This is the key name for the content-holding property\n\nvar contentKeyName = 'content'; // The id used for the ssr app\n\nvar ssrAppId = 'ssr'; // How long meta update\n\nvar debounceWait = 10; // How long meta update\n\nvar waitOnDestroyed = true;\nvar defaultOptions = {\n  keyName: keyName,\n  attribute: attribute,\n  ssrAttribute: ssrAttribute,\n  tagIDKeyName: tagIDKeyName,\n  contentKeyName: contentKeyName,\n  metaTemplateKeyName: metaTemplateKeyName,\n  waitOnDestroyed: waitOnDestroyed,\n  debounceWait: debounceWait,\n  ssrAppId: ssrAppId\n}; // might be a bit ugly, but minimizes the browser bundles a bit\n\nvar defaultInfoKeys = Object.keys(defaultInfo); // The metaInfo property keys which are used to disable escaping\n\nvar disableOptionKeys = [defaultInfoKeys[12], defaultInfoKeys[13]]; // List of metaInfo property keys which are configuration options (and dont generate html)\n\nvar metaInfoOptionKeys = [defaultInfoKeys[1], defaultInfoKeys[2], 'changed'].concat(disableOptionKeys); // List of metaInfo property keys which only generates attributes and no tags\n\nvar metaInfoAttributeKeys = [defaultInfoKeys[3], defaultInfoKeys[4], defaultInfoKeys[5]]; // HTML elements which support the onload event\n\nvar tagsSupportingOnload = ['link', 'style', 'script']; // HTML elements which dont have a head tag (shortened to our needs)\n// see: https://www.w3.org/TR/html52/document-metadata.html\n\nvar tagsWithoutEndTag = ['base', 'meta', 'link']; // HTML elements which can have inner content (shortened to our needs)\n\nvar tagsWithInnerContent = ['noscript', 'script', 'style']; // Attributes which are inserted as childNodes instead of HTMLAttribute\n\nvar tagAttributeAsInnerContent = ['innerHTML', 'cssText', 'json'];\nvar tagProperties = ['once', 'skip', 'template']; // Attributes which should be added with data- prefix\n\nvar commonDataAttributes = ['body', 'pbody']; // from: https://github.com/kangax/html-minifier/blob/gh-pages/src/htmlminifier.js#L202\n\nvar booleanHtmlAttributes = ['allowfullscreen', 'amp', 'amp-boilerplate', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defaultchecked', 'defaultmuted', 'defaultselected', 'defer', 'disabled', 'enabled', 'formnovalidate', 'hidden', 'indeterminate', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'pauseonexit', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'sortable', 'truespeed', 'typemustmatch', 'visible'];\n\nvar batchId = null;\nfunction triggerUpdate(_ref, rootVm, hookName) {\n  var debounceWait = _ref.debounceWait;\n\n  // if an update was triggered during initialization or when an update was triggered by the\n  // metaInfo watcher, set initialized to null\n  // then we keep falsy value but know we need to run a triggerUpdate after initialization\n  if (!rootVm[rootConfigKey].initialized && (rootVm[rootConfigKey].initializing || hookName === 'watcher')) {\n    rootVm[rootConfigKey].initialized = null;\n  }\n\n  if (rootVm[rootConfigKey].initialized && !rootVm[rootConfigKey].pausing) {\n    // batch potential DOM updates to prevent extraneous re-rendering\n    // eslint-disable-next-line no-void\n    batchUpdate(function () {\n      return void rootVm.$meta().refresh();\n    }, debounceWait);\n  }\n}\n/**\n * Performs a batched update.\n *\n * @param  {(null|Number)} id - the ID of this update\n * @param  {Function} callback - the update to perform\n * @return {Number} id - a new ID\n */\n\nfunction batchUpdate(callback, timeout) {\n  timeout = timeout === undefined ? 10 : timeout;\n\n  if (!timeout) {\n    callback();\n    return;\n  }\n\n  clearTimeout(batchId);\n  batchId = setTimeout(function () {\n    callback();\n  }, timeout);\n  return batchId;\n}\n\n/*\n * To reduce build size, this file provides simple polyfills without\n * overly excessive type checking and without modifying\n * the global Array.prototype\n * The polyfills are automatically removed in the commonjs build\n * Also, only files in client/ & shared/ should use these functions\n * files in server/ still use normal js function\n */\nfunction find(array, predicate, thisArg) {\n  if ( !Array.prototype.find) {\n    // idx needs to be a Number, for..in returns string\n    for (var idx = 0; idx < array.length; idx++) {\n      if (predicate.call(thisArg, array[idx], idx, array)) {\n        return array[idx];\n      }\n    }\n\n    return;\n  }\n\n  return array.find(predicate, thisArg);\n}\nfunction findIndex(array, predicate, thisArg) {\n  if ( !Array.prototype.findIndex) {\n    // idx needs to be a Number, for..in returns string\n    for (var idx = 0; idx < array.length; idx++) {\n      if (predicate.call(thisArg, array[idx], idx, array)) {\n        return idx;\n      }\n    }\n\n    return -1;\n  }\n\n  return array.findIndex(predicate, thisArg);\n}\nfunction toArray(arg) {\n  if ( !Array.from) {\n    return Array.prototype.slice.call(arg);\n  }\n\n  return Array.from(arg);\n}\nfunction includes(array, value) {\n  if ( !Array.prototype.includes) {\n    for (var idx in array) {\n      if (array[idx] === value) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  return array.includes(value);\n}\n\nvar querySelector = function querySelector(arg, el) {\n  return (el || document).querySelectorAll(arg);\n};\nfunction getTag(tags, tag) {\n  if (!tags[tag]) {\n    tags[tag] = document.getElementsByTagName(tag)[0];\n  }\n\n  return tags[tag];\n}\nfunction getElementsKey(_ref) {\n  var body = _ref.body,\n      pbody = _ref.pbody;\n  return body ? 'body' : pbody ? 'pbody' : 'head';\n}\nfunction queryElements(parentNode, _ref2, attributes) {\n  var appId = _ref2.appId,\n      attribute = _ref2.attribute,\n      type = _ref2.type,\n      tagIDKeyName = _ref2.tagIDKeyName;\n  attributes = attributes || {};\n  var queries = [\"\".concat(type, \"[\").concat(attribute, \"=\\\"\").concat(appId, \"\\\"]\"), \"\".concat(type, \"[data-\").concat(tagIDKeyName, \"]\")].map(function (query) {\n    for (var key in attributes) {\n      var val = attributes[key];\n      var attributeValue = val && val !== true ? \"=\\\"\".concat(val, \"\\\"\") : '';\n      query += \"[data-\".concat(key).concat(attributeValue, \"]\");\n    }\n\n    return query;\n  });\n  return toArray(querySelector(queries.join(', '), parentNode));\n}\nfunction removeElementsByAppId(_ref3, appId) {\n  var attribute = _ref3.attribute;\n  toArray(querySelector(\"[\".concat(attribute, \"=\\\"\").concat(appId, \"\\\"]\"))).map(function (el) {\n    return el.remove();\n  });\n}\nfunction removeAttribute(el, attributeName) {\n  el.removeAttribute(attributeName);\n}\n\nfunction hasMetaInfo(vm) {\n  vm = vm || this;\n  return vm && (vm[rootConfigKey] === true || isObject(vm[rootConfigKey]));\n} // a component is in a metaInfo branch when itself has meta info or one of its (grand-)children has\n\nfunction inMetaInfoBranch(vm) {\n  vm = vm || this;\n  return vm && !isUndefined(vm[rootConfigKey]);\n}\n\nfunction pause(rootVm, refresh) {\n  rootVm[rootConfigKey].pausing = true;\n  return function () {\n    return resume(rootVm, refresh);\n  };\n}\nfunction resume(rootVm, refresh) {\n  rootVm[rootConfigKey].pausing = false;\n\n  if (refresh || refresh === undefined) {\n    return rootVm.$meta().refresh();\n  }\n}\n\nfunction addNavGuards(rootVm) {\n  var router = rootVm.$router; // return when nav guards already added or no router exists\n\n  if (rootVm[rootConfigKey].navGuards || !router) {\n    /* istanbul ignore next */\n    return;\n  }\n\n  rootVm[rootConfigKey].navGuards = true;\n  router.beforeEach(function (to, from, next) {\n    pause(rootVm);\n    next();\n  });\n  router.afterEach(function () {\n    rootVm.$nextTick(function () {\n      var _resume = resume(rootVm),\n          metaInfo = _resume.metaInfo;\n\n      if (metaInfo && isFunction(metaInfo.afterNavigation)) {\n        metaInfo.afterNavigation(metaInfo);\n      }\n    });\n  });\n}\n\nvar appId = 1;\nfunction createMixin(Vue, options) {\n  // for which Vue lifecycle hooks should the metaInfo be refreshed\n  var updateOnLifecycleHook = ['activated', 'deactivated', 'beforeMount'];\n  var wasServerRendered = false; // watch for client side component updates\n\n  return {\n    beforeCreate: function beforeCreate() {\n      var _this2 = this;\n\n      var rootKey = '$root';\n      var $root = this[rootKey];\n      var $options = this.$options;\n      var devtoolsEnabled = Vue.config.devtools;\n      Object.defineProperty(this, '_hasMetaInfo', {\n        configurable: true,\n        get: function get() {\n          // Show deprecation warning once when devtools enabled\n          if (devtoolsEnabled && !$root[rootConfigKey].deprecationWarningShown) {\n            warn('VueMeta DeprecationWarning: _hasMetaInfo has been deprecated and will be removed in a future version. Please use hasMetaInfo(vm) instead');\n            $root[rootConfigKey].deprecationWarningShown = true;\n          }\n\n          return hasMetaInfo(this);\n        }\n      });\n\n      if (this === $root) {\n        $root.$once('hook:beforeMount', function () {\n          wasServerRendered = this.$el && this.$el.nodeType === 1 && this.$el.hasAttribute('data-server-rendered'); // In most cases when you have a SSR app it will be the first app thats gonna be\n          // initiated, if we cant detect the data-server-rendered attribute from Vue but we\n          // do see our own ssrAttribute then _assume_ the Vue app with appId 1 is the ssr app\n          // attempted fix for #404 & #562, but we rly need to refactor how we pass appIds from\n          // ssr to the client\n\n          if (!wasServerRendered && $root[rootConfigKey] && $root[rootConfigKey].appId === 1) {\n            var htmlTag = getTag({}, 'html');\n            wasServerRendered = htmlTag && htmlTag.hasAttribute(options.ssrAttribute);\n          }\n        });\n      } // Add a marker to know if it uses metaInfo\n      // _vnode is used to know that it's attached to a real component\n      // useful if we use some mixin to add some meta tags (like nuxt-i18n)\n\n\n      if (isUndefined($options[options.keyName]) || $options[options.keyName] === null) {\n        return;\n      }\n\n      if (!$root[rootConfigKey]) {\n        $root[rootConfigKey] = {\n          appId: appId\n        };\n        appId++;\n\n        if (devtoolsEnabled && $root.$options[options.keyName]) {\n          // use nextTick so the children should be added to $root\n          this.$nextTick(function () {\n            // find the first child that lists fnOptions\n            var child = find($root.$children, function (c) {\n              return c.$vnode && c.$vnode.fnOptions;\n            });\n\n            if (child && child.$vnode.fnOptions[options.keyName]) {\n              warn(\"VueMeta has detected a possible global mixin which adds a \".concat(options.keyName, \" property to all Vue components on the page. This could cause severe performance issues. If possible, use $meta().addApp to add meta information instead\"));\n            }\n          });\n        }\n      } // to speed up updates we keep track of branches which have a component with vue-meta info defined\n      // if _vueMeta = true it has info, if _vueMeta = false a child has info\n\n\n      if (!this[rootConfigKey]) {\n        this[rootConfigKey] = true;\n        var parent = this.$parent;\n\n        while (parent && parent !== $root) {\n          if (isUndefined(parent[rootConfigKey])) {\n            parent[rootConfigKey] = false;\n          }\n\n          parent = parent.$parent;\n        }\n      } // coerce function-style metaInfo to a computed prop so we can observe\n      // it on creation\n\n\n      if (isFunction($options[options.keyName])) {\n        $options.computed = $options.computed || {};\n        $options.computed.$metaInfo = $options[options.keyName];\n\n        if (!this.$isServer) {\n          // if computed $metaInfo exists, watch it for updates & trigger a refresh\n          // when it changes (i.e. automatically handle async actions that affect metaInfo)\n          // credit for this suggestion goes to [Sébastien Chopin](https://github.com/Atinux)\n          this.$on('hook:created', function () {\n            this.$watch('$metaInfo', function () {\n              triggerUpdate(options, this[rootKey], 'watcher');\n            });\n          });\n        }\n      } // force an initial refresh on page load and prevent other lifecycleHooks\n      // to triggerUpdate until this initial refresh is finished\n      // this is to make sure that when a page is opened in an inactive tab which\n      // has throttled rAF/timers we still immediately set the page title\n\n\n      if (isUndefined($root[rootConfigKey].initialized)) {\n        $root[rootConfigKey].initialized = this.$isServer;\n\n        if (!$root[rootConfigKey].initialized) {\n          if (!$root[rootConfigKey].initializedSsr) {\n            $root[rootConfigKey].initializedSsr = true;\n            this.$on('hook:beforeMount', function () {\n              var $root = this[rootKey]; // if this Vue-app was server rendered, set the appId to 'ssr'\n              // only one SSR app per page is supported\n\n              if (wasServerRendered) {\n                $root[rootConfigKey].appId = options.ssrAppId;\n              }\n            });\n          } // we use the mounted hook here as on page load\n\n\n          this.$on('hook:mounted', function () {\n            var $root = this[rootKey];\n\n            if ($root[rootConfigKey].initialized) {\n              return;\n            } // used in triggerUpdate to check if a change was triggered\n            // during initialization\n\n\n            $root[rootConfigKey].initializing = true; // refresh meta in nextTick so all child components have loaded\n\n            this.$nextTick(function () {\n              var _$root$$meta$refresh = $root.$meta().refresh(),\n                  tags = _$root$$meta$refresh.tags,\n                  metaInfo = _$root$$meta$refresh.metaInfo; // After ssr hydration (identifier by tags === false) check\n              // if initialized was set to null in triggerUpdate. That'd mean\n              // that during initilazation changes where triggered which need\n              // to be applied OR a metaInfo watcher was triggered before the\n              // current hook was called\n              // (during initialization all changes are blocked)\n\n\n              if (tags === false && $root[rootConfigKey].initialized === null) {\n                this.$nextTick(function () {\n                  return triggerUpdate(options, $root, 'init');\n                });\n              }\n\n              $root[rootConfigKey].initialized = true;\n              delete $root[rootConfigKey].initializing; // add the navigation guards if they havent been added yet\n              // they are needed for the afterNavigation callback\n\n              if (!options.refreshOnceOnNavigation && metaInfo.afterNavigation) {\n                addNavGuards($root);\n              }\n            });\n          }); // add the navigation guards if requested\n\n          if (options.refreshOnceOnNavigation) {\n            addNavGuards($root);\n          }\n        }\n      }\n\n      this.$on('hook:destroyed', function () {\n        var _this = this;\n\n        // do not trigger refresh:\n        // - when user configured to not wait for transitions on destroyed\n        // - when the component doesnt have a parent\n        // - doesnt have metaInfo defined\n        if (!this.$parent || !hasMetaInfo(this)) {\n          return;\n        }\n\n        delete this._hasMetaInfo;\n        this.$nextTick(function () {\n          if (!options.waitOnDestroyed || !_this.$el || !_this.$el.offsetParent) {\n            triggerUpdate(options, _this.$root, 'destroyed');\n            return;\n          } // Wait that element is hidden before refreshing meta tags (to support animations)\n\n\n          var interval = setInterval(function () {\n            if (_this.$el && _this.$el.offsetParent !== null) {\n              /* istanbul ignore next line */\n              return;\n            }\n\n            clearInterval(interval);\n            triggerUpdate(options, _this.$root, 'destroyed');\n          }, 50);\n        });\n      }); // do not trigger refresh on the server side\n\n      if (this.$isServer) {\n        /* istanbul ignore next */\n        return;\n      } // no need to add this hooks on server side\n\n\n      updateOnLifecycleHook.forEach(function (lifecycleHook) {\n        _this2.$on(\"hook:\".concat(lifecycleHook), function () {\n          triggerUpdate(options, this[rootKey], lifecycleHook);\n        });\n      });\n    }\n  };\n}\n\nfunction setOptions(options) {\n  // combine options\n  options = isObject(options) ? options : {}; // The options are set like this so they can\n  // be minified by terser while keeping the\n  // user api intact\n  // terser --mangle-properties keep_quoted=strict\n\n  /* eslint-disable dot-notation */\n\n  return {\n    keyName: options['keyName'] || defaultOptions.keyName,\n    attribute: options['attribute'] || defaultOptions.attribute,\n    ssrAttribute: options['ssrAttribute'] || defaultOptions.ssrAttribute,\n    tagIDKeyName: options['tagIDKeyName'] || defaultOptions.tagIDKeyName,\n    contentKeyName: options['contentKeyName'] || defaultOptions.contentKeyName,\n    metaTemplateKeyName: options['metaTemplateKeyName'] || defaultOptions.metaTemplateKeyName,\n    debounceWait: isUndefined(options['debounceWait']) ? defaultOptions.debounceWait : options['debounceWait'],\n    waitOnDestroyed: isUndefined(options['waitOnDestroyed']) ? defaultOptions.waitOnDestroyed : options['waitOnDestroyed'],\n    ssrAppId: options['ssrAppId'] || defaultOptions.ssrAppId,\n    refreshOnceOnNavigation: !!options['refreshOnceOnNavigation']\n  };\n  /* eslint-enable dot-notation */\n}\nfunction getOptions(options) {\n  var optionsCopy = {};\n\n  for (var key in options) {\n    optionsCopy[key] = options[key];\n  }\n\n  return optionsCopy;\n}\n\nfunction ensureIsArray(arg, key) {\n  if (!key || !isObject(arg)) {\n    return isArray(arg) ? arg : [];\n  }\n\n  if (!isArray(arg[key])) {\n    arg[key] = [];\n  }\n\n  return arg;\n}\n\nvar serverSequences = [[/&/g, '&amp;'], [/</g, '&lt;'], [/>/g, '&gt;'], [/\"/g, '&quot;'], [/'/g, '&#x27;']];\nvar clientSequences = [[/&/g, \"&\"], [/</g, \"<\"], [/>/g, \">\"], [/\"/g, \"\\\"\"], [/'/g, \"'\"]]; // sanitizes potentially dangerous characters\n\nfunction escape(info, options, escapeOptions, escapeKeys) {\n  var tagIDKeyName = options.tagIDKeyName;\n  var _escapeOptions$doEsca = escapeOptions.doEscape,\n      doEscape = _escapeOptions$doEsca === void 0 ? function (v) {\n    return v;\n  } : _escapeOptions$doEsca;\n  var escaped = {};\n\n  for (var key in info) {\n    var value = info[key]; // no need to escape configuration options\n\n    if (includes(metaInfoOptionKeys, key)) {\n      escaped[key] = value;\n      continue;\n    } // do not use destructuring for disableOptionKeys, it increases transpiled size\n    // due to var checks while we are guaranteed the structure of the cb\n\n\n    var disableKey = disableOptionKeys[0];\n\n    if (escapeOptions[disableKey] && includes(escapeOptions[disableKey], key)) {\n      // this info[key] doesnt need to escaped if the option is listed in __dangerouslyDisableSanitizers\n      escaped[key] = value;\n      continue;\n    }\n\n    var tagId = info[tagIDKeyName];\n\n    if (tagId) {\n      disableKey = disableOptionKeys[1]; // keys which are listed in __dangerouslyDisableSanitizersByTagID for the current vmid do not need to be escaped\n\n      if (escapeOptions[disableKey] && escapeOptions[disableKey][tagId] && includes(escapeOptions[disableKey][tagId], key)) {\n        escaped[key] = value;\n        continue;\n      }\n    }\n\n    if (isString(value)) {\n      escaped[key] = doEscape(value);\n    } else if (isArray(value)) {\n      escaped[key] = value.map(function (v) {\n        if (isPureObject(v)) {\n          return escape(v, options, escapeOptions, true);\n        }\n\n        return doEscape(v);\n      });\n    } else if (isPureObject(value)) {\n      escaped[key] = escape(value, options, escapeOptions, true);\n    } else {\n      escaped[key] = value;\n    }\n\n    if (escapeKeys) {\n      var escapedKey = doEscape(key);\n\n      if (key !== escapedKey) {\n        escaped[escapedKey] = escaped[key];\n        delete escaped[key];\n      }\n    }\n  }\n\n  return escaped;\n}\nfunction escapeMetaInfo(options, info, escapeSequences) {\n  escapeSequences = escapeSequences || []; // do not use destructuring for seq, it increases transpiled size\n  // due to var checks while we are guaranteed the structure of the cb\n\n  var escapeOptions = {\n    doEscape: function doEscape(value) {\n      return escapeSequences.reduce(function (val, seq) {\n        return val.replace(seq[0], seq[1]);\n      }, value);\n    }\n  };\n  disableOptionKeys.forEach(function (disableKey, index) {\n    if (index === 0) {\n      ensureIsArray(info, disableKey);\n    } else if (index === 1) {\n      for (var key in info[disableKey]) {\n        ensureIsArray(info[disableKey], key);\n      }\n    }\n\n    escapeOptions[disableKey] = info[disableKey];\n  }); // begin sanitization\n\n  return escape(info, options, escapeOptions);\n}\n\nfunction applyTemplate(_ref, headObject, template, chunk) {\n  var component = _ref.component,\n      metaTemplateKeyName = _ref.metaTemplateKeyName,\n      contentKeyName = _ref.contentKeyName;\n\n  if (template === true || headObject[metaTemplateKeyName] === true) {\n    // abort, template was already applied\n    return false;\n  }\n\n  if (isUndefined(template) && headObject[metaTemplateKeyName]) {\n    template = headObject[metaTemplateKeyName];\n    headObject[metaTemplateKeyName] = true;\n  } // return early if no template defined\n\n\n  if (!template) {\n    // cleanup faulty template properties\n    delete headObject[metaTemplateKeyName];\n    return false;\n  }\n\n  if (isUndefined(chunk)) {\n    chunk = headObject[contentKeyName];\n  }\n\n  headObject[contentKeyName] = isFunction(template) ? template.call(component, chunk) : template.replace(/%s/g, chunk);\n  return true;\n}\n\nfunction _arrayMerge(_ref, target, source) {\n  var component = _ref.component,\n      tagIDKeyName = _ref.tagIDKeyName,\n      metaTemplateKeyName = _ref.metaTemplateKeyName,\n      contentKeyName = _ref.contentKeyName;\n  // we concat the arrays without merging objects contained in,\n  // but we check for a `vmid` property on each object in the array\n  // using an O(1) lookup associative array exploit\n  var destination = [];\n\n  if (!target.length && !source.length) {\n    return destination;\n  }\n\n  target.forEach(function (targetItem, targetIndex) {\n    // no tagID so no need to check for duplicity\n    if (!targetItem[tagIDKeyName]) {\n      destination.push(targetItem);\n      return;\n    }\n\n    var sourceIndex = findIndex(source, function (item) {\n      return item[tagIDKeyName] === targetItem[tagIDKeyName];\n    });\n    var sourceItem = source[sourceIndex]; // source doesnt contain any duplicate vmid's, we can keep targetItem\n\n    if (sourceIndex === -1) {\n      destination.push(targetItem);\n      return;\n    } // when sourceItem explictly defines contentKeyName or innerHTML as undefined, its\n    // an indication that we need to skip the default behaviour or child has preference over parent\n    // which means we keep the targetItem and ignore/remove the sourceItem\n\n\n    if (contentKeyName in sourceItem && sourceItem[contentKeyName] === undefined || 'innerHTML' in sourceItem && sourceItem.innerHTML === undefined) {\n      destination.push(targetItem); // remove current index from source array so its not concatenated to destination below\n\n      source.splice(sourceIndex, 1);\n      return;\n    } // we now know that targetItem is a duplicate and we should ignore it in favor of sourceItem\n    // if source specifies null as content then ignore both the target as the source\n\n\n    if (sourceItem[contentKeyName] === null || sourceItem.innerHTML === null) {\n      // remove current index from source array so its not concatenated to destination below\n      source.splice(sourceIndex, 1);\n      return;\n    } // now we only need to check if the target has a template to combine it with the source\n\n\n    var targetTemplate = targetItem[metaTemplateKeyName];\n\n    if (!targetTemplate) {\n      return;\n    }\n\n    var sourceTemplate = sourceItem[metaTemplateKeyName];\n\n    if (!sourceTemplate) {\n      // use parent template and child content\n      applyTemplate({\n        component: component,\n        metaTemplateKeyName: metaTemplateKeyName,\n        contentKeyName: contentKeyName\n      }, sourceItem, targetTemplate); // set template to true to indicate template was already applied\n\n      sourceItem.template = true;\n      return;\n    }\n\n    if (!sourceItem[contentKeyName]) {\n      // use parent content and child template\n      applyTemplate({\n        component: component,\n        metaTemplateKeyName: metaTemplateKeyName,\n        contentKeyName: contentKeyName\n      }, sourceItem, undefined, targetItem[contentKeyName]);\n    }\n  });\n  return destination.concat(source);\n}\nvar warningShown = false;\nfunction merge(target, source, options) {\n  options = options || {}; // remove properties explicitly set to false so child components can\n  // optionally _not_ overwrite the parents content\n  // (for array properties this is checked in arrayMerge)\n\n  if (source.title === undefined) {\n    delete source.title;\n  }\n\n  metaInfoAttributeKeys.forEach(function (attrKey) {\n    if (!source[attrKey]) {\n      return;\n    }\n\n    for (var key in source[attrKey]) {\n      if (key in source[attrKey] && source[attrKey][key] === undefined) {\n        if (includes(booleanHtmlAttributes, key) && !warningShown) {\n          warn('VueMeta: Please note that since v2 the value undefined is not used to indicate boolean attributes anymore, see migration guide for details');\n          warningShown = true;\n        }\n\n        delete source[attrKey][key];\n      }\n    }\n  });\n  return deepmerge(target, source, {\n    arrayMerge: function arrayMerge(t, s) {\n      return _arrayMerge(options, t, s);\n    }\n  });\n}\n\nfunction getComponentMetaInfo(options, component) {\n  return getComponentOption(options || {}, component, defaultInfo);\n}\n/**\n * Returns the `opts.option` $option value of the given `opts.component`.\n * If methods are encountered, they will be bound to the component context.\n * If `opts.deep` is true, will recursively merge all child component\n * `opts.option` $option values into the returned result.\n *\n * @param  {Object} opts - options\n * @param  {Object} opts.component - Vue component to fetch option data from\n * @param  {Boolean} opts.deep - look for data in child components as well?\n * @param  {Function} opts.arrayMerge - how should arrays be merged?\n * @param  {String} opts.keyName - the name of the option to look for\n * @param  {Object} [result={}] - result so far\n * @return {Object} result - final aggregated result\n */\n\nfunction getComponentOption(options, component, result) {\n  result = result || {};\n\n  if (component._inactive) {\n    return result;\n  }\n\n  options = options || {};\n  var _options = options,\n      keyName = _options.keyName;\n  var $metaInfo = component.$metaInfo,\n      $options = component.$options,\n      $children = component.$children; // only collect option data if it exists\n\n  if ($options[keyName]) {\n    // if $metaInfo exists then [keyName] was defined as a function\n    // and set to the computed prop $metaInfo in the mixin\n    // using the computed prop should be a small performance increase\n    // because Vue caches those internally\n    var data = $metaInfo || $options[keyName]; // only merge data with result when its an object\n    // eg it could be a function when metaInfo() returns undefined\n    // dueo to the or statement above\n\n    if (isObject(data)) {\n      result = merge(result, data, options);\n    }\n  } // collect & aggregate child options if deep = true\n\n\n  if ($children.length) {\n    $children.forEach(function (childComponent) {\n      // check if the childComponent is in a branch\n      // return otherwise so we dont walk all component branches unnecessarily\n      if (!inMetaInfoBranch(childComponent)) {\n        return;\n      }\n\n      result = getComponentOption(options, childComponent, result);\n    });\n  }\n\n  return result;\n}\n\nvar callbacks = [];\nfunction isDOMComplete(d) {\n  return (d || document).readyState === 'complete';\n}\nfunction addCallback(query, callback) {\n  if (arguments.length === 1) {\n    callback = query;\n    query = '';\n  }\n\n  callbacks.push([query, callback]);\n}\nfunction addCallbacks(_ref, type, tags, autoAddListeners) {\n  var tagIDKeyName = _ref.tagIDKeyName;\n  var hasAsyncCallback = false;\n  tags.forEach(function (tag) {\n    if (!tag[tagIDKeyName] || !tag.callback) {\n      return;\n    }\n\n    hasAsyncCallback = true;\n    addCallback(\"\".concat(type, \"[data-\").concat(tagIDKeyName, \"=\\\"\").concat(tag[tagIDKeyName], \"\\\"]\"), tag.callback);\n  });\n\n  if (!autoAddListeners || !hasAsyncCallback) {\n    return hasAsyncCallback;\n  }\n\n  return addListeners();\n}\nfunction addListeners() {\n  if (isDOMComplete()) {\n    applyCallbacks();\n    return;\n  } // Instead of using a MutationObserver, we just apply\n\n  /* istanbul ignore next */\n\n\n  document.onreadystatechange = function () {\n    applyCallbacks();\n  };\n}\nfunction applyCallbacks(matchElement) {\n  callbacks.forEach(function (args) {\n    // do not use destructuring for args, it increases transpiled size\n    // due to var checks while we are guaranteed the structure of the cb\n    var query = args[0];\n    var callback = args[1];\n    var selector = \"\".concat(query, \"[onload=\\\"this.__vm_l=1\\\"]\");\n    var elements = [];\n\n    if (!matchElement) {\n      elements = toArray(querySelector(selector));\n    }\n\n    if (matchElement && matchElement.matches(selector)) {\n      elements = [matchElement];\n    }\n\n    elements.forEach(function (element) {\n      /* __vm_cb: whether the load callback has been called\n       * __vm_l: set by onload attribute, whether the element was loaded\n       * __vm_ev: whether the event listener was added or not\n       */\n      if (element.__vm_cb) {\n        return;\n      }\n\n      var onload = function onload() {\n        /* Mark that the callback for this element has already been called,\n         * this prevents the callback to run twice in some (rare) conditions\n         */\n        element.__vm_cb = true;\n        /* onload needs to be removed because we only need the\n         * attribute after ssr and if we dont remove it the node\n         * will fail isEqualNode on the client\n         */\n\n        removeAttribute(element, 'onload');\n        callback(element);\n      };\n      /* IE9 doesnt seem to load scripts synchronously,\n       * causing a script sometimes/often already to be loaded\n       * when we add the event listener below (thus adding an onload event\n       * listener has no use because it will never be triggered).\n       * Therefore we add the onload attribute during ssr, and\n       * check here if it was already loaded or not\n       */\n\n\n      if (element.__vm_l) {\n        onload();\n        return;\n      }\n\n      if (!element.__vm_ev) {\n        element.__vm_ev = true;\n        element.addEventListener('load', onload);\n      }\n    });\n  });\n}\n\n// instead of adding it to the html\n\nvar attributeMap = {};\n/**\n * Updates the document's html tag attributes\n *\n * @param  {Object} attrs - the new document html attributes\n * @param  {HTMLElement} tag - the HTMLElement tag to update with new attrs\n */\n\nfunction updateAttribute(appId, options, type, attrs, tag) {\n  var _ref = options || {},\n      attribute = _ref.attribute;\n\n  var vueMetaAttrString = tag.getAttribute(attribute);\n\n  if (vueMetaAttrString) {\n    attributeMap[type] = JSON.parse(decodeURI(vueMetaAttrString));\n    removeAttribute(tag, attribute);\n  }\n\n  var data = attributeMap[type] || {};\n  var toUpdate = []; // remove attributes from the map\n  // which have been removed for this appId\n\n  for (var attr in data) {\n    if (data[attr] !== undefined && appId in data[attr]) {\n      toUpdate.push(attr);\n\n      if (!attrs[attr]) {\n        delete data[attr][appId];\n      }\n    }\n  }\n\n  for (var _attr in attrs) {\n    var attrData = data[_attr];\n\n    if (!attrData || attrData[appId] !== attrs[_attr]) {\n      toUpdate.push(_attr);\n\n      if (attrs[_attr] !== undefined) {\n        data[_attr] = data[_attr] || {};\n        data[_attr][appId] = attrs[_attr];\n      }\n    }\n  }\n\n  for (var _i = 0, _toUpdate = toUpdate; _i < _toUpdate.length; _i++) {\n    var _attr2 = _toUpdate[_i];\n    var _attrData = data[_attr2];\n    var attrValues = [];\n\n    for (var _appId in _attrData) {\n      Array.prototype.push.apply(attrValues, [].concat(_attrData[_appId]));\n    }\n\n    if (attrValues.length) {\n      var attrValue = includes(booleanHtmlAttributes, _attr2) && attrValues.some(Boolean) ? '' : attrValues.filter(function (v) {\n        return v !== undefined;\n      }).join(' ');\n      tag.setAttribute(_attr2, attrValue);\n    } else {\n      removeAttribute(tag, _attr2);\n    }\n  }\n\n  attributeMap[type] = data;\n}\n\n/**\n * Updates the document title\n *\n * @param  {String} title - the new title of the document\n */\nfunction updateTitle(title) {\n  if (!title && title !== '') {\n    return;\n  }\n\n  document.title = title;\n}\n\n/**\n * Updates meta tags inside <head> and <body> on the client. Borrowed from `react-helmet`:\n * https://github.com/nfl/react-helmet/blob/004d448f8de5f823d10f838b02317521180f34da/src/Helmet.js#L195-L245\n *\n * @param  {('meta'|'base'|'link'|'style'|'script'|'noscript')} type - the name of the tag\n * @param  {(Array<Object>|Object)} tags - an array of tag objects or a single object in case of base\n * @return {Object} - a representation of what tags changed\n */\n\nfunction updateTag(appId, options, type, tags, head, body) {\n  var _ref = options || {},\n      attribute = _ref.attribute,\n      tagIDKeyName = _ref.tagIDKeyName;\n\n  var dataAttributes = commonDataAttributes.slice();\n  dataAttributes.push(tagIDKeyName);\n  var newElements = [];\n  var queryOptions = {\n    appId: appId,\n    attribute: attribute,\n    type: type,\n    tagIDKeyName: tagIDKeyName\n  };\n  var currentElements = {\n    head: queryElements(head, queryOptions),\n    pbody: queryElements(body, queryOptions, {\n      pbody: true\n    }),\n    body: queryElements(body, queryOptions, {\n      body: true\n    })\n  };\n\n  if (tags.length > 1) {\n    // remove duplicates that could have been found by merging tags\n    // which include a mixin with metaInfo and that mixin is used\n    // by multiple components on the same page\n    var found = [];\n    tags = tags.filter(function (x) {\n      var k = JSON.stringify(x);\n      var res = !includes(found, k);\n      found.push(k);\n      return res;\n    });\n  }\n\n  tags.forEach(function (tag) {\n    if (tag.skip) {\n      return;\n    }\n\n    var newElement = document.createElement(type);\n\n    if (!tag.once) {\n      newElement.setAttribute(attribute, appId);\n    }\n\n    Object.keys(tag).forEach(function (attr) {\n      /* istanbul ignore next */\n      if (includes(tagProperties, attr)) {\n        return;\n      }\n\n      if (attr === 'innerHTML') {\n        newElement.innerHTML = tag.innerHTML;\n        return;\n      }\n\n      if (attr === 'json') {\n        newElement.innerHTML = JSON.stringify(tag.json);\n        return;\n      }\n\n      if (attr === 'cssText') {\n        if (newElement.styleSheet) {\n          /* istanbul ignore next */\n          newElement.styleSheet.cssText = tag.cssText;\n        } else {\n          newElement.appendChild(document.createTextNode(tag.cssText));\n        }\n\n        return;\n      }\n\n      if (attr === 'callback') {\n        newElement.onload = function () {\n          return tag[attr](newElement);\n        };\n\n        return;\n      }\n\n      var _attr = includes(dataAttributes, attr) ? \"data-\".concat(attr) : attr;\n\n      var isBooleanAttribute = includes(booleanHtmlAttributes, attr);\n\n      if (isBooleanAttribute && !tag[attr]) {\n        return;\n      }\n\n      var value = isBooleanAttribute ? '' : tag[attr];\n      newElement.setAttribute(_attr, value);\n    });\n    var oldElements = currentElements[getElementsKey(tag)]; // Remove a duplicate tag from domTagstoRemove, so it isn't cleared.\n\n    var indexToDelete;\n    var hasEqualElement = oldElements.some(function (existingTag, index) {\n      indexToDelete = index;\n      return newElement.isEqualNode(existingTag);\n    });\n\n    if (hasEqualElement && (indexToDelete || indexToDelete === 0)) {\n      oldElements.splice(indexToDelete, 1);\n    } else {\n      newElements.push(newElement);\n    }\n  });\n  var oldElements = [];\n\n  for (var _type in currentElements) {\n    Array.prototype.push.apply(oldElements, currentElements[_type]);\n  } // remove old elements\n\n\n  oldElements.forEach(function (element) {\n    element.parentNode.removeChild(element);\n  }); // insert new elements\n\n  newElements.forEach(function (element) {\n    if (element.hasAttribute('data-body')) {\n      body.appendChild(element);\n      return;\n    }\n\n    if (element.hasAttribute('data-pbody')) {\n      body.insertBefore(element, body.firstChild);\n      return;\n    }\n\n    head.appendChild(element);\n  });\n  return {\n    oldTags: oldElements,\n    newTags: newElements\n  };\n}\n\n/**\n * Performs client-side updates when new meta info is received\n *\n * @param  {Object} newInfo - the meta info to update to\n */\n\nfunction updateClientMetaInfo(appId, options, newInfo) {\n  options = options || {};\n  var _options = options,\n      ssrAttribute = _options.ssrAttribute,\n      ssrAppId = _options.ssrAppId; // only cache tags for current update\n\n  var tags = {};\n  var htmlTag = getTag(tags, 'html'); // if this is a server render, then dont update\n\n  if (appId === ssrAppId && htmlTag.hasAttribute(ssrAttribute)) {\n    // remove the server render attribute so we can update on (next) changes\n    removeAttribute(htmlTag, ssrAttribute); // add load callbacks if the\n\n    var addLoadListeners = false;\n    tagsSupportingOnload.forEach(function (type) {\n      if (newInfo[type] && addCallbacks(options, type, newInfo[type])) {\n        addLoadListeners = true;\n      }\n    });\n\n    if (addLoadListeners) {\n      addListeners();\n    }\n\n    return false;\n  } // initialize tracked changes\n\n\n  var tagsAdded = {};\n  var tagsRemoved = {};\n\n  for (var type in newInfo) {\n    // ignore these\n    if (includes(metaInfoOptionKeys, type)) {\n      continue;\n    }\n\n    if (type === 'title') {\n      // update the title\n      updateTitle(newInfo.title);\n      continue;\n    }\n\n    if (includes(metaInfoAttributeKeys, type)) {\n      var tagName = type.substr(0, 4);\n      updateAttribute(appId, options, type, newInfo[type], getTag(tags, tagName));\n      continue;\n    } // tags should always be an array, ignore if it isnt\n\n\n    if (!isArray(newInfo[type])) {\n      continue;\n    }\n\n    var _updateTag = updateTag(appId, options, type, newInfo[type], getTag(tags, 'head'), getTag(tags, 'body')),\n        oldTags = _updateTag.oldTags,\n        newTags = _updateTag.newTags;\n\n    if (newTags.length) {\n      tagsAdded[type] = newTags;\n      tagsRemoved[type] = oldTags;\n    }\n  }\n\n  return {\n    tagsAdded: tagsAdded,\n    tagsRemoved: tagsRemoved\n  };\n}\n\nvar appsMetaInfo;\nfunction addApp(rootVm, appId, options) {\n  return {\n    set: function set(metaInfo) {\n      return setMetaInfo(rootVm, appId, options, metaInfo);\n    },\n    remove: function remove() {\n      return removeMetaInfo(rootVm, appId, options);\n    }\n  };\n}\nfunction setMetaInfo(rootVm, appId, options, metaInfo) {\n  // if a vm exists _and_ its mounted then immediately update\n  if (rootVm && rootVm.$el) {\n    return updateClientMetaInfo(appId, options, metaInfo);\n  } // store for later, the info\n  // will be set on the first refresh\n\n\n  appsMetaInfo = appsMetaInfo || {};\n  appsMetaInfo[appId] = metaInfo;\n}\nfunction removeMetaInfo(rootVm, appId, options) {\n  if (rootVm && rootVm.$el) {\n    var tags = {};\n\n    var _iterator = _createForOfIteratorHelper(metaInfoAttributeKeys),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var type = _step.value;\n        var tagName = type.substr(0, 4);\n        updateAttribute(appId, options, type, {}, getTag(tags, tagName));\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    return removeElementsByAppId(options, appId);\n  }\n\n  if (appsMetaInfo[appId]) {\n    delete appsMetaInfo[appId];\n    clearAppsMetaInfo();\n  }\n}\nfunction getAppsMetaInfo() {\n  return appsMetaInfo;\n}\nfunction clearAppsMetaInfo(force) {\n  if (force || !Object.keys(appsMetaInfo).length) {\n    appsMetaInfo = undefined;\n  }\n}\n\n/**\n * Returns the correct meta info for the given component\n * (child components will overwrite parent meta info)\n *\n * @param  {Object} component - the Vue instance to get meta info from\n * @return {Object} - returned meta info\n */\n\nfunction getMetaInfo(options, info, escapeSequences, component) {\n  options = options || {};\n  escapeSequences = escapeSequences || [];\n  var _options = options,\n      tagIDKeyName = _options.tagIDKeyName; // Remove all \"template\" tags from meta\n  // backup the title chunk in case user wants access to it\n\n  if (info.title) {\n    info.titleChunk = info.title;\n  } // replace title with populated template\n\n\n  if (info.titleTemplate && info.titleTemplate !== '%s') {\n    applyTemplate({\n      component: component,\n      contentKeyName: 'title'\n    }, info, info.titleTemplate, info.titleChunk || '');\n  } // convert base tag to an array so it can be handled the same way\n  // as the other tags\n\n\n  if (info.base) {\n    info.base = Object.keys(info.base).length ? [info.base] : [];\n  }\n\n  if (info.meta) {\n    // remove meta items with duplicate vmid's\n    info.meta = info.meta.filter(function (metaItem, index, arr) {\n      var hasVmid = !!metaItem[tagIDKeyName];\n\n      if (!hasVmid) {\n        return true;\n      }\n\n      var isFirstItemForVmid = index === findIndex(arr, function (item) {\n        return item[tagIDKeyName] === metaItem[tagIDKeyName];\n      });\n      return isFirstItemForVmid;\n    }); // apply templates if needed\n\n    info.meta.forEach(function (metaObject) {\n      return applyTemplate(options, metaObject);\n    });\n  }\n\n  return escapeMetaInfo(options, info, escapeSequences);\n}\n\n/**\n * When called, will update the current meta info with new meta info.\n * Useful when updating meta info as the result of an asynchronous\n * action that resolves after the initial render takes place.\n *\n * Credit to [Sébastien Chopin](https://github.com/Atinux) for the suggestion\n * to implement this method.\n *\n * @return {Object} - new meta info\n */\n\nfunction refresh(rootVm, options) {\n  options = options || {}; // make sure vue-meta was initiated\n\n  if (!rootVm[rootConfigKey]) {\n    showWarningNotSupported();\n    return {};\n  } // collect & aggregate all metaInfo $options\n\n\n  var rawInfo = getComponentMetaInfo(options, rootVm);\n  var metaInfo = getMetaInfo(options, rawInfo, clientSequences, rootVm);\n  var appId = rootVm[rootConfigKey].appId;\n  var tags = updateClientMetaInfo(appId, options, metaInfo); // emit \"event\" with new info\n\n  if (tags && isFunction(metaInfo.changed)) {\n    metaInfo.changed(metaInfo, tags.tagsAdded, tags.tagsRemoved);\n    tags = {\n      addedTags: tags.tagsAdded,\n      removedTags: tags.tagsRemoved\n    };\n  }\n\n  var appsMetaInfo = getAppsMetaInfo();\n\n  if (appsMetaInfo) {\n    for (var additionalAppId in appsMetaInfo) {\n      updateClientMetaInfo(additionalAppId, options, appsMetaInfo[additionalAppId]);\n      delete appsMetaInfo[additionalAppId];\n    }\n\n    clearAppsMetaInfo(true);\n  }\n\n  return {\n    vm: rootVm,\n    metaInfo: metaInfo,\n    // eslint-disable-line object-shorthand\n    tags: tags\n  };\n}\n\n/**\n * Generates tag attributes for use on the server.\n *\n * @param  {('bodyAttrs'|'htmlAttrs'|'headAttrs')} type - the type of attributes to generate\n * @param  {Object} data - the attributes to generate\n * @return {Object} - the attribute generator\n */\n\nfunction attributeGenerator(options, type, data, _ref) {\n  var addSsrAttribute = _ref.addSsrAttribute;\n\n  var _ref2 = options || {},\n      attribute = _ref2.attribute,\n      ssrAttribute = _ref2.ssrAttribute;\n\n  var attributeStr = '';\n\n  for (var attr in data) {\n    var attrData = data[attr];\n    var attrValues = [];\n\n    for (var appId in attrData) {\n      attrValues.push.apply(attrValues, _toConsumableArray([].concat(attrData[appId])));\n    }\n\n    if (attrValues.length) {\n      attributeStr += booleanHtmlAttributes.includes(attr) && attrValues.some(Boolean) ? \"\".concat(attr) : \"\".concat(attr, \"=\\\"\").concat(attrValues.join(' '), \"\\\"\");\n      attributeStr += ' ';\n    }\n  }\n\n  if (attributeStr) {\n    attributeStr += \"\".concat(attribute, \"=\\\"\").concat(encodeURI(JSON.stringify(data)), \"\\\"\");\n  }\n\n  if (type === 'htmlAttrs' && addSsrAttribute) {\n    return \"\".concat(ssrAttribute).concat(attributeStr ? ' ' : '').concat(attributeStr);\n  }\n\n  return attributeStr;\n}\n\n/**\n * Generates title output for the server\n *\n * @param  {'title'} type - the string \"title\"\n * @param  {String} data - the title text\n * @return {Object} - the title generator\n */\nfunction titleGenerator(options, type, data, generatorOptions) {\n  var _ref = generatorOptions || {},\n      ln = _ref.ln;\n\n  if (!data) {\n    return '';\n  }\n\n  return \"<\".concat(type, \">\").concat(data, \"</\").concat(type, \">\").concat(ln ? '\\n' : '');\n}\n\n/**\n * Generates meta, base, link, style, script, noscript tags for use on the server\n *\n * @param  {('meta'|'base'|'link'|'style'|'script'|'noscript')} the name of the tag\n * @param  {(Array<Object>|Object)} tags - an array of tag objects or a single object in case of base\n * @return {Object} - the tag generator\n */\n\nfunction tagGenerator(options, type, tags, generatorOptions) {\n  var _ref = options || {},\n      ssrAppId = _ref.ssrAppId,\n      attribute = _ref.attribute,\n      tagIDKeyName = _ref.tagIDKeyName;\n\n  var _ref2 = generatorOptions || {},\n      appId = _ref2.appId,\n      _ref2$isSSR = _ref2.isSSR,\n      isSSR = _ref2$isSSR === void 0 ? true : _ref2$isSSR,\n      _ref2$body = _ref2.body,\n      body = _ref2$body === void 0 ? false : _ref2$body,\n      _ref2$pbody = _ref2.pbody,\n      pbody = _ref2$pbody === void 0 ? false : _ref2$pbody,\n      _ref2$ln = _ref2.ln,\n      ln = _ref2$ln === void 0 ? false : _ref2$ln;\n\n  var dataAttributes = [tagIDKeyName].concat(_toConsumableArray(commonDataAttributes));\n\n  if (!tags || !tags.length) {\n    return '';\n  } // build a string containing all tags of this type\n\n\n  return tags.reduce(function (tagsStr, tag) {\n    if (tag.skip) {\n      return tagsStr;\n    }\n\n    var tagKeys = Object.keys(tag);\n\n    if (tagKeys.length === 0) {\n      return tagsStr; // Bail on empty tag object\n    }\n\n    if (Boolean(tag.body) !== body || Boolean(tag.pbody) !== pbody) {\n      return tagsStr;\n    }\n\n    var attrs = tag.once ? '' : \" \".concat(attribute, \"=\\\"\").concat(appId || (isSSR === false ? '1' : ssrAppId), \"\\\"\"); // build a string containing all attributes of this tag\n\n    for (var attr in tag) {\n      // these attributes are treated as children on the tag\n      if (tagAttributeAsInnerContent.includes(attr) || tagProperties.includes(attr)) {\n        continue;\n      }\n\n      if (attr === 'callback') {\n        attrs += ' onload=\"this.__vm_l=1\"';\n        continue;\n      } // these form the attribute list for this tag\n\n\n      var prefix = '';\n\n      if (dataAttributes.includes(attr)) {\n        prefix = 'data-';\n      }\n\n      var isBooleanAttr = !prefix && booleanHtmlAttributes.includes(attr);\n\n      if (isBooleanAttr && !tag[attr]) {\n        continue;\n      }\n\n      attrs += \" \".concat(prefix).concat(attr) + (isBooleanAttr ? '' : \"=\\\"\".concat(tag[attr], \"\\\"\"));\n    }\n\n    var json = '';\n\n    if (tag.json) {\n      json = JSON.stringify(tag.json);\n    } // grab child content from one of these attributes, if possible\n\n\n    var content = tag.innerHTML || tag.cssText || json; // generate tag exactly without any other redundant attribute\n    // these tags have no end tag\n\n    var hasEndTag = !tagsWithoutEndTag.includes(type); // these tag types will have content inserted\n\n    var hasContent = hasEndTag && tagsWithInnerContent.includes(type); // the final string for this specific tag\n\n    return \"\".concat(tagsStr, \"<\").concat(type).concat(attrs).concat(!hasContent && hasEndTag ? '/' : '', \">\") + (hasContent ? \"\".concat(content, \"</\").concat(type, \">\") : '') + (ln ? '\\n' : '');\n  }, '');\n}\n\n/**\n * Converts a meta info property to one that can be stringified on the server\n *\n * @param  {String} type - the type of data to convert\n * @param  {(String|Object|Array<Object>)} data - the data value\n * @return {Object} - the new injector\n */\n\nfunction generateServerInjector(options, metaInfo, globalInjectOptions) {\n  var serverInjector = {\n    data: metaInfo,\n    extraData: undefined,\n    addInfo: function addInfo(appId, metaInfo) {\n      this.extraData = this.extraData || {};\n      this.extraData[appId] = metaInfo;\n    },\n    callInjectors: function callInjectors(opts) {\n      var m = this.injectors; // only call title for the head\n\n      return (opts.body || opts.pbody ? '' : m.title.text(opts)) + m.meta.text(opts) + m.base.text(opts) + m.link.text(opts) + m.style.text(opts) + m.script.text(opts) + m.noscript.text(opts);\n    },\n    injectors: {\n      head: function head(ln) {\n        return serverInjector.callInjectors(_objectSpread2(_objectSpread2({}, globalInjectOptions), {}, {\n          ln: ln\n        }));\n      },\n      bodyPrepend: function bodyPrepend(ln) {\n        return serverInjector.callInjectors(_objectSpread2(_objectSpread2({}, globalInjectOptions), {}, {\n          ln: ln,\n          pbody: true\n        }));\n      },\n      bodyAppend: function bodyAppend(ln) {\n        return serverInjector.callInjectors(_objectSpread2(_objectSpread2({}, globalInjectOptions), {}, {\n          ln: ln,\n          body: true\n        }));\n      }\n    }\n  };\n\n  var _loop = function _loop(type) {\n    if (metaInfoOptionKeys.includes(type)) {\n      return \"continue\";\n    }\n\n    serverInjector.injectors[type] = {\n      text: function text(injectOptions) {\n        var addSsrAttribute = injectOptions === true;\n        injectOptions = _objectSpread2(_objectSpread2({\n          addSsrAttribute: addSsrAttribute\n        }, globalInjectOptions), injectOptions);\n\n        if (type === 'title') {\n          return titleGenerator(options, type, serverInjector.data[type], injectOptions);\n        }\n\n        if (metaInfoAttributeKeys.includes(type)) {\n          var attributeData = {};\n          var data = serverInjector.data[type];\n\n          if (data) {\n            var appId = injectOptions.isSSR === false ? '1' : options.ssrAppId;\n\n            for (var attr in data) {\n              attributeData[attr] = _defineProperty({}, appId, data[attr]);\n            }\n          }\n\n          if (serverInjector.extraData) {\n            for (var _appId in serverInjector.extraData) {\n              var _data = serverInjector.extraData[_appId][type];\n\n              if (_data) {\n                for (var _attr in _data) {\n                  attributeData[_attr] = _objectSpread2(_objectSpread2({}, attributeData[_attr]), {}, _defineProperty({}, _appId, _data[_attr]));\n                }\n              }\n            }\n          }\n\n          return attributeGenerator(options, type, attributeData, injectOptions);\n        }\n\n        var str = tagGenerator(options, type, serverInjector.data[type], injectOptions);\n\n        if (serverInjector.extraData) {\n          for (var _appId2 in serverInjector.extraData) {\n            var _data2 = serverInjector.extraData[_appId2][type];\n            var extraStr = tagGenerator(options, type, _data2, _objectSpread2({\n              appId: _appId2\n            }, injectOptions));\n            str = \"\".concat(str).concat(extraStr);\n          }\n        }\n\n        return str;\n      }\n    };\n  };\n\n  for (var type in defaultInfo) {\n    var _ret = _loop(type);\n\n    if (_ret === \"continue\") continue;\n  }\n\n  return serverInjector;\n}\n\n/**\n * Converts the state of the meta info object such that each item\n * can be compiled to a tag string on the server\n *\n * @vm {Object} - Vue instance - ideally the root component\n * @return {Object} - server meta info with `toString` methods\n */\n\nfunction inject(rootVm, options, injectOptions) {\n  // make sure vue-meta was initiated\n  if (!rootVm[rootConfigKey]) {\n    showWarningNotSupported();\n    return {};\n  } // collect & aggregate all metaInfo $options\n\n\n  var rawInfo = getComponentMetaInfo(options, rootVm);\n  var metaInfo = getMetaInfo(options, rawInfo, serverSequences, rootVm); // generate server injector\n\n  var serverInjector = generateServerInjector(options, metaInfo, injectOptions); // add meta info from additional apps\n\n  var appsMetaInfo = getAppsMetaInfo();\n\n  if (appsMetaInfo) {\n    for (var additionalAppId in appsMetaInfo) {\n      serverInjector.addInfo(additionalAppId, appsMetaInfo[additionalAppId]);\n      delete appsMetaInfo[additionalAppId];\n    }\n\n    clearAppsMetaInfo(true);\n  }\n\n  return serverInjector.injectors;\n}\n\nfunction $meta(options) {\n  options = options || {};\n  /**\n   * Returns an injector for server-side rendering.\n   * @this {Object} - the Vue instance (a root component)\n   * @return {Object} - injector\n   */\n\n  var $root = this.$root;\n  return {\n    getOptions: function getOptions$1() {\n      return getOptions(options);\n    },\n    setOptions: function setOptions(newOptions) {\n      var refreshNavKey = 'refreshOnceOnNavigation';\n\n      if (newOptions && newOptions[refreshNavKey]) {\n        options.refreshOnceOnNavigation = !!newOptions[refreshNavKey];\n        addNavGuards($root);\n      }\n\n      var debounceWaitKey = 'debounceWait';\n\n      if (newOptions && debounceWaitKey in newOptions) {\n        var debounceWait = parseInt(newOptions[debounceWaitKey]);\n\n        if (!isNaN(debounceWait)) {\n          options.debounceWait = debounceWait;\n        }\n      }\n\n      var waitOnDestroyedKey = 'waitOnDestroyed';\n\n      if (newOptions && waitOnDestroyedKey in newOptions) {\n        options.waitOnDestroyed = !!newOptions[waitOnDestroyedKey];\n      }\n    },\n    refresh: function refresh$1() {\n      return refresh($root, options);\n    },\n    inject: function inject$1(injectOptions) {\n      return  inject($root, options, injectOptions) ;\n    },\n    pause: function pause$1() {\n      return pause($root);\n    },\n    resume: function resume$1() {\n      return resume($root);\n    },\n    addApp: function addApp$1(appId) {\n      return addApp($root, appId, options);\n    }\n  };\n}\n\nfunction generate(rawInfo, options) {\n  options = setOptions(options);\n  var metaInfo = getMetaInfo(options, rawInfo, serverSequences);\n  var serverInjector = generateServerInjector(options, metaInfo);\n  return serverInjector.injectors;\n}\n\n/**\n * Plugin install function.\n * @param {Function} Vue - the Vue constructor.\n */\n\nfunction install(Vue, options) {\n  if (Vue.__vuemeta_installed) {\n    return;\n  }\n\n  Vue.__vuemeta_installed = true;\n  options = setOptions(options);\n\n  Vue.prototype.$meta = function () {\n    return $meta.call(this, options);\n  };\n\n  Vue.mixin(createMixin(Vue, options));\n}\n\nvar index = {\n  version: version,\n  install: install,\n  generate: function generate$1(metaInfo, options) {\n    return  generate(metaInfo, options) ;\n  },\n  hasMetaInfo: hasMetaInfo\n};\n\nexport default index;\n"],"sourceRoot":""}