/*
 * To reduce build size, this file provides simple polyfills without
 * overly excessive type checking and without modifying
 * the global Array.prototype
 * The polyfills are automatically removed in the commonjs build
 * Also, only files in client/ & shared/ should use these functions
 * files in server/ still use normal js function
 */

/*
 * not type checking this file because flow doesn't play well with
 * dynamically accessing methods on Array prototype
 */

/*  */

/* , endPosition = @length */

/* , fromIndex = 0 */

/* , mapfn = undefined, thisArg = undefined */

/* , position = 0 */

/* 0 */

/* 1 */

/* 10 */

/* 100 */

/* 101 */

/* 102 */

/* 103 */

/* 104 */

/* 105 */

/* 106 */

/* 107 */

/* 108 */

/* 109 */

/* 11 */

/* 110 */

/* 111 */

/* 112 */

/* 113 */

/* 114 */

/* 115 */

/* 116 */

/* 117 */

/* 118 */

/* 119 */

/* 12 */

/* 120 */

/* 121 */

/* 122 */

/* 123 */

/* 124 */

/* 125 */

/* 126 */

/* 127 */

/* 128 */

/* 129 */

/* 13 */

/* 130 */

/* 131 */

/* 132 */

/* 133 */

/* 134 */

/* 135 */

/* 136 */

/* 137 */

/* 138 */

/* 139 */

/* 14 */

/* 140 */

/* 141 */

/* 142 */

/* 143 */

/* 144 */

/* 145 */

/* 146 */

/* 147 */

/* 148 */

/* 149 */

/* 15 */

/* 150 */

/* 151 */

/* 152 */

/* 153 */

/* 154 */

/* 155 */

/* 156 */

/* 157 */

/* 158 */

/* 159 */

/* 16 */

/* 160 */

/* 161 */

/* 162 */

/* 163 */

/* 164 */

/* 165 */

/* 166 */

/* 167 */

/* 168 */

/* 169 */

/* 17 */

/* 170 */

/* 171 */

/* 172 */

/* 173 */

/* 174 */

/* 175 */

/* 176 */

/* 177 */

/* 178 */

/* 179 */

/* 18 */

/* 180 */

/* 181 */

/* 182 */

/* 183 */

/* 184 */

/* 185 */

/* 186 */

/* 187 */

/* 188 */

/* 189 */

/* 19 */

/* 190 */

/* 191 */

/* 192 */

/* 193 */

/* 194 */

/* 195 */

/* 196 */

/* 197 */

/* 198 */

/* 199 */

/* 2 */

/* 20 */

/* 200 */

/* 201 */

/* 202 */

/* 203 */

/* 204 */

/* 205 */

/* 206 */

/* 207 */

/* 208 */

/* 209 */

/* 21 */

/* 210 */

/* 211 */

/* 212 */

/* 213 */

/* 214 */

/* 215 */

/* 216 */

/* 217 */

/* 218 */

/* 219 */

/* 22 */

/* 220 */

/* 221 */

/* 222 */

/* 223 */

/* 224 */

/* 225 */

/* 226 */

/* 227 */

/* 228 */

/* 229 */

/* 23 */

/* 230 */

/* 231 */

/* 232 */

/* 233 */

/* 234 */

/* 235 */

/* 236 */

/* 237 */

/* 238 */

/* 239 */

/* 24 */

/* 240 */

/* 241 */

/* 242 */

/* 243 */

/* 244 */

/* 245 */

/* 246 */

/* 247 */

/* 248 */

/* 249 */

/* 25 */

/* 250 */

/* 251 */

/* 252 */

/* 253 */

/* 254 */

/* 255 */

/* 256 */

/* 257 */

/* 258 */

/* 259 */

/* 26 */

/* 260 */

/* 261 */

/* 262 */

/* 263 */

/* 264 */

/* 265 */

/* 266 */

/* 267 */

/* 268 */

/* 269 */

/* 27 */

/* 270 */

/* 271 */

/* 272 */

/* 273 */

/* 274 */

/* 275 */

/* 276 */

/* 277 */

/* 278 */

/* 279 */

/* 28 */

/* 280 */

/* 281 */

/* 282 */

/* 283 */

/* 284 */

/* 285 */

/* 286 */

/* 287 */

/* 288 */

/* 289 */

/* 29 */

/* 290 */

/* 291 */

/* 292 */

/* 293 */

/* 294 */

/* 295 */

/* 296 */

/* 297 */

/* 298 */

/* 299 */

/* 3 */

/* 30 */

/* 300 */

/* 301 */

/* 302 */

/* 303 */

/* 304 */

/* 305 */

/* 306 */

/* 307 */

/* 308 */

/* 309 */

/* 31 */

/* 310 */

/* 311 */

/* 312 */

/* 313 */

/* 314 */

/* 315 */

/* 316 */

/* 317 */

/* 318 */

/* 319 */

/* 32 */

/* 320 */

/* 321 */

/* 322 */

/* 323 */

/* 324 */

/* 325 */

/* 326 */

/* 327 */

/* 328 */

/* 329 */

/* 33 */

/* 330 */

/* 331 */

/* 332 */

/* 333 */

/* 334 */

/* 335 */

/* 336 */

/* 337 */

/* 338 */

/* 339 */

/* 34 */

/* 340 */

/* 341 */

/* 342 */

/* 343 */

/* 344 */

/* 345 */

/* 346 */

/* 347 */

/* 348 */

/* 349 */

/* 35 */

/* 350 */

/* 351 */

/* 352 */

/* 353 */

/* 354 */

/* 355 */

/* 356 */

/* 357 */

/* 358 */

/* 359 */

/* 36 */

/* 360 */

/* 361 */

/* 362 */

/* 363 */

/* 364 */

/* 365 */

/* 366 */

/* 367 */

/* 368 */

/* 369 */

/* 37 */

/* 370 */

/* 371 */

/* 372 */

/* 373 */

/* 374 */

/* 375 */

/* 376 */

/* 377 */

/* 378 */

/* 379 */

/* 38 */

/* 380 */

/* 381 */

/* 382 */

/* 383 */

/* 384 */

/* 385 */

/* 386 */

/* 387 */

/* 388 */

/* 389 */

/* 39 */

/* 390 */

/* 391 */

/* 392 */

/* 393 */

/* 394 */

/* 395 */

/* 396 */

/* 397 */

/* 398 */

/* 399 */

/* 4 */

/* 40 */

/* 400 */

/* 401 */

/* 402 */

/* 403 */

/* 404 */

/* 405 */

/* 406 */

/* 407 */

/* 408 */

/* 409 */

/* 41 */

/* 410 */

/* 411 */

/* 412 */

/* 413 */

/* 414 */

/* 415 */

/* 416 */

/* 417 */

/* 418 */

/* 419 */

/* 42 */

/* 420 */

/* 421 */

/* 422 */

/* 423 */

/* 424 */

/* 425 */

/* 426 */

/* 427 */

/* 428 */

/* 429 */

/* 43 */

/* 430 */

/* 431 */

/* 432 */

/* 433 */

/* 434 */

/* 435 */

/* 436 */

/* 437 */

/* 438 */

/* 439 */

/* 44 */

/* 440 */

/* 441 */

/* 442 */

/* 443 */

/* 444 */

/* 445 */

/* 446 */

/* 447 */

/* 448 */

/* 449 */

/* 45 */

/* 450 */

/* 451 */

/* 452 */

/* 453 */

/* 454 */

/* 455 */

/* 456 */

/* 457 */

/* 458 */

/* 459 */

/* 46 */

/* 460 */

/* 461 */

/* 462 */

/* 463 */

/* 464 */

/* 465 */

/* 466 */

/* 467 */

/* 468 */

/* 469 */

/* 47 */

/* 470 */

/* 471 */

/* 472 */

/* 473 */

/* 474 */

/* 475 */

/* 476 */

/* 477 */

/* 478 */

/* 479 */

/* 48 */

/* 480 */

/* 481 */

/* 482 */

/* 483 */

/* 484 */

/* 485 */

/* 486 */

/* 487 */

/* 488 */

/* 489 */

/* 49 */

/* 490 */

/* 491 */

/* 492 */

/* 493 */

/* 494 */

/* 495 */

/* 496 */

/* 497 */

/* 498 */

/* 499 */

/* 5 */

/* 50 */

/* 500 */

/* 501 */

/* 502 */

/* 503 */

/* 504 */

/* 505 */

/* 506 */

/* 507 */

/* 508 */

/* 509 */

/* 51 */

/* 510 */

/* 511 */

/* 512 */

/* 513 */

/* 514 */

/* 515 */

/* 516 */

/* 517 */

/* 518 */

/* 519 */

/* 52 */

/* 520 */

/* 521 */

/* 522 */

/* 523 */

/* 524 */

/* 525 */

/* 526 */

/* 527 */

/* 528 */

/* 529 */

/* 53 */

/* 530 */

/* 531 */

/* 532 */

/* 533 */

/* 534 */

/* 535 */

/* 536 */

/* 537 */

/* 538 */

/* 539 */

/* 54 */

/* 540 */

/* 541 */

/* 542 */

/* 543 */

/* 544 */

/* 545 */

/* 546 */

/* 547 */

/* 548 */

/* 549 */

/* 55 */

/* 550 */

/* 551 */

/* 56 */

/* 57 */

/* 58 */

/* 59 */

/* 6 */

/* 60 */

/* 61 */

/* 62 */

/* 63 */

/* 64 */

/* 65 */

/* 66 */

/* 67 */

/* 68 */

/* 69 */

/* 7 */

/* 70 */

/* 71 */

/* 72 */

/* 73 */

/* 74 */

/* 75 */

/* 76 */

/* 77 */

/* 78 */

/* 79 */

/* 8 */

/* 80 */

/* 81 */

/* 82 */

/* 83 */

/* 84 */

/* 85 */

/* 86 */

/* 87 */

/* 88 */

/* 89 */

/* 9 */

/* 90 */

/* 91 */

/* 92 */

/* 93 */

/* 94 */

/* 95 */

/* 96 */

/* 97 */

/* 98 */

/* 99 */

/* IE9 doesnt seem to load scripts synchronously,
       * causing a script sometimes/often already to be loaded
       * when we add the event listener below (thus adding an onload event
       * listener has no use because it will never be triggered).
       * Therefore we add the onload attribute during ssr, and
       * check here if it was already loaded or not
       */

/* Ignore */

/* Mark that the callback for this element has already been called,
         * this prevents the callback to run twice in some (rare) conditions
         */

/* Vue component instance */

/* WEBPACK VAR INJECTION */

/* __vm_cb: whether the load callback has been called
       * __vm_l: set by onload attribute, whether the element was loaded
       * __vm_ev: whether the event listener was added or not
       */

/* asRootData */

/* direct */

/* empty */

/* eslint-disable dot-notation */

/* eslint-disable no-proto */

/* eslint-disable no-self-compare */

/* eslint-disable no-unused-vars */

/* eslint-enable dot-notation */

/* eslint-enable no-proto */

/* eslint-enable no-self-compare */

/* eslint-enable no-unused-vars */

/* globals __VUE_SSR_CONTEXT__ */

/* harmony default export */

/* harmony export (binding) */

/* harmony import */

/* hydrating */

/* isRenderWatcher */

/* istanbul ignore else */

/* istanbul ignore if */

/* istanbul ignore next */

/* istanbul ignore next, $flow-disable-line */

/* not type checking this file because flow doesn't play well with Proxy */

/* onload needs to be removed because we only need the
         * attribute after ssr and if we dont remove it the node
         * will fail isEqualNode on the client
         */

/* removeOnly */

/* server only */

/* true */

/* unused harmony export Store */

/* unused harmony export createLogger */

/* unused harmony export createNamespacedHelpers */

/* unused harmony export install */

/* unused harmony export mapGetters */

/* unused harmony export mapMutations */

/* unused harmony export mapState */

/* vue-cli only */

/*!
  * vue-router v3.4.3
  * (c) 2020 Evan You
  * @license MIT
  */

/*!
 * Vue.js v2.6.12
 * (c) 2014-2020 Evan You
 * Released under the MIT License.
 */

/*!
 * cookie
 * Copyright(c) 2012-2014 Roman Shtylman
 * Copyright(c) 2015 Douglas Christopher Wilson
 * MIT Licensed
 */

/*!
 * vuex v3.5.1
 * (c) 2020 Evan You
 * @license MIT
 */

/*#__PURE__*/

/**
    * Determine if a URL shares the same origin as the current location
    *
    * @param {String} requestURL The URL to test
    * @returns {boolean} True if URL shares the same origin, otherwise false
    */

/**
    * Parse a URL to discover it's components
    *
    * @param {String} url The URL to be parsed
    * @returns {Object}
    */

/**
   * A timeout in milliseconds to abort a request. If set to 0 (default) a
   * timeout is not created.
   */

/**
   * Check if a tag is an unknown element.
   * Platform-dependent.
   */

/**
   * Check if a tag is reserved so that it cannot be registered as a
   * component. This is platform-dependent and may be overwritten.
   */

/**
   * Check if an attribute is reserved so that it cannot be used as a component
   * prop. This is platform-dependent and may be overwritten.
   */

/**
   * Check if an attribute must be bound using property, e.g. value
   * Platform-dependent.
   */

/**
   * Class inheritance
   */

/**
   * Create asset registration methods.
   */

/**
   * Custom user key aliases for v-on
   */

/**
   * Each instance constructor, including Vue, has a unique
   * cid. This enables us to create wrapped "child
   * constructors" for prototypal inheritance and cache them.
   */

/**
   * Error handler for watcher errors
   */

/**
   * Exposed for legacy reasons
   */

/**
   * Get the namespace of an element
   */

/**
   * Ignore certain custom elements
   */

/**
   * Option merge strategies (used in core/util/options)
   */

/**
   * Parse the real tag name for the specific platform.
   */

/**
   * Perform updates asynchronously. Intended to be used by Vue Test Utils
   * This will significantly reduce performance if set to false.
   */

/**
   * Returns an injector for server-side rendering.
   * @this {Object} - the Vue instance (a root component)
   * @return {Object} - injector
   */

/**
   * Show production mode tip message on boot?
   */

/**
   * Vuex init hook, injected into each instances init hooks list.
   */

/**
   * Warn handler for watcher warns
   */

/**
   * Whether to enable devtools
   */

/**
   * Whether to record perf
   */

/**
   * Whether to suppress warnings.
   */

/**
 * A `CancelToken` is an object that can be used to request cancellation of an operation.
 *
 * @class
 * @param {Function} executor The executor function.
 */

/**
 * A `Cancel` is an object that is thrown when an operation is canceled.
 *
 * @class
 * @param {string=} message The message.
 */

/**
 * A watcher parses an expression, collects dependencies,
 * and fires callback when the expression value changes.
 * This is used for both the $watch() api and directives.
 */

/**
 * Accepts varargs expecting each argument to be an object, then
 * immutably merges the properties of each object and returns result.
 *
 * When multiple objects contain the same key the later object in
 * the arguments list will take precedence.
 *
 * Example:
 *
 * ```js
 * var result = merge({foo: 123}, {foo: 456});
 * console.log(result.foo); // outputs 456
 * ```
 *
 * @param {Object} obj1 Object to merge
 * @returns {Object} Result of all merge properties
 */

/**
 * Add a dependency to this directive.
 */

/**
 * Add a new interceptor to the stack
 *
 * @param {Function} fulfilled The function to handle `then` for a `Promise`
 * @param {Function} rejected The function to handle `reject` for a `Promise`
 *
 * @return {Number} An ID used to remove interceptor later
 */

/**
 * Add class with compatibility for SVG since classList is not supported on
 * SVG elements in IE
 */

/**
 * Always return false.
 */

/**
 * Assert whether a prop is valid.
 */

/**
 * Assets
 *
 * When a vm is present (instance creation), we need to do
 * a three-way merge between constructor options, instance
 * options and parent options.
 */

/**
 * Attach the keys as a property of the regexp.
 *
 * @param  {!RegExp} re
 * @param  {Array}   keys
 * @return {!RegExp}
 */

/**
 * Attempt to create an observer instance for a value,
 * returns the new observer if successfully observed,
 * or the existing observer if the value already has one.
 */

/**
 * Augment a target Object or Array by defining
 * hidden properties.
 */

/**
 * Augment a target Object or Array by intercepting
 * the prototype chain using __proto__
 */

/**
 * Build a URL by appending params to the end
 *
 * @param {string} url The base of the url (e.g., http://www.google.com)
 * @param {object} [params] The params to be appended
 * @returns {string} The formatted url
 */

/**
 * Camelize a hyphen-delimited string.
 */

/**
 * Check if a string starts with $ or _
 */

/**
 * Check if a tag is a built-in tag.
 */

/**
 * Check if an attribute is a reserved attribute.
 */

/**
 * Check if two values are loosely equal - that is,
 * if they are plain objects, do they have the same shape?
 */

/**
 * Check if val is a valid array index.
 */

/**
 * Check if value is primitive.
 */

/**
 * Check whether an object has the property.
 */

/**
 * Clean up for dependency collection.
 */

/**
 * Collect dependencies on array elements when the array is touched, since
 * we cannot intercept array element access like property getters.
 */

/**
 * Compile a string to a template function for the path.
 *
 * @param  {string}             str
 * @param  {Object=}            options
 * @return {!function(Object=, Object=)}
 */

/**
 * Config-specific merge-function which creates a new config-object
 * by merging two configuration objects together.
 *
 * @param {Object} config1
 * @param {Object} config2
 * @returns {Object} New object resulting from merging config2 to config1
 */

/**
 * Convert a value to a string that is actually rendered.
 */

/**
 * Convert an Array-like object to a real Array.
 */

/**
 * Convert an input value to a number for persistence.
 * If the conversion fails, return original string.
 */

/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/**
 * Create a cached version of a pure function.
 */

/**
 * Create a new instance of Axios
 *
 * @param {Object} instanceConfig The default config for the instance
 */

/**
 * Create a path regexp from string input.
 *
 * @param  {string}  path
 * @param  {!Array}  keys
 * @param  {!Object} options
 * @return {!RegExp}
 */

/**
 * Create an Error with the specified message, config, error code, request and response.
 *
 * @param {string} message The error message.
 * @param {Object} config The config.
 * @param {string} [code] The error code (for example, 'ECONNABORTED').
 * @param {Object} [request] The request.
 * @param {Object} [response] The response.
 * @returns {Error} The created error.
 */

/**
 * Create an instance of Axios
 *
 * @param {Object} defaultConfig The default config for the instance
 * @return {Axios} A new instance of Axios
 */

/**
 * Creates a new URL by combining the baseURL with the requestedURL,
 * only when the requestedURL is not already an absolute URL.
 * If the requestURL is absolute, this function returns the requestedURL untouched.
 *
 * @param {string} baseURL The base URL
 * @param {string} requestedURL Absolute or relative URL to combine
 * @returns {string} The combined full path
 */

/**
 * Creates a new URL by combining the specified URLs
 *
 * @param {string} baseURL The base URL
 * @param {string} relativeURL The relative URL
 * @returns {string} The combined URL
 */

/**
 * Data
 */

/**
 * Deep copy the given object considering circular structure.
 * This function caches all nested objects and its copies.
 * If it detects circular structure, use cached copy to avoid infinite loop.
 *
 * @param {*} obj
 * @param {Array<Object>} cache
 * @return {*}
 */

/**
 * Default strategy.
 */

/**
 * Define a property.
 */

/**
 * Define a reactive property on an Object.
 */

/**
 * Delete a property and trigger change if necessary.
 */

/**
 * Depend on all deps collected by this watcher.
 */

/**
 * Determine if a value is a Blob
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Blob, otherwise false
 */

/**
 * Determine if a value is a Buffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Buffer, otherwise false
 */

/**
 * Determine if a value is a Date
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Date, otherwise false
 */

/**
 * Determine if a value is a File
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a File, otherwise false
 */

/**
 * Determine if a value is a FormData
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an FormData, otherwise false
 */

/**
 * Determine if a value is a Function
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Function, otherwise false
 */

/**
 * Determine if a value is a Number
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Number, otherwise false
 */

/**
 * Determine if a value is a Stream
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Stream, otherwise false
 */

/**
 * Determine if a value is a String
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a String, otherwise false
 */

/**
 * Determine if a value is a URLSearchParams object
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
 */

/**
 * Determine if a value is a plain Object
 *
 * @param {Object} val The value to test
 * @return {boolean} True if value is a plain Object, otherwise false
 */

/**
 * Determine if a value is a view on an ArrayBuffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
 */

/**
 * Determine if a value is an Array
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an Array, otherwise false
 */

/**
 * Determine if a value is an ArrayBuffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
 */

/**
 * Determine if a value is an Object
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an Object, otherwise false
 */

/**
 * Determine if a value is undefined
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if the value is undefined, otherwise false
 */

/**
 * Determine if we're running in a standard browser environment
 *
 * This allows axios to run in a web worker, and react-native.
 * Both environments support XMLHttpRequest, but not fully standard globals.
 *
 * web workers:
 *  typeof window -> undefined
 *  typeof document -> undefined
 *
 * react-native:
 *  navigator.product -> 'ReactNative'
 * nativescript
 *  navigator.product -> 'NativeScript' or 'NS'
 */

/**
 * Determines whether the specified URL is absolute
 *
 * @param {string} url The URL to test
 * @returns {boolean} True if the specified URL is absolute, otherwise false
 */

/**
 * Dispatch a request
 *
 * @param {Object} config The config specific for this request (merged with this.defaults)
 */

/**
 * Dispatch a request to the server using the configured adapter.
 *
 * @param {object} config The config that is to be used for the request
 * @returns {Promise} The Promise to be fulfilled
 */

/**
 * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.
 *
 * @param  {string}
 * @return {string}
 */

/**
 * Ensure a function is called only once.
 */

/**
 * Ensure all props option syntax are normalized into the
 * Object-based format.
 */

/**
 * Escape a regular expression string.
 *
 * @param  {string} str
 * @return {string}
 */

/**
 * Escape the capturing group by escaping special characters and meaning.
 *
 * @param  {string} group
 * @return {string}
 */

/**
 * Evaluate the getter, and re-collect dependencies.
 */

/**
 * Evaluate the value of the watcher.
 * This only gets called for lazy watchers.
 */

/**
 * Expose `pathToRegexp`.
 */

/**
 * Expose a function for taking tokens and returning a RegExp.
 *
 * @param  {!Array}          tokens
 * @param  {(Array|Object)=} keys
 * @param  {Object=}         options
 * @return {!RegExp}
 */

/**
 * Expose a method for transforming tokens into the path function.
 */

/**
 * Extends object a by mutably adding to it the properties of object b.
 *
 * @param {Object} a The object to be extended
 * @param {Object} b The object to copy properties from
 * @param {Object} thisArg The object to bind function to
 * @return {Object} The resulting value of object a
 */

/**
 * Flush both queues and run the watchers.
 */

/**
 * Get the default value of a prop.
 */

/**
 * Get the first item that pass the test
 * by second argument function
 *
 * @param {Array} list
 * @param {Function} f
 * @return {*}
 */

/**
 * Get the flags for a regexp from the options.
 *
 * @param  {Object} options
 * @return {string}
 */

/**
 * Get the raw type string of a value, e.g., [object Object].
 */

/**
 * Helper that recursively merges two data objects together.
 */

/**
 * Hooks and props are merged as arrays.
 */

/**
 * In some cases we may want to disable observation inside a component's
 * update computation.
 */

/**
 * Intercept mutating methods and emit events
 */

/**
 * Iterate over all the registered interceptors
 *
 * This method is particularly useful for skipping over any
 * interceptors that may have become `null` calling `eject`.
 *
 * @param {Function} fn The function to call for each interceptor
 */

/**
 * Iterate over an Array or an Object invoking a function for each item.
 *
 * If `obj` is an Array callback will be called passing
 * the value, index, and complete array for each item.
 *
 * If 'obj' is an Object callback will be called passing
 * the value, key, and complete object for each property.
 *
 * @param {Object|Array} obj The object to iterate
 * @param {Function} fn The callback to invoke for each item
 */

/**
 * Make a map and return a function for checking if a key
 * is in that map.
 */

/**
 * Merge an Array of Objects into a single Object.
 */

/**
 * Merge two option objects into a new one.
 * Core utility used in both instantiation and inheritance.
 */

/**
 * Mix properties into target object.
 */

/**
 * Module exports.
 * @public
 */

/**
 * Module variables.
 * @private
 */

/**
 * Normalize a transition hook's argument length. The hook may be:
 * - a merged hook (invoker) with the original in .fns
 * - a wrapped component method (check ._length)
 * - a plain function (.length)
 */

/**
 * Normalize all injections into Object-based format
 */

/**
 * Normalize raw function directives into object format.
 */

/**
 * Normalize the given path string, returning a regular expression.
 *
 * An empty array can be passed in for the keys, which will hold the
 * placeholder key descriptions. For example, using `/user/:id`, `keys` will
 * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
 *
 * @param  {(string|RegExp|Array)} path
 * @param  {(Array|Object)=}       keys
 * @param  {Object=}               options
 * @return {!RegExp}
 */

/**
 * Normalize the map
 * normalizeMap([1, 2, 3]) => [ { key: 1, val: 1 }, { key: 2, val: 2 }, { key: 3, val: 3 } ]
 * normalizeMap({a: 1, b: 2, c: 3}) => [ { key: 'a', val: 1 }, { key: 'b', val: 2 }, { key: 'c', val: 3 } ]
 * @param {Array|Object} map
 * @return {Object}
 */

/**
 * Not type checking this file because flow doesn't like attaching
 * properties to Elements.
 */

/**
 * Observe a list of Array items.
 */

/**
 * Observer class that is attached to each observed
 * object. Once attached, the observer converts the target
 * object's property keys into getter/setters that
 * collect dependencies and dispatch updates.
 */

/**
 * Option overwriting strategies are functions that handle
 * how to merge a parent option value and a child option
 * value into the final value.
 */

/**
 * Options with restrictions
 */

/**
 * Other object hashes.
 */

/**
 * Parse a cookie header.
 *
 * Parse the given cookie header string into an object
 * The object has the various cookies as keys(names) => values
 *
 * @param {string} str
 * @param {object} [options]
 * @return {object}
 * @public
 */

/**
 * Parse a string for the raw tokens.
 *
 * @param  {string}  str
 * @param  {Object=} options
 * @return {!Array}
 */

/**
 * Parse headers into an object
 *
 * ```
 * Date: Wed, 27 Aug 2014 08:58:49 GMT
 * Content-Type: application/json
 * Connection: keep-alive
 * Transfer-Encoding: chunked
 * ```
 *
 * @param {String} headers Headers needing to be parsed
 * @returns {Object} Headers parsed into an object
 */

/**
 * Parse simple path.
 */

/**
 * Perform no operation.
 * Stubbing args to make Flow happy without leaving useless transpiled code
 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
 */

/**
 * Performs a batched update.
 *
 * @param  {(null|Number)} id - the ID of this update
 * @param  {Function} callback - the update to perform
 * @return {Number} id - a new ID
 */

/**
 * Performs client-side updates when new meta info is received
 *
 * @param  {Object} newInfo - the meta info to update to
 */

/**
 * Plugin install function.
 * @param {Function} Vue - the Vue constructor.
 */

/**
 * Prettier encoding of URI path segments.
 *
 * @param  {string}
 * @return {string}
 */

/**
 * Pull out keys from a regexp.
 *
 * @param  {!RegExp} path
 * @param  {!Array}  keys
 * @return {!RegExp}
 */

/**
 * Push a watcher into the watcher queue.
 * Jobs with duplicate IDs will be skipped unless it's
 * pushed when the queue is being flushed.
 */

/**
 * Query an element selector if it's not an element already.
 */

/**
 * Queue a kept-alive component that was activated during patch.
 * The queue will be processed after the entire tree has been patched.
 */

/**
 * Quick object check - this is primarily used to tell
 * Objects from primitive values when we know the value
 * is a JSON-compliant type.
 */

/**
 * Recursively traverse an object to evoke all converted
 * getters, so that every nested property inside the object
 * is collected as a "deep" dependency.
 */

/**
 * Reduce the code which written in Vue.js for committing the mutation
 * @param {String} [namespace] - Module's namespace
 * @param {Object|Array} mutations # Object's item can be a function which accept `commit` function as the first param, it can accept anthor params. You can commit mutation and do any other things in this function. specially, You need to pass anthor params from the mapped function.
 * @return {Object}
 */

/**
 * Reduce the code which written in Vue.js for getting the state.
 * @param {String} [namespace] - Module's namespace
 * @param {Object|Array} states # Object's item can be a function which accept state and getters for param, you can do something for state and getters in it.
 * @param {Object}
 */

/**
 * Remove an interceptor from the stack
 *
 * @param {Number} id The ID that was returned by `use`
 */

/**
 * Remove an item from an array.
 */

/**
 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
 *
 * @param {string} content with BOM
 * @return {string} content value without BOM
 */

/**
 * Remove class with compatibility for SVG since classList is not supported on
 * SVG elements in IE
 */

/**
 * Remove self from all dependencies' subscriber list.
 */

/**
 * Resolve an asset.
 * This function is used because child instances need access
 * to assets defined in its ancestor chain.
 */

/**
 * Resolve or reject a Promise based on response status.
 *
 * @param {Function} resolve A function that resolves the promise.
 * @param {Function} reject A function that rejects the promise.
 * @param {object} response The response.
 */

/**
 * Return a function expect two param contains namespace and map. it will normalize the namespace and then the param's function will handle the new namespace and the map.
 * @param {Function} fn
 * @return {Function}
 */

/**
 * Return the first index at which a loosely equal value can be
 * found in the array (if value is a plain object, the array must
 * contain an object of the same shape), or -1 if it is not present.
 */

/**
 * Return the same value.
 */

/**
 * Returns an object that contains a new `CancelToken` and a function that, when called,
 * cancels the `CancelToken`.
 */

/**
 * Returns the `opts.option` $option value of the given `opts.component`.
 * If methods are encountered, they will be bound to the component context.
 * If `opts.deep` is true, will recursively merge all child component
 * `opts.option` $option values into the returned result.
 *
 * @param  {Object} opts - options
 * @param  {Object} opts.component - Vue component to fetch option data from
 * @param  {Boolean} opts.deep - look for data in child components as well?
 * @param  {Function} opts.arrayMerge - how should arrays be merged?
 * @param  {String} opts.keyName - the name of the option to look for
 * @param  {Object} [result={}] - result so far
 * @return {Object} result - final aggregated result
 */

/**
 * Returns the correct meta info for the given component
 * (child components will overwrite parent meta info)
 *
 * @param  {Object} component - the Vue instance to get meta info from
 * @return {Object} - returned meta info
 */

/**
 * Runtime helper for checking keyCodes from config.
 * exposed as Vue.prototype._k
 * passing in eventKeyName as last argument separately for backwards compat
 */

/**
 * Runtime helper for merging v-bind="object" into a VNode's data.
 */

/**
 * Runtime helper for rendering <slot>
 */

/**
 * Runtime helper for rendering static trees.
 */

/**
 * Runtime helper for rendering v-for lists.
 */

/**
 * Runtime helper for resolving filters
 */

/**
 * Runtime helper for resolving raw children VNodes into a slot object.
 */

/**
 * Runtime helper for v-once.
 * Effectively it means marking the node as static with a unique key.
 */

/**
 * Scheduler job interface.
 * Will be called by the scheduler.
 */

/**
 * Search a special module from store by namespace. if module not exist, print error message.
 * @param {Object} store
 * @param {String} helper
 * @param {String} namespace
 * @return {Object}
 */

/**
 * Serialize data into a cookie header.
 *
 * Serialize the a name value pair into a cookie string suitable for
 * http headers. An optional options object specified cookie parameters.
 *
 * serialize('foo', 'bar', { httpOnly: true })
 *   => "foo=bar; httpOnly"
 *
 * @param {string} name
 * @param {string} val
 * @param {object} [options]
 * @return {string}
 * @public
 */

/**
 * Set a property on an object. Adds the new property and
 * triggers change notification if the property doesn't
 * already exist.
 */

/**
 * Simple bind polyfill for environments that do not support it,
 * e.g., PhantomJS 1.x. Technically, we don't need this anymore
 * since native bind is now performant enough in most browsers.
 * But removing it would mean breaking code that was able to run in
 * PhantomJS 1.x, so this must be kept for backward compatibility.
 */

/**
 * Strict object type check. Only returns true
 * for plain JavaScript objects.
 */

/**
 * Subscriber interface.
 * Will be called when a dependency changes.
 */

/**
 * Syntactic sugar for invoking a function and expanding an array for arguments.
 *
 * Common use case would be to use `Function.prototype.apply`.
 *
 *  ```js
 *  function f(x, y, z) {}
 *  var args = [1, 2, 3];
 *  f.apply(null, args);
 *  ```
 *
 * With `spread` this example can be re-written.
 *
 *  ```js
 *  spread(function(x, y, z) {})([1, 2, 3]);
 *  ```
 *
 * @param {Function} callback
 * @returns {Function}
 */

/**
 * Throws a `Cancel` if cancellation has been requested.
 */

/**
 * Transform an array into a regexp.
 *
 * @param  {!Array}  path
 * @param  {Array}   keys
 * @param  {!Object} options
 * @return {!RegExp}
 */

/**
 * Transform the data for a request or a response
 *
 * @param {Object|String} data The data to be transformed
 * @param {Array} headers The headers for the request or response
 * @param {Array|Function} fns A single function or Array of functions
 * @returns {*} The resulting transformed data
 */

/**
 * Trim excess whitespace off the beginning and end of a string
 *
 * @param {String} str The String to trim
 * @returns {String} The String freed of excess whitespace
 */

/**
 * Try decoding a string using a decoding function.
 *
 * @param {string} str
 * @param {function} decode
 * @private
 */

/**
 * Update an Error with the specified config, error code, and response.
 *
 * @param {Error} error The error to update.
 * @param {Object} config The config.
 * @param {string} [code] The error code (for example, 'ECONNABORTED').
 * @param {Object} [request] The request.
 * @param {Object} [response] The response.
 * @returns {Error} The error.
 */

/**
 * Updates meta tags inside <head> and <body> on the client. Borrowed from `react-helmet`:
 * https://github.com/nfl/react-helmet/blob/004d448f8de5f823d10f838b02317521180f34da/src/Helmet.js#L195-L245
 *
 * @param  {('meta'|'base'|'link'|'style'|'script'|'noscript')} type - the name of the tag
 * @param  {(Array<Object>|Object)} tags - an array of tag objects or a single object in case of base
 * @return {Object} - a representation of what tags changed
 */

/**
 * Updates the document title
 *
 * @param  {String} title - the new title of the document
 */

/**
 * Updates the document's html tag attributes
 *
 * @param  {Object} attrs - the new document html attributes
 * @param  {HTMLElement} tag - the HTMLElement tag to update with new attrs
 */

/**
 * Use function string name to check built-in types,
 * because a simple equality check will fail when running
 * across different vms / iframes.
 */

/**
 * Validate component names
 */

/**
 * Validate whether given map is valid or not
 * @param {*} map
 * @return {Boolean}
 */

/**
 * Virtual DOM patching algorithm based on Snabbdom by
 * Simon Friis Vindum (@paldepind)
 * Licensed under the MIT License
 * https://github.com/paldepind/snabbdom/blob/master/LICENSE
 *
 * modified by Evan You (@yyx990803)
 *
 * Not type-checking this because this file is perf-critical and the cost
 * of making flow understand it is not worth it.
 */

/**
 * Walk through all properties and convert them into
 * getter/setters. This method should only be called when
 * value type is Object.
 */

/**
 * Watchers.
 *
 * Watchers hashes should not overwrite one
 * another, so we merge them as arrays.
 */

/**
 * When called, will update the current meta info with new meta info.
 * Useful when updating meta info as the result of an asynchronous
 * action that resolves after the initial render takes place.
 *
 * Credit to [Sébastien Chopin](https://github.com/Atinux) for the suggestion
 * to implement this method.
 *
 * @return {Object} - new meta info
 */

/**
 * checks if passed argument is an array
 * @param  {any}  arg - the object to check
 * @return {Boolean} - true if `arg` is an array
 */

/**
 * forEach for object
 */

/**
 * make localized dispatch, commit, getters and state
 * if there is no namespace, just use root ones
 */

/**
 * parent component style should be after child's
 * so that parent component's style could override it
 */

/** @type {!Array} */

/** @type {!Object} */

/** @type {string} */

/***/

/*@__PURE__*/

/*eslint func-names:0*/

/*eslint no-param-reassign:0*/

/*global toString:true*/

//

//    created before the child)

//    its watchers can be skipped.

//    user watchers are created before the render watcher)

//   captures = result.slice(1).map(maybeToString)

//  nested

// "$stable" marker.

// "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]

// "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]

// "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]

// "consumed" by the delegate iterator. If context.method was

// "force" the microtask queue to be flushed by adding an empty timer.

// "return" to "throw", let that override the TypeError below.

// "return", allow the original .return call to continue in the

// "too much recursion" error.

// "touch" every property so they are all tracked as

// #2301

// #4391: in IE9, setting type can reset value for input[type=radio]

// #6157

// #6513

// #6574 in case the inject object is observed...

// #6601 work around Chrome version <= 55 bug where single textNode

// #6666: IE/Edge forces progress value down to 1 before setting a max

// #6903

// #7138: IE10 & 11 fires input event when setting placeholder on

// #750

// #7573 disable dep collection when invoking data getters

// #7573 disable dep collection when invoking lifecycle hooks

// #7817 clone node before setting fnContext, otherwise if the node is reused

// #7975

// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp

// #9448 bail if event is fired in another document in a multi-page

// #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState

// #9681 QtWebEngine event.timeStamp is negative value

// #match works fine because it just return the exec results, even if it has

// #replace needs built-in support for named groups.

// $attrs & $listeners are exposed for easier HOC creation.

// $flow-disable-line

// (#6466 MutationObserver is unreliable in IE11)

// () => Promise

// (also registers _wrappedGetters as computed properties)

// (async resolves are shimmed as synchronous during SSR)

// (during initialization all changes are blocked)

// (e.g. #6813, out-in transitions).

// (e.g. it was from a cached normal slot) the fnContext causes named slots

// (for array properties this is checked in arrayMerge)

// (relative to UNIX epoch), so in order to compare time we have to use the

// - appending to trailing slash (last segment is empty)

// - doesnt have metaInfo defined

// - not appending

// - when the component doesnt have a parent

// - when user configured to not wait for transitions on destroyed

// .constructor.prototype properties for functions that return Generator

// .throw, and .return (see defineIteratorMethods).

// .throw, and .return methods.

// 1. Components are updated from parent to child. (because parent is always

// 1. When the children contains components - because a functional component

// 1. resolve relative redirect

// 19.1.2.1 Object.assign(target, source, ...)

// 19.1.2.14 / 15.2.3.14 Object.keys(O)

// 19.1.2.14 Object.keys(O)

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])

// 19.1.2.2 Object.create(O [, Properties])

// 19.1.2.3 Object.defineProperties(O, Properties)

// 19.1.2.4 Object.defineProperty(O, P, Attributes)

// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)

// 19.1.2.7 Object.getOwnPropertyNames(O)

// 19.1.2.8 Object.getOwnPropertySymbols(O)

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)

// 19.1.3.1 Object.assign(target, source)

// 19.1.3.6 Object.prototype.toString()

// 19.2.4.2 name

// 19.4.1.1 Symbol([description])

// 19.4.2.1 Symbol.for(key)

// 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14

// 19.4.2.5 Symbol.keyFor(sym)

// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)

// 19.4.3.5 Symbol.prototype[@@toStringTag]

// 2. A component's user watchers are run before its render watcher (because

// 2. When the children contains constructs that always generated nested Arrays,

// 2. resolve params

// 2.2 with runInNewContext: true

// 2.3 injection

// 2.6 explicit observable API

// 20.2.1.9 Math[@@toStringTag]

// 21.1.3.13 String.prototype.repeat(count)

// 21.1.3.18 String.prototype.startsWith(searchString [, position ])

// 21.1.3.27 String.prototype[@@iterator]()

// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])

// 21.1.3.7 String.prototype.includes(searchString, position = 0)

// 21.2.5.14 RegExp.prototype.toString()

// 21.2.5.3 get RegExp.prototype.flags

// 21.2.5.3 get RegExp.prototype.flags()

// 21.2.5.6 RegExp.prototype[@@match](string)

// 21.2.5.9 RegExp.prototype[@@search](string)

// 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)

// 22.1.3.13 Array.prototype.keys()

// 22.1.3.29 Array.prototype.values()

// 22.1.3.30 Array.prototype[@@iterator]()

// 22.1.3.31 Array.prototype[@@unscopables]

// 22.1.3.4 Array.prototype.entries()

// 24.3.2 JSON.stringify(value [, replacer [, space]])

// 24.3.3 JSON[@@toStringTag]

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()

// 25.4.1.5 NewPromiseCapability(C)

// 25.4.3.1 Promise(executor)

// 25.4.4.1 Promise.all(iterable)

// 25.4.4.4 Promise.race(iterable)

// 25.4.4.5 Promise.reject(r)

// 25.4.4.6 Promise.resolve(x)

// 25.4.5.1 Promise.prototype.catch(onRejected)

// 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)

// 3. If a component is destroyed during a parent component's watcher run,

// 3. rematch with existing query and hash

// 7.1.1 ToPrimitive(input [, PreferredType])

// 7.1.13 ToObject(argument)

// 7.1.15 ToLength

// 7.1.4 ToInteger

// 7.2.1 RequireObjectCoercible(argument)

// 7.2.2 IsArray(argument)

// 7.2.8 IsRegExp(argument)

// 7.2.9 SameValue(x, y)

// 7.3.20 SpeciesConstructor(O, defaultConstructor)

// 7.4.6 IteratorClose(iterator, completion)

// :class are used on slot nodes

// <- awaiting reactions

// <- checked in isUnhandled reactions

// <- done

// <- rejection state, 0 - default, 1 - handled, 2 - unhandled

// <- state

// <- value

// <textarea>... block the first input event and remove the blocker

// @@iterator function is called on it. Some browsers' implementations of the

// @@match logic

// @@replace logic

// @@search logic

// @@split logic

// A .throw or .return when the delegate iterator has no .throw

// A Generator should always return itself as the iterator object when the

// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).

// A major drawback of this tradeoff is that there are some scenarios

// AFTER it was attached.

// Add a marker to know if it uses metaInfo

// Add a port to the getters proxy.

// Add headers to the request

// Add responseType to request if needed

// Add withCredentials to request if needed

// Add xsrf header

// After ssr hydration (identifier by tags === false) check

// All IE versions use low-res event timestamps, and have problematic clock

// Allow for axios('example/url'[, config]) a la fetch API

// Allow use of default import syntax in TypeScript

// Also, using (macro) tasks in event handler would cause some weird behaviors

// Apply extends and mixins on the child options,

// Array#includes uses SameValueZero equality algorithm

// Array#indexOf ignores holes, Array#includes - not

// Assign the result of the finished delegate to the temporary

// Async edge case #6566 requires saving the timestamp when event listeners are

// Async edge case fix requires storing an event listener's attach timestamp.

// AsyncIterator objects; they just return a Promise for the value of

// Auto install if it is not done yet and `window` has `Vue`.

// Avoid an infinite loop

// Avoid propagating failures to Promises returned by later

// Avoiding first `popstate` event dispatched in some browsers but first

// Axios

// Base data struct for store's module, package with some attribute and method

// Be forgiving, per 25.3.3.3.3 of the spec:

// Browser environment sniffing

// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

// But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.

// CSP to forbid Function, and you're not willing to fix either of those

// CSS transitions. Since the element may be inside an entering

// Call delegate.iterator[context.method](context.arg) and handle the

// Callback can either be a function or a string

// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives

// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec

// Clean up request

// Compile all the patterns before compilation.

// Compile all the tokens into regexps.

// Copy axios.prototype to instance

// Copy context to instance

// Copy function arguments

// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted

// Create the default instance to be exported

// Credits: borrowed code from fcomb/redux-logger

// DEPRECATED: alias for componentInstance for backwards compat.

// DOM APIs, for completeness

// DOM Exception 18 where it limits to 100 pushState calls

// Deactivate deps tracking while processing error handler to avoid possible infinite rendering.

// Deep watchers and watchers on Object/Arrays should fire even

// Default implementation is empty

// Define Generator.prototype.{next,throw,return} in terms of the

// Define as getter property because

// Define iterator

// Define the unified helper method that is used to implement .next,

// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a

// Deliberately forget the last sent value so that we don't

// Detect whether an element with the move class applied has

// Determine what event timestamp the browser is using. Annoyingly, the

// Dispatch the exception by looping back around to the

// Does not start the time, just sets up the members needed.

// Don't bother if no value provided

// Don't enum bug & hidden keys

// Don't get fooled by e.g. browserify environments.

// Dummy constructor functions that we use as the .constructor and

// During updates, a kept-alive component's child components may

// ECMAScript 6 symbols shim

// ES3:

// Ensure headers exist

// Exception should still be thrown

// Exception thrown outside of any try block that could handle

// Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.

// Expose Axios class to allow class inheritance

// Expose Cancel & CancelToken

// Expose all/spread

// Factory for creating new instances

// Fallback to setImmediate.

// Fix #1994: using * with props: true generates a param named 0

// Fix #2505 resolving asterisk routes { name: 'not-found', params: { pathMatch: '/not-found' }}

// Fix browsers whose `exec` methods don't consistently return `undefined`

// Fix for #1585 for Firefox

// Fix for #2195 Add optional third attribute to workaround a bug in safari https://bugs.webkit.org/show_bug.cgi?id=182678

// Fix for #2774 Support for apps loaded from Windows file shares not mapped to network drives: replaced location.origin with

// Fix native

// Flatten headers

// For IE 6–8

// For browsers use XHR adapter

// For non-IE10 modern browsers

// For plain HTML markup, normalization can be completely skipped because the

// For props and computed properties, we define the proxy getters on

// For the native GeneratorFunction constructor, the best we can

// For web workers, where supported

// Force an array if not already something iterable

// From the spec: "Wait until any invocations of this algorithm started before this one have completed."

// GenStateExecuting and loop back for another invocation.

// Get the commit method from store

// HTTP basic authentication

// Handle browser request cancellation (as opposed to a manual cancellation)

// Handle cancellation

// Handle low level network errors

// Handle progress if needed

// Handle timeout

// Headers whose duplicates are ignored by node

// Helper for defining the .next, .throw, and .return methods of the

// Here we have async deferring wrappers using microtasks.

// Hook up interceptors middleware

// However, it has subtle problems when state is changed right before repaint

// IE 8 has a broken Object.defineProperty that only works on DOM objects.

// IE 8- don't enum bug keys

// IE doesn't support innerHTML for SVG elements

// IE input[type=range] only supports `change` event

// IE needs attribute set twice to normalize properties

// IE8 returns string on undefined

// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).

// If `separator` is not a regex, use native split

// If a rejected Promise was yielded, throw the rejection back

// If an exception is thrown from innerFn, we leave state ===

// If comma is not replaced with a dot, the input will be rounded down (i.e. acting

// If context.method was "throw" but the delegate handled the

// If enqueue has been called before, then we want to wait until

// If maybeInvokeDelegate(context) changed context.method from

// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.

// If the delegate iterator has a return method, give it a

// If the dispatched exception was caught by a catch block,

// If the path exists, push it onto the end.

// Ignore already escaped sequences.

// Ignore the finally entry if control is not jumping to a

// In 2.5 we used (macro) tasks (in combination with microtasks).

// In most cases when you have a SSR app it will be the first app thats gonna be

// In non-strict mode we allow a slash at the end of match. If the path to

// In problematic UIWebViews, Promise.then doesn't completely break, but

// Initial redirection should still trigger the onReady onSuccess

// Instead of using a MutationObserver, we just apply

// Iterate over array values

// Iterate over object keys

// Iterate over the tokens and create our regexp string.

// Iterator interface in terms of a single ._invoke method.

// JSDOM may return undefined for transition properties

// Listen for ready state

// MS Edge converts symbol values to JSON as {}

// Match Express-style parameters and un-named parameters with a prefix

// Match any characters still remaining.

// Match escaped characters that would otherwise appear in future matches.

// Microsoft

// Mozilla

// MutationObserver has wider support, however it is seriously bugged in

// NOTE: This cannot be properly polyfilled in engines that don't support

// NOTE: This is equivalent to

// NOTE: these are not considered part of the public API - avoid relying on

// New element

// Node.js

// Node.js 0.8-

// Node.js 0.9+ & IE10+ has setImmediate, otherwise:

// Not all browsers support upload events

// Not sure about the optimal order of these conditions:

// Note that simple async functions are implemented on top of

// Note: ["return"] must be used for ES3 parsing compatibility.

// Note: style is excluded because it relies on initial clone for future

// Note: this is a browser-only function so we can assume elms are DOM nodes.

// Number('+0x1') should be NaN, old V8 fix

// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers

// On some exotic environments, it's not clear which object `setimmediate` was

// Only merged options has the _base property.

// Otherwise add header to the request

// PhantomJS and iOS 7.x

// Plug for library

// Prefixed last, checked first

// Prepare the response

// Prepend partial segment prefixes.

// Prevent browser scroll behavior on History popstate

// Promise is available, we will use it:

// Promise.resolve without an argument throws an error in LG WebOS 2

// Provide aliases for supported request methods

// Push the current path onto the tokens.

// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed

// Rather than returning an object with a next method, we keep

// Real errors are hidden from us by the browser

// RegExp constructor can alter flags and IsRegExp works correct with @@match

// RegExp[@@split] doesn't call the regex's exec method, but first creates

// Regardless of whether this script is executing as a CommonJS module

// Remove Content-Type if data is undefined

// Remove a duplicate tag from domTagstoRemove, so it isn't cleared.

// Remove all "template" tags from meta

// Resetting context._sent for legacy support of Babel's

// Resume execution at the desired location (see delegateYield).

// Return an iterator with no values.

// Reuse variable

// Safari < 10.2 & UIWebView doesn't fire compositionend when

// See https://github.com/facebook/regenerator/issues/274 for more details.

// See: https://github.com/vuejs/vuex/issues/1505

// Send the request

// Set @@toStringTag to native iterators

// Set config.method

// Set the request timeout in MS

// Set them one by one, and the browser will only set those it can recognize

// Setting context._sent for legacy support of Babel's

// Show deprecation warning once when devtools enabled

// So if we're currently running a task, we'll need to delay this invocation.

// So we now use microtasks everywhere, again.

// Some versions of I.E. have different rules for clearTimeout vs setTimeout

// Sort queue before flush.

// Spec says greater than zero

// Specifically not if we're in a web worker, or react-native.

// Standard

// Standard browser envs have full support of the APIs needed to test

// Store and register the task

// Store some children item

// Store the origin module object which passed by programmer

// Store the origin module's state

// String methods call symbol-named RegEp methods

// Support values array created by autoprefixer, e.g.

// Symbol-named RegExp methods call .exec

// TODO: Not spec compliant, should be false.

// Technically it leverages the (macro) task queue,

// Text node

// Thank's IE8 for his funny defineProperty

// The ._invoke method unifies the implementations of the .next,

// The context.catch method must only be called with a location

// The current target watcher being evaluated.

// The delegate iterator is finished, so forget it and continue with

// The namespace has been mutated by normalizeNamespace

// The nextTick behavior leverages the microtask queue, which can be accessed

// The options are set like this so they can

// The request errored out and we didn't get a response, this will be

// The root entry object (effectively a try statement without a catch

// The template compiler attempts to minimize the need for normalization by

// The test against `importScripts` prevents this implementation from being installed inside a web worker,

// There's no need to maintain a stack because all render fns are called

// These helpers produce better VM code in JS engines due to their

// This  #4521 by skipping the unnecessary `checked` update.

// This allows the user to escape special characters that won't transform.

// This ensures that:

// This environment has a native %IteratorPrototype%; use it instead

// This is a polyfill for %IteratorPrototype% for environments that

// This is globally unique because only one watcher

// This is only done if running in a standard browser environment.

// This module is a runtime utility for cleaner component module output and will

// This module should not be running in strict mode, so the above

// This vnode was used in a previous render!

// This was originally intended to fix #4521 but no longer necessary

// This works if eval is allowed (see CSP)

// This works if the window reference is available

// This works in non-strict mode

// Thrash, waste and sodomy: IE GC bug

// To allow users to avoid auto-installation in some cases,

// To avoid creating an additional object, we just hang the .value

// Transform request data

// Transform response data

// Try/catch helper to minimize deoptimizations. Returns a completion

// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It

// Use MutationObserver where native Promise is not available,

// Use a negative lookahead to match only capturing groups.

// V8 throws on boxed symbols

// Vnode moved left

// Vnode moved right

// Vue.extend constructor export interop

// Vue.prototype.__patch__ is injected in entry points

// Wait that element is hidden before refreshing meta tags (to support animations)

// We can't use window.location.hash here because it's not

// We return undefined, instead of nothing here, so it's

// WebKit converts symbol values to JSON as null

// When a yielded Promise is resolved, its final value becomes

// When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally

// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally

// With one exception: request that using file: protocol, most browsers

// Within the body of any async function, `await x` is transformed to

// Works with __proto__ only. Old v8 can't work with null proto objects.

// \d\d?

// _vnode is used to know that it's attached to a real component

// `AdvanceStringIndex` abstract operation

// `RegExp.prototype[@@match]` method

// `RegExp.prototype[@@replace]` method

// `RegExp.prototype[@@search]` method

// `RegExp.prototype[@@split]` method

// `RegExpExec` abstract operation

// `String.prototype.match` method

// `String.prototype.replace` method

// `String.prototype.search` method

// `String.prototype.split` method

// `hasOwn.call(value, "__await")` to determine if the yielded value is

// `setimmediate` library.

// `value` is handled separately because the DOM value may be temporarily

// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test

// a "grops" property.

// a child.

// a component is in a metaInfo branch when itself has meta info or one of its (grand-)children has

// a flag to avoid this being observed

// a new one. We need to return the patched regex when creating the new one.

// a reactivated keep-alive component doesn't insert itself

// a successful hydration.

// a uid

// a value is Function if its prototype is function even across different execution context

// able to install onto.  Search each possibility in the same order as the

// abstract components do not keep anything

// accidentally pass it on to the delegate.

// add "__proto__" for Object.getPrototypeOf polyfill

// add load callbacks if the

// add missing metadata

// add the navigation guards if requested

// add the navigation guards if they havent been added yet

// additional parameters

// after 2.5. Keeping it for backwards compat with generated code from < 2.4

// after calling the init hook, if the vnode is a child component

// again. It's not ideal to involve module-specific logic in here but

// all

// all enumerable object keys, includes symbols

// all object keys, includes non-enumerable and symbols

// all other transition classes applied to ensure only the move class

// all previous Promises have been resolved before calling invoke,

// allow further extension/mixin/plugin usage

// already a merged invoker

// already have an existing method we want to call, so there's no need

// already pending

// also ensures that the minifier will not anonymize the function.

// also register instance in prepatch hook

// an indication that we need to skip the default behaviour or child has preference over parent

// and .done properties off the next function object itself. This

// and collects all module getters inside this._wrappedGetters

// and fix #3106 so that you can work with location descriptor object having params.pathMatch equal to empty string

// and is always a fresh object, so it's safe to merge into it

// and optional suffixes. Matches appear as:

// and prevent memory leak

// and set to the computed prop $metaInfo in the mixin

// and the handler would only fire if the event passed to it was fired

// and the second argument - flag - preferred type is a string

// and we need to use the hi-res version for event listener timestamps as

// and when that is passed down this would cause an error

// any necessary setup in a predictable way. This predictability

// append new listeners for router-link

// apply plugins

// apply templates if needed

// apply transition data to child

// are already rendered on the client or has no need for initialization

// args order: tag, data, children, normalizationType, alwaysNormalize

// argument that corresponds to a known catch block.

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)

// array of events

// as a comment node but preserves all the raw information for the node.

// as a floor function) causing unexpected behaviors

// as search(query) is already decoded

// as the other tags

// as these will throw away existing DOM nodes and cause removal errors

// as we run existing watchers

// assert node match

// assign to this to avoid being removed in tree-shaking

// assignment should always work unless something is misconfigured. Just

// associated DOM element for it.

// assume it's an async component resolve function.

// async component

// async components

// async edge case #6566: inner click event triggers patch, event handler

// async functions in terms of async generators, it is especially

// at instantiation here.

// attach instance registration hook

// attached during that flush.

// attached to outer element during patch, and triggered again. This

// attached. However, calling performance.now() has a perf overhead especially

// attempted fix for #404 & #562, but we rly need to refactor how we pass appIds from

// attributes that should be using props for binding

// automatic install

// avoid catch triggering multiple times when nested calls

// avoid resetting cursor position when value is the same

// avoids Object.defineProperty calls for each instance created.

// avoriaz seems to mock a non-extensible $scopedSlots object

// backup the title chunk in case user wants access to it

// backwards compatible with the first introduction of Errors

// bail for environments that have buggy event.timeStamp implementations

// based on es5-shim implementation, need to rework it

// based on the rendering backend used.

// basic support for MathML

// batch potential DOM updates to prevent extraneous re-rendering

// be included in the final webpack user bundle.

// be minified by terser while keeping the

// be processed after the whole patch process ended.

// because Vue caches those internally

// because functional components already normalize their own children.

// because they will be changed by vm update

// because we want to refer it in recursive deepCopy

// been updated.

// begin sanitization

// bind

// bind commit and dispatch to self

// bind on install

// bind store public getters

// bind the createElement fn to this instance

// bind timers to global for call from export context

// binding to window is necessary to make hot reload work in IE in strict mode

// boolean has higher priority

// browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339

// but Flash expects a value of "true" when used on <embed> tag

// but ToNumber should return NaN if a string contains unavailable symbols

// but at the same time, it doesn't make much sense to select an element with an id and an extra selector

// but for some reason `nativeSlice.call(result, 1, result.length)` (called in

// but it is still a better choice than setTimeout.

// but only if it is a raw options object that isn't

// but we check for a `vmid` property on each object in the array

// by any combination of letters, digits, plus, period, or hyphen.

// by multiple components on the same page

// c.f. https://nodejs.org/api/http.html#http_message_headers

// cache component

// cache constructor

// cache original method

// cache resolved

// cached call

// cached from whatever global is present so that test runners that stub it

// call component updated and activated hooks

// call enter callback now

// call factory function for non-Function types

// call invoke immediately, without waiting on a callback to fire,

// call leave callback now

// call something on iterator step with safe closing on error

// call the last hook...

// can be evaluated at a time.

// can have their private assets too.

// can we use __proto__?

// can't set metadata to uncaught frozen object

// catch redirect option https://github.com/vuejs/vue-router/issues/3201

// cater for pre-defined getter/setters

// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.

// certain weird environments...

// chance to clean up.

// change, so directly walking the tree here may call activated hooks

// changed after adding errors with

// check default value

// check history fallback deeplinking

// check if the childComponent is in a branch

// check if there are any late-modified/attached options (#4976)

// check if there are dynamic scopedSlots (hand-written or compiled but with

// check if this is server-rendered content and if we can perform

// check inline-template render functions

// check local registration variations first

// check nested equality

// check object-style commit

// check object-style dispatch

// check on default Array iterator

// check pattern

// check platforms/web/util/attrs.js acceptValue

// child component listeners instead of DOM listeners

// child component. it should have hydrated its own tree.

// clean out app from this.apps array once destroyed

// clean up event listeners

// cleanup faulty template properties

// clone children array to avoid mutating original in case of cloning

// clone observed objects, as the user probably wants to mutate it

// clone reused vnode

// clone to prevent mutation

// coerce function-style metaInfo to a computed prop so we can observe

// collect & aggregate all metaInfo $options

// collect & aggregate child options if deep = true

// combine options

// compiled as a scoped slot, render fn users would expect it to be present

// completely stops working after triggering a few times... so, if native

// component also has set the placeholder vnode's elm.

// component constructor creation

// component instance. This key will be used to remove pending leaving nodes

// component itself.

// component prototype. We only need to define computed properties defined

// component's mounted hook), which relies on vm._watcher being already defined

// component-defined computed properties are already defined on the

// components with in Weex's multi-instance scenarios.

// computed properties are just getters during SSR

// config

// confirm transition and pass on the value

// consistent across browsers - Firefox will pre-decode it!

// constructor polyfill

// contains in native

// context.dispatchException(context.arg) call above.

// context.method was "next", forget context.arg since it has been

// convert base tag to an array so it can be handled the same way

// convert primitive to vnode

// correct subclassing with @@species support

// create an empty node and replace it

// create asset registers, so extended classes

// create internal watcher for the computed property.

// create new node

// createDict = iframe.contentWindow.Object;

// credit for this suggestion goes to [Sébastien Chopin](https://github.com/Atinux)

// current hook was called

// current iteration.

// decode the hash but not the search or hash

// deep updates (#7063).

// default key for nested array children (likely generated by v-for)

// delay insert hooks for component root nodes, invoke them after the

// delegate iterator, or by modifying context.method and context.arg,

// delete the 0 if it was added

// dependencies for deep watching

// destroy old node

// detect devtools

// detect such cases and filter out values that no longer has a matching

// determine whether component has slot children

// devtool hook

// devtools global hook

// direct component options / constructor

// direct inline function use will lead to closure preserving oldVm.

// directly removing

// directly use parent context's createElement() function

// dispatch changes in all subscribed watchers

// do is to check its .name property.

// do not cache length because more watchers might be pushed

// do not log it twice

// do not trigger refresh on the server side

// do not trigger refresh:

// do not use destructuring for args, it increases transpiled size

// do not use destructuring for disableOptionKeys, it increases transpiled size

// do not use destructuring for seq, it increases transpiled size

// do see our own ssrAttribute then _assume_ the Vue app with appId 1 is the ssr app

// does not trigger because the inner node's created hooks are not called

// doesn't have <a> child, apply listener to self

// doing this because it's faster than dynamic enumeration.

// don't break things.  But we need to wrap it in a try catch in case it is

// don't natively support it.

// don't redirect if `target="_blank"`

// don't redirect on right click

// don't redirect when preventDefault called

// don't redirect with control keys

// due to var checks while we are guaranteed the structure of the cb

// dueo to the or statement above

// during Vue.extend(). We only need to proxy props defined at

// during entering.

// during initialization

// during template compilation

// dynamic slot names). Static scoped slots compiled from template has the

// e.g. <option disabled>Select one</option>

// e.g. <template>, <slot>, v-for, or when the children is provided by user

// e.g. PhantomJS, iOS7, Android 4.4

// e.g. `value` on <progress> w/ non-finite value

// e.g. for directives that uses the "inserted" hook.

// easier to handle this case. if(!global) { ...}

// eg it could be a function when metaInfo() returns undefined

// either not server-rendered, or hydration failed.

// electron/nw.js app, since event.timeStamp will be using a different

// element is really inserted

// element may have already been removed due to v-html / v-text

// emit "event" with new info

// empty component root.

// empty element, allow client to pick up and populate children

// empty mount (likely as component), create new root element

// empty path

// empty string to avoid regexp issues

// enable recursive self-lookup

// enable strict mode for new vm

// enqueue has not been called before, then it is important to

// ensure a key that is unique to the vnode type and to this transition

// ensure collecting deps for deep class bindings for future updates

// ensure leading slash

// ensure only append when value is already string, otherwise it will be cast

// ensure we still have a main app or null if no apps

// ensure wildcard routes are always at the end

// eslint-disable-line

// eslint-disable-line no-new

// eslint-disable-line no-script-url

// eslint-disable-line no-undef

// eslint-disable-line no-unused-vars

// eslint-disable-line object-shorthand

// eslint-disable-next-line no-loop-func

// eslint-disable-next-line no-new-func

// eslint-disable-next-line no-param-reassign

// eslint-disable-next-line no-prototype-builtins

// eslint-disable-next-line no-self-compare

// eslint-disable-next-line no-throw-literal

// eslint-disable-next-line no-unused-vars

// eslint-disable-next-line no-void

// essentially merged when rendered to HTML strings

// event is fired after handler attachment

// events.

// every time the scheduler flushes and use that for all event listeners

// exception, let the outer generator proceed normally. If

// excluded

// execute code before the first await. Since we implement simple

// executor callback, and why async functions synchronously

// existing directive, update

// existing plain hook

// explicitness and function inlining.

// export

// export native or passed

// expose FunctionalRenderContext for ssr runtime helper installation

// expose normal slots on scopedSlots

// expose real self

// exposed util methods.

// exposing $options for renderStatic()

// extend global

// extend now so that global mixins are applied.

// extract listeners and pass them directly to the transition methods

// extract listeners, since these needs to be treated as

// extract local getter type

// extract props

// extremely rare edge case: do not insert if old element is in a

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window

// fallback for non-array-like ES3 and non-enumerable old V8 strings

// fallback to prototype chain

// false -> Array#indexOf

// false -> String#codePointAt

// false or null will remove the attribute but undefined will not

// fast apply, http://jsperf.lnkit.com/fast-apply/5

// fast case for arrays with default iterator

// fast equal /^0b[01]+$/i

// fast equal /^0o[0-7]+$/i

// fast path 1: child component re-render only, parent did not change

// fast path 2: stable scoped slots w/ no normal slots to proxy,

// filter out text nodes (possible whitespaces)

// find the first <a> child and apply listener and href

// find the first child that lists fnOptions

// fire destroyed hook

// fire ready cbs once

// fires "change" instead of "input" on autocomplete.

// fix Array#{values, @@iterator}.name in V8 / FF

// fix for some old engines

// flow complains about extra args which is why we use any

// flow somehow has problems with directly declared definition object

// for 1.x backwards compatibility.

// for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/

// for backwards compat

// for lazy watchers

// for slot content they should also get the scopeId from the host instance.

// for template-only hot-reload because in that case the render fn doesn't

// for transition enter check

// for which Vue lifecycle hooks should the metaInfo be refreshed

// force an initial refresh on page load and prevent other lifecycleHooks

// force reflow to put everything in position

// force removing pass

// forced

// frozen object may not have observer.

// function because try/catches deoptimize in certain engines.

// function.sent implementation.

// functional

// functional component

// functional template

// g can still be undefined, but nothing to do about it...

// generated render function is guaranteed to return Array<VNode>. There are

// get dispatch function from store

// getElementById would still fail if the selector contains a more complicated query like #main[data-attr]

// getters and state object must be gotten lazily

// getting tag from 19.1.3.6 Object.prototype.toString()

// global

// global before hooks

// go through the normalizer

// hack for #4339: a reactivated component with inner transition

// handle null value #1566

// handle transition classes

// handle transition mode

// handled by onerror instead

// happens because browsers fire microtask ticks between event propagation.

// has a stable shape and so hopefully should be cheap to allocate.

// has new static slots

// has old static slots

// has throttled rAF/timers we still immediately set the page title

// have been (and was previously) designed to take a closure to be

// have mutated.

// helper for String#{startsWith, endsWith, includes}

// helper to dynamically append modifier runtime markers to event names.

// helpers

// history route not updated since async guard at the same time.

// html.removeChild(iframe);

// http://www.matts411.com/post/internet-explorer-9-oninput/

// https://bugs.chromium.org/p/v8/issues/detail?id=3443

// https://github.com/facebook/flow/issues/285

// https://github.com/tc39/Array.prototype.includes

// https://github.com/tc39/proposal-object-getownpropertydescriptors

// https://github.com/tc39/proposal-promise-finally

// https://github.com/vuejs/vue-router/issues/2341

// https://github.com/vuejs/vue-router/issues/2639

// https://github.com/vuejs/vue-router/issues/2708

// https://github.com/vuejs/vue-router/issues/3225

// https://github.com/vuejs/vue-router/pull/3047 before that change,

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028

// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume

// https://tc39.github.io/ecma262/#sec-advancestringindex

// https://tc39.github.io/ecma262/#sec-getsubstitution

// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match

// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace

// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search

// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split

// https://tc39.github.io/ecma262/#sec-regexpexec

// https://tc39.github.io/ecma262/#sec-string.prototype.match

// https://tc39.github.io/ecma262/#sec-string.prototype.replace

// https://tc39.github.io/ecma262/#sec-string.prototype.search

// https://tc39.github.io/ecma262/#sec-string.prototype.split

// hydrating

// idx needs to be a Number, for..in returns string

// ie9 setting to null has no effect, must use empty string

// if $metaInfo exists then [keyName] was defined as a function

// if _vueMeta = true it has info, if _vueMeta = false a child has info

// if a Content Security Policy forbids using Function, but in that case

// if a router-view is wrapped with an out-in transition,

// if a vm exists _and_ its mounted then immediately update

// if already flushing, splice the watcher based on its id

// if already past its id, it will be run next immediately.

// if an update was triggered during initialization or when an update was triggered by the

// if at this stage it's not a constructor or an async component factory,

// if childNode is not null, it means the actual childNodes list is

// if clearTimeout wasn't available but was latter defined

// if computed $metaInfo exists, watch it for updates & trigger a refresh

// if has already-rendered static tree and not inside v-for,

// if initialized was set to null in triggerUpdate. That'd mean

// if it's a function and doesn't have cid attached,

// if obj is hit, it is in circular structure

// if object isn't iterable or it's array with default iterator - use simple case

// if parent is an HOC, update its $el as well

// if setTimeout wasn't available but was latter defined

// if source specifies null as content then ignore both the target as the source

// if the event timestamp, although evaluated AFTER the Date.now(), is

// if the new node is not cloned it means the render functions have been

// if the page has thousands of event listeners. Instead, we take a timestamp

// if the returned array contains only a single node, allow it

// if the user intentionally throws the original error in the handler,

// if the user uses an arrow function shorthand that happens to

// if the vm is being destroyed.

// if this Vue-app was server rendered, set the appId to 'ssr'

// if this is a component root node and the component's

// if this is a server render, then dont update

// ignore children if the node has textContent or innerHTML,

// ignore slots that contains only whitespace

// ignore these

// immediately.

// implementation and does not fire microtasks in between event propagation, so

// implementations (#9632)

// important for dynamic transitions!

// important to get this right, even though it requires care.

// important: remove merged hook to ensure it's called only once

// in Webpack 2, require.ensure now also returns a Promise

// in a Vue.extend merge, both should be functions

// in a locale-dependent way, using a comma instead of a dot.

// in case kept-alive component be actived when routes changed

// in case of component :is set to falsy value

// in case runtime.js accidentally runs in strict mode, we can escape

// in case the <a> is a static node

// in case the child is also an abstract component, e.g. <keep-alive>

// in case the object is already observed...

// in case the options rendered by v-for have changed,

// in case the same component instance is reused across different routes

// in each iteration - which helps prevent layout thrashing.

// in every case, so we don't have to touch the arguments object. The

// in non-ending mode, where "/test/" shouldn't match "/test//route".

// in some cases, the event used has to be determined at runtime

// in that case we can just return the element and be done.

// in the case the route map has been dynamically appended to

// in this case we want to make sure we are able to get a hold to the

// in-component leave guards

// in-component update hooks

// in-config enter guards

// increase the listeners count

// init all modules

// init parent attached events

// init root module.

// initialize the store vm, which is responsible for the reactivity

// initialize tracked changes

// initiated, if we cant detect the data-server-rendered attribute from Vue but we

// inject component registration as beforeCreate hook

// inject component styles

// inject is :any because flow is not smart enough to figure out cached

// injected by v-model runtime

// injected easily by `bin/regenerator --include-runtime script.js`.

// inline hooks to be invoked on component VNodes during patch

// insert new elements

// install component management hooks onto the placeholder node

// install platform patch function

// install platform runtime directives & components

// install platform specific utils

// install runtime convenience helpers

// instance merge

// instantiation here.

// instead of a hash lookup

// instead of adding it to the html

// instead of the ES6 spec version, we didn't implement @@toPrimitive case

// internal component options needs special treatment.

// internal version is used by render functions compiled from templates

// into the async generator function so it can be handled there.

// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.

// invocations of the iterator.

// invoke callbacks only if this is not a synchronous resolve

// invoke destroy hooks on current rendered tree

// invoke insert hooks that may have been merged by create hooks.

// invoked without arguments, but in all the cases we care about we

// is applied.

// is needed to cater to all possible types of children values.

// is no longer valid.

// is valid at the end of a path match, not in the middle. This is important

// is why the Promise constructor synchronously invokes its

// issue #9511

// it can get stuck in a weird state where callbacks are pushed into the

// it on creation

// it should've created a child instance and mounted it. the child

// it's important to place the event as the first in the array because

// it's possible that the value is out-of-sync with the rendered options.

// it, so set the completion value of the entire function to

// iterate and compare children lists

// iterator prototype chain incorrectly implement this, causing the Generator

// just return if obj is immutable value

// keep a copy of raw propsData

// keep a reference to the super options at extension time.

// keep copies of post queues before resetting state

// keep-alive + HOCs. (#4590)

// kept-alive components, treat as a patch

// later at instantiation we can check if Super's options have

// leaving transition. Only happens when combining transition +

// list of modules that can skip create hook during hydration because they

// local getters

// local state

// locate first non-abstract parent

// location outside the try/catch block.

// location.host contains the port and location.hostname doesn't

// locations where there is no enclosing try statement.

// longer than the virtual children list.

// main app previously initialized

// make current key freshest

// make sure there's the starting slash

// make sure to clone it if it's reactive, since the user likely wants

// make sure to invoke the insert hook

// make sure to observe it.

// make sure vue-meta was initiated

// manually mounted instance, call mounted on self

// mark v-show

// mark vuex getter for devtools

// marker for reverse proxying v-slot without scope on this.$slots

// match already ends with a slash, we remove it for consistency. The slash

// may return an Array instead of a single root. In this case, just a simple

// may throw

// meant to be awaited.

// merge adjacent text nodes

// merge options

// merge static and dynamic style data on the same vnode

// metaInfo watcher, set initialized to null

// method always terminates the yield* loop.

// microtask queue but the queue isn't being flushed, until the browser

// minifier not to mangle the names of these two functions.

// module.parent = undefined by default

// most Object methods by ES6 should accept primitives

// mounted is called for render-created child components in its inserted hook

// mounting to a real element

// multiple renders, cloning them avoids errors when DOM manipulations rely

// named slots should only be respected if the vnode was rendered in the

// named target

// necessary to ensure parent re-render when deep bindings like :style and

// need to resolve new options.

// needs to do some other work, e.g. handle a timer. Therefore we can

// never gets called

// new directive, bind

// new parent vnode

// new syntax in Vue 2.3

// next index

// next('/') or next({ path: '/' }) -> redirect

// next(false) -> abort navigation, ensure current URL

// no bubbling, should always fire.

// no default, return undefined

// no existing hook

// no longer present, unbind

// no match

// no need to add this hooks on server side

// no need to escape configuration options

// no tagID so no need to check for duplicity

// non-string values will be stringified

// noop

// normalization is always applied for the public version, used in

// normalization is needed - if any child is an Array, we flatten the whole

// normalize possible array / string values into Object

// normalize v-model event tokens that can only be determined at runtime.

// not equal to the updated value

// not included

// not necessary to add metadata

// note it doesn't support other MathML elements being component roots

// note we only do this if the vnode is cloned -

// notify change

// now it's used as a new node, overwriting its elm would cause

// now we only need to check if the target has a template to combine it with the source

// object ID

// object syntax in v-bind

// object to not be returned from this call. This ensures that doesn't happen.

// objects. For full spec compliance, you may wish to configure your

// observe data

// of going through the normal attribute patching process.

// of the polyfill.

// on incorrect children. Instead we push them into a queue which will

// on subsequent patches (#3360)

// on their elm reference.

// on this.$slots because the usage is semantically a normal slot.

// on[event] is always a function

// onerror should only fire if it's a network error

// only additional allocation required is the completion record, which

// only assign once

// only cache tags for current update

// only cast empty string / same name to boolean if

// only collect option data if it exists

// only merge data with result when its an object

// only need to normalize once

// only one SSR app per page is supported

// only used in dev mode

// optimize hook:event cost by using a boolean flag marked at registration

// optimize internal component instantiation

// optimized shallow clone

// option in the DOM.

// optional / simple context binding

// optionally _not_ overwrite the parents content

// options

// or a finally block) gives us a place to store values thrown from

// or even between bubbling of the same event (#6566).

// or not, return the runtime object so that we can declare the variable

// other than props & listeners & slot

// otherwise, render a fresh tree.

// out of sync with VDOM state due to focus, composition and modifiers.

// outer generator.

// override init and inject vuex init procedure

// parent container node also has transition, skip.

// parse expression for getter

// parseInt parses a string to a first unavailable symbol

// pass non-declared props as attrs

// pass props

// patch existing root node

// plain options object: turn it into a constructor

// potential patch errors down the road when it's used as an insertion

// pow(2, 53) - 1 == 9007199254740991

// pre-resolve slots for renderSlot()

// preserve existing history state as it could be overriden by the user

// prevent triggering an input event for no reason

// problems, please detail your unique predicament in a GitHub issue.

// prop and event handler respectively.

// props

// proto

// proxy data on instance

// prune oldest entry

// public mount method

// put the copy into cache at first

// query values can be null and undefined

// queue the flush

// quoted values

// real context instance.

// real proto method for `library`

// record leaving element

// record like context.tryEntries[i].completion. This interface could

// recursively invoke hooks on child component root node

// recursively search for possible transition defined inside the component root

// redirect and aborted navigation would produce an err == null

// ref #5318

// reference node. Instead, we clone the node on-demand before creating

// refresh meta in nextTick so all child components have loaded

// regeneratorRuntime in the outer scope, which allows this module to be

// register component module identifier for async chunk inferrence

// register for functional component in vue file

// register in namespace map

// register instance in init hook

// register nested modules

// register root module (Vuex.Store options)

// reject.

// relative params

// release circular reference (#6759)

// rely on checking whether it's in an inactive tree (e.g. router-view)

// remove __vue__ reference

// remove attributes from the map

// remove current index from source array so its not concatenated to destination below

// remove duplicates that could have been found by merging tags

// remove meta items with duplicate vmid's

// remove old elements

// remove pending leave element on enter by injecting an insert hook

// remove properties explicitly set to false so child components can

// remove reference from data ob

// remove self from parent

// remove self from vm's watcher list

// remove slot attribute if the node is resolved as a Vue slot node

// remove the server render attribute so we can update on (next) changes

// remove trailing segment if:

// remove trailing slash

// render

// render empty node if no matched route or no config component

// render functions

// render previous view if the tree is inactive and kept-alive

// replace old child transition data with fresh one

// replace title with populated template

// replace with listeners with .native modifier

// replaced by innerHTML/textContent retains its parentNode property

// replacing existing element

// reset by the hot-reload-api and we need to do a proper re-render.

// reset local getters cache

// reset store to update getters...

// reset vm

// resolve constructor options in case global mixins are applied after

// resolve injections before data/props

// resolve props

// resolve provide after data/props

// resolve relative path

// resolve slots + force update if has children

// resolved named direct

// resolved.

// respect <base> tag

// result, either by returning a { value, done } result from the

// return a placeholder node for async component, which is rendered

// return a placeholder vnode

// return as we don't need to set up new history listener

// return early if no template defined

// return empty vnode in case the render function errored out

// return handler return value for single handlers

// return in case resolved synchronously

// return otherwise so we dont walk all component branches unnecessarily

// return placeholder node and queue update when leave finishes

// return previous default value to avoid unnecessary watcher trigger

// return primitive with prefix

// return that Promise.

// return true when textbox (.number and .trim) loses focus and its value is

// return when nav guards already added or no router exists

// reuse element for static trees.

// root instance props should be converted

// root state

// safe

// safe to exclude.

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error

// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.

// same context.

// same key but different element. treat as new element

// same timestamp type when saving the flush timestamp.

// sanitizes potentially dangerous characters

// save current target element in closure

// save resolved on async factory in case it's used elsewhere

// save route and configProps in cache

// scoped slot

// scopedId

// see flow/vnode

// separately from one another. Nested component's render fns are called

// sequential events (e.g. #4521, #6690, which have workarounds)

// server build

// set attribute for blank value

// set new value

// set parent

// set parent vnode. this allows render functions to have access

// set scope id attribute for scoped CSS.

// set state

// set template to true to indicate template was already applied

// set the class

// set up app destroyed handler

// setimmediate attaches itself to the global object

// setting _inactive to false here so that a render function can

// setting context.delegate to null, and returning the ContinueSentinel.

// shim for using process in browser

// should work with symbols and should have deterministic property order (V8 bug)

// since dynamic options merging is pretty slow, and none of the

// since the default value is a fresh copy,

// since the watcher's initial patch may call $forceUpdate (e.g. inside child

// skip all element-related modules except for ref (#3455)

// skip if the target getter is not match this namespace

// skip the update if old and new VDOM state is the same.

// skip things that don't look like key=value

// smaller than it, it means the event is using a hi-res timestamp,

// so it gets processed during parent component patch.

// so that components rendered by router-view can resolve named slots

// so that results are always delivered in the correct order. If

// so that the async generator function has the opportunity to do

// so that the transition module can hand over the control to the directive

// so that we get proper render context inside it.

// so the resolve/reject functions may get called an extra time

// so we used some reserved tokens during compile.

// some funky global mixins

// some property updates can throw

// somehow flow cannot infer this is a function

// source doesnt contain any duplicate vmid's, we can keep targetItem

// specific event

// specific handler

// ssr to the client

// stabilize the subscriber list first

// start at index 1 to avoid re-invoking component mounted hook

// start enter transition

// start with a route object that stands for "nowhere"

// starting reference

// stateful

// static

// static props are already proxied on the component's prototype

// static style is pre-processed into an object during compilation

// statically analyzing the template at compile time.

// statics

// store for later, the info

// store injection

// store internal state

// store normalized style under a different key for next diff

// store value as _value as well since

// strange IE + webpack dev server bug - use .call(global)

// strict mode

// strict mode using a global Function call. This could conceivably fail

// strip full URL origin

// super option changed,

// support for compiled functional template

// support single function children as default scoped slot

// suppress warnings just in case the user has added

// switching focus before confirming composition choice

// tags should always be an array, ignore if it isnt

// target

// teardown watchers

// technically allowfullscreen is a boolean attribute for <iframe>,

// terser --mangle-properties keep_quoted=strict

// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).

// that during initilazation changes where triggered which need

// that should not be matched to match.

// the 'y' flag.

// the .value of the Promise<{value,done}> result for the

// the Vue instances at extension time, on the extended prototype. This

// the context vm passed in is a functional context as well.

// the delayed leave may have already been cancelled

// the final result produced by the iterator.

// the following are added in 2.6

// the information will be used for async server-rendering and hydration.

// the instance may not have been registered at this time.

// the method takes exactly one argument, since that happens to be true

// the object here.

// the outer generator.

// the path list is used to control path matching priority

// the proper solution is to fix the accidental strict mode problem. If

// the raw prop value was also undefined from previous render,

// the result of another mergeOptions call.

// the root of the child tree

// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and

// the solution is simple: we save the timestamp when a handler is attached,

// the starting route that represents the initial state

// the whole point is ensuring the v-model callback gets called before

// them unless you are aware of the risk.

// then let that catch block handle the exception normally.

// then we keep falsy value but know we need to run a triggerUpdate after initialization

// there doesn't seem to be a better way to do it.

// these are also reactive so they may trigger child update if the child

// these are reserved for web because they are directly compiled away

// they are needed for the afterNavigation callback

// they need to be reactive so that HOCs using them are always updated

// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep

// things simple and return the next function itself.

// this also fixes the issue where some browsers e.g. iOS Chrome

// this also recursively registers all sub-modules

// this code should be placed here. See #731

// this info[key] doesnt need to escaped if the option is listed in __dangerouslyDisableSanitizers

// this is a slot using the new v-slot syntax without scope. although it is

// this is a somewhat expensive operation so we skip it

// this is delayed until the app mounts

// this is implemented as a special case to avoid the overhead

// this is just a safety net in case event.timeStamp is unreliable in

// this is necessary for SSR hydration because text nodes are

// this is to make sure that when a page is opened in an inactive tab which

// this is used to identify the "base" constructor to extend all plain-object

// this may be a Weex event which doesn't have this method

// this needs to be lazy-evaled because vue may be required before

// this will be called in the instance's injected lifecycle hooks

// throw the exception.

// timestamp can either be hi-res (relative to page load) or low-res

// to avoid the hashchange listener being fired too early

// to be applied OR a metaInfo watcher was triggered before the

// to create a new function object. We can even get away with assuming

// to force getter re-evaluation for hot reloading.

// to indexed object, toObject with fallback for non-array-like ES3 strings

// to mutate it.

// to speed up updates we keep track of branches which have a component with vue-meta info defined

// to string and cause the type check to miss.

// to the data on the placeholder node.

// to triggerUpdate until this initial refresh is finished

// transform component v-model data into props & events

// transform component v-model info (value and callback) into

// transform existing events in both objects into arrays so we can push later

// transition at this very moment, we make a clone of it and remove

// true  -> Array#includes

// true  -> String#at

// try...catch the pushState call to get around Safari

// turn off all instance listeners.

// two cases where extra normalization is needed:

// type bitmap

// uid for batching

// unhandled rejections tracking support, NodeJS Promise without it fails @@species test

// unified ._invoke helper method.

// unlike a newly created component,

// unwrap

// update $attrs and $listeners hash

// update __vue__ reference

// update base extend options

// update child tree's parent

// update listeners

// update nested modules

// update parent placeholder node element, recursively

// update props

// update target module

// update the title

// update vm's placeholder node without re-render

// updated listeners

// updated props

// updates

// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils

// use User Timing api (if present) for more accurate key precision

// use a Vue instance to store the state tree

// use computed to leverage its lazy-caching mechanism

// use default namespace inside foreignObject

// use getRealChild() to ignore abstract components e.g. keep-alive

// use native Set when available.

// use nextTick so the children should be added to $root

// use parent content and child template

// use parent template and child content

// use the same hook merging strategy for route hooks

// used by devtools to display a router-view badge

// used by ssr in case component is cached and beforeCreate

// used for static nodes and slot nodes because they may be reused across

// used in triggerUpdate to check if a change was triggered

// used them during render

// useful if we use some mixin to add some meta tags (like nuxt-i18n)

// user api intact

// user-attached handlers.

// user-written render functions.

// using an O(1) lookup associative array exploit

// using partial to return function with only arguments preserved in closure environment.

// using the computed prop should be a small performance increase

// utils is a library of generic helper functions non-specific to axios

// v-html and domProps: innerHTML

// v-once cached trees

// v8 likes predictible objects

// val could be undefined for unregistration

// validation and default values are handled in the child

// variable length - can't use forEach

// variable specified by delegate.resultName (see delegateYield).

// via either native Promise.then or MutationObserver.

// vue-router#1212

// vue-server-renderer can set VUE_ENV

// wait until re-render finishes before scrolling

// warn against non-factory defaults for Object & Array

// warn against non-primitive key

// warn invalid mode

// warn multiple elements

// watch for client side component updates

// we are not using Vue's default async resolving mechanism because

// we are only extracting raw values here.

// we can reuse the same tree.

// we concat the arrays without merging objects contained in,

// we divide the work into three loops to avoid mixing DOM reads and writes

// we do not release the router so it can be reused

// we do not want to evaluate the getters in this time.

// we have a recursively passed down rm callback

// we know it's MountedComponentVNode but flow doesn't

// we need to do this before overwriting $options._renderChildren.

// we now know that targetItem is a duplicate and we should ignore it in favor of sourceItem

// we set this to vm._watcher inside the watcher's constructor

// we use the mounted hook here as on page load

// we want to halt the navigation until the incoming component has been

// we want to recursively retrieve the real component to be rendered

// we will need to poll for registration until current route

// well.

// when it changes (i.e. automatically handle async actions that affect metaInfo)

// when parent component is patched.

// when sourceItem explictly defines contentKeyName or innerHTML as undefined, its

// when the value is the same, because the value may

// when using Object.defineProperty, so we have to procedurally build up

// when when somebody has screwed with setTimeout but no I.E. maddness

// where `global.postMessage` means something completely different and can't be used for this purpose.

// where microtasks have too high a priority and fire in between supposedly

// whether the request URL is of the same origin as current location.

// which have been removed for this appId

// which include a mixin with metaInfo and that mixin is used

// which means we keep the targetItem and ignore/remove the sourceItem

// will be set on the first refresh

// will return status as 0 even though it's a successful request

// window.location.protocol + '//' + window.location.host

// with hand-written render functions / JSX. In such cases a full normalization

// without getting yelled at by flow

// work around Firefox's Object.prototype.watch...

// work around IE bug when accessing document.activeElement in an iframe

// work around flow

// work around weird flow bug

// wrap

// wrapped in strict mode code which doesn't define any globals.  It's inside a

// wrapper function for providing a more flexible interface

// wtf flow?

// you've misconfigured your bundler to force strict mode and applied a

// {display: ["-webkit-box", "-ms-flexbox", "flex"]}

//normal enviroments in sane situations
