node_modules

node_modules/vue-meta/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-2018 Declan de Wet & Sébastien Chopin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/vue-meta/README.md

@@ -0,0 +1,850 @@
+<p align="center">
+  <img src="http://imgur.com/258WtHI.png" alt="vue-meta">
+</p>
+
+<h5 align="center">
+  Manage page meta info in Vue 2.0 components. SSR + Streaming supported. Inspired by <a href="https://github.com/nfl/react-helmet">react-helmet</a>.
+</h5>
+
+<p align="center">
+  <a href="https://github.com/feross/standard">
+    <img src="https://cdn.rawgit.com/feross/standard/master/badge.svg" alt="Standard - JavaScript Style">
+  </a>
+</p>
+
+<p align="center">
+<a href="https://github.com/nuxt/vue-meta/releases/latest"><img src="https://img.shields.io/github/release/nuxt/vue-meta.svg" alt="github release"></a> <a href="http://npmjs.org/package/vue-meta"><img src="https://img.shields.io/npm/v/vue-meta.svg" alt="npm version"></a> <a href="https://circleci.com/gh/nuxt/vue-meta/"><img src="https://badgen.net/circleci/github/nuxt/vue-meta" alt="Build Status"></a> <a href="https://codecov.io/gh/nuxt/vue-meta"><img src="https://codecov.io/gh/nuxt/vue-meta/branch/master/graph/badge.svg" alt="codecov"></a><br>
+<a href="https://david-dm.org/nuxt/vue-meta"><img src="https://david-dm.org/nuxt/vue-meta/status.svg" alt="dependencies Status"></a> <a href="https://david-dm.org/nuxt/vue-meta?type=dev"><img src="https://david-dm.org/nuxt/vue-meta/dev-status.svg" alt="devDependencies Status"></a><br>
+<a href="http://npm-stat.com/charts.html?package=vue-meta"><img src="https://img.shields.io/npm/dm/vue-meta.svg" alt="npm downloads"></a> <a href="https://gitter.im/nuxt/vue-meta"><img src="https://badges.gitter.im/nuxt/vue-meta.svg" alt="Gitter"></a>
+</p>
+
+```html
+<template>
+  ...
+</template>
+
+<script>
+  export default {
+    metaInfo: {
+      title: 'My Example App', // set a title
+      titleTemplate: '%s - Yay!', // title is now "My Example App - Yay!"
+      htmlAttrs: {
+        lang: 'en',
+        amp: undefined // "amp" has no value
+      }
+    }
+  }
+</script>
+```
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+# Table of Contents
+
+- [Description](#description)
+- [Installation](#installation)
+    - [Yarn](#yarn)
+    - [NPM](#npm)
+    - [CDN](#cdn)
+- [Usage](#usage)
+  - [Step 1: Preparing the plugin](#step-1-preparing-the-plugin)
+      - [Options](#options)
+  - [Step 2: Server Rendering (Optional)](#step-2-server-rendering-optional)
+    - [Step 2.1: Exposing `$meta` to `bundleRenderer`](#step-21-exposing-meta-to-bundlerenderer)
+    - [Step 2.2: Populating the document meta info with `inject()`](#step-22-populating-the-document-meta-info-with-inject)
+      - [Simple Rendering with `renderToString()`](#simple-rendering-with-rendertostring)
+      - [Streaming Rendering with `renderToStream()`](#streaming-rendering-with-rendertostream)
+  - [Step 3: Start defining `metaInfo`](#step-3-start-defining-metainfo)
+    - [Recognized `metaInfo` Properties](#recognized-metainfo-properties)
+      - [`title` (String)](#title-string)
+      - [`titleTemplate` (String | Function)](#titletemplate-string--function)
+      - [`htmlAttrs` (Object)](#htmlattrs-object)
+      - [`headAttrs` (Object)](#headattrs-object)
+      - [`bodyAttrs` (Object)](#bodyattrs-object)
+      - [`base` (Object)](#base-object)
+      - [`meta` ([Object])](#meta-object)
+      - [`link` ([Object])](#link-object)
+      - [`style` ([Object])](#style-object)
+      - [`script` ([Object])](#script-object)
+      - [`noscript` ([Object])](#noscript-object)
+      - [`__dangerouslyDisableSanitizers` ([String])](#__dangerouslydisablesanitizers-string)
+      - [`__dangerouslyDisableSanitizersByTagID` ({[String]})](#__dangerouslydisablesanitizersbytagid-string)
+      - [`changed` (Function)](#changed-function)
+    - [How `metaInfo` is Resolved](#how-metainfo-is-resolved)
+      - [Lists of Tags](#lists-of-tags)
+- [Performance](#performance)
+    - [How to prevent the update on the initial page render](#how-to-prevent-the-update-on-the-initial-page-render)
+- [FAQ](#faq)
+  - [How do I use component props and/or component data in `metaInfo`?](#how-do-i-use-component-props-andor-component-data-in-metainfo)
+  - [How do I populate `metaInfo` from the result of an asynchronous action?](#how-do-i-populate-metainfo-from-the-result-of-an-asynchronous-action)
+  - [Why doesn't `vue-meta` support `jsnext:main`?](#why-doesnt-vue-meta-support-jsnextmain)
+- [Examples](#examples)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+
+# Description
+`vue-meta` is a [Vue 2.0](https://vuejs.org) plugin that allows you to manage your app's meta information, much like [`react-helmet`](https://github.com/nfl/react-helmet) does for React. However, instead of setting your data as props passed to a proprietary component, you simply export it as part of your component's data using the `metaInfo` property.
+
+These properties, when set on a deeply nested component, will cleverly overwrite their parent components' `metaInfo`, thereby enabling custom info for each top-level view as well as coupling meta info directly to deeply nested subcomponents for more maintainable code.
+
+# Installation
+
+### Yarn
+```sh
+$ yarn add vue-meta
+```
+
+### NPM
+```sh
+$ npm install vue-meta --save
+```
+
+### CDN
+
+Use the links below - if you want a previous version, check the instructions at https://unpkg.com.
+
+<!-- start CDN generator - do **NOT** remove this comment -->
+**Uncompressed:**
+```html
+<script src="https://unpkg.com/vue-meta@1.6.0/lib/vue-meta.js"></script>
+```
+
+**Minified:**
+```html
+<script src="https://unpkg.com/vue-meta@1.6.0/lib/vue-meta.min.js"></script>
+```
+<!-- end CDN generator - do **NOT** remove this comment -->
+
+# Usage
+
+## Step 1: Preparing the plugin
+> This step is optional if you don't need SSR and `Vue` is available as a global variable. `vue-meta` will install itself in this case.
+
+In order to use this plugin, you first need to pass it to `Vue.use` - if you're not rendering on the server-side, your JS entry file will suffice. If you are rendering on the server, then place it in a file that runs both on the server and on the client before your root instance is mounted. If you're using [`vue-router`](https://github.com/vuejs/vue-router), then your main `router.js` file is a good place:
+
+**router.js:**
+```js
+import Vue from 'vue'
+import Router from 'vue-router'
+import Meta from 'vue-meta'
+
+Vue.use(Router)
+Vue.use(Meta)
+
+export default new Router({
+  ...
+})
+```
+
+#### Options
+
+`vue-meta` allows a few custom options:
+
+```js
+Vue.use(Meta, {
+  keyName: 'metaInfo', // the component option name that vue-meta looks for meta info on.
+  attribute: 'data-vue-meta', // the attribute name vue-meta adds to the tags it observes
+  ssrAttribute: 'data-vue-meta-server-rendered', // the attribute name that lets vue-meta know that meta info has already been server-rendered
+  tagIDKeyName: 'vmid' // the property name that vue-meta uses to determine whether to overwrite or append a tag
+})
+```
+
+If you don't care about server-side rendering, you can skip straight to [step 3](#step-3-start-defining-metainfo). Otherwise, continue. :smile:
+
+## Step 2: Server Rendering (Optional)
+
+If you have an isomorphic/universal webapp, you'll likely want to render your metadata on the server side as well. Here's how.
+
+### Step 2.1: Exposing `$meta` to `bundleRenderer`
+
+You'll need to expose the results of the `$meta` method that `vue-meta` adds to the Vue instance to the bundle render context before you can begin injecting your meta information. You'll need to do this in your server entry file:
+
+**server-entry.js:**
+```js
+import app from './app'
+
+const router = app.$router
+const meta = app.$meta() // here
+
+export default (context) => {
+  router.push(context.url)
+  context.meta = meta // and here
+  return app
+}
+```
+
+### Step 2.2: Populating the document meta info with `inject()`
+
+All that's left for you to do now before you can begin using `metaInfo` options in your components is to make sure they work on the server by `inject`-ing them so you can call `text()` on each item to render out the necessary info. You have two methods at your disposal:
+
+#### Simple Rendering with `renderToString()`
+
+Considerably the easiest method to wrap your head around is if your Vue server markup is rendered out as a string:
+
+**server.js:**
+
+```js
+app.get('*', (req, res) => {
+  const context = { url: req.url }
+  renderer.renderToString(context, (error, html) => {
+    if (error) return res.send(error.stack)
+    const bodyOpt = { body: true }
+    const {
+      title, htmlAttrs, headAttrs, bodyAttrs, link, style, script, noscript, meta
+    } = context.meta.inject()
+    return res.send(`
+      <!doctype html>
+      <html data-vue-meta-server-rendered ${htmlAttrs.text()}>
+        <head ${headAttrs.text()}>
+          ${meta.text()}
+          ${title.text()}
+          ${link.text()}
+          ${style.text()}
+          ${script.text()}
+          ${noscript.text()}
+        </head>
+        <body ${bodyAttrs.text()}>
+          ${html}
+          <script src="/assets/vendor.bundle.js"></script>
+          <script src="/assets/client.bundle.js"></script>
+          ${script.text(bodyOpt)}
+        </body>
+      </html>
+    `)
+  })
+})
+```
+
+If you are using a separate template file, edit your head tag with
+
+```html
+<head>
+  {{{ meta.inject().title.text() }}}
+  {{{ meta.inject().meta.text() }}}
+</head>
+```
+
+Notice the use of `{{{` to avoid double escaping. Be extremely cautious when you use `{{{` with `__dangerouslyDisableSanitizers`.
+
+#### Streaming Rendering with `renderToStream()`
+
+A little more complex, but well worth it, is to instead stream your response. `vue-meta` supports streaming with no effort (on it's part :stuck_out_tongue_winking_eye:) thanks to Vue's clever `bundleRenderer` context injection:
+
+**server.js**
+```js
+app.get('*', (req, res) => {
+  const context = { url: req.url }
+  const renderStream = renderer.renderToStream(context)
+  renderStream.once('data', () => {
+    const bodyOpt = { body: true }
+    const {
+      title, htmlAttrs, headAttrs, bodyAttrs, link, style, script, noscript, meta
+    } = context.meta.inject()
+    res.write(`
+      <!doctype html>
+      <html data-vue-meta-server-rendered ${htmlAttrs.text()}>
+        <head ${headAttrs.text()}>
+          ${meta.text()}
+          ${title.text()}
+          ${link.text()}
+          ${style.text()}
+          ${script.text()}
+          ${noscript.text()}
+        </head>
+        <body ${bodyAttrs.text()}>
+    `)
+  })
+  renderStream.on('data', (chunk) => {
+    res.write(chunk)
+  })
+  renderStream.on('end', () => {
+    res.end(`
+          <script src="/assets/vendor.bundle.js"></script>
+          <script src="/assets/client.bundle.js"></script>
+          ${script.text(bodyOpt)}
+        </body>
+      </html>
+    `)
+  })
+  renderStream.on('error', (error) => res.status(500).end(`<pre>${error.stack}</pre>`))
+})
+```
+
+## Step 3: Start defining `metaInfo`
+
+In any of your components, define a `metaInfo` property:
+
+**App.vue:**
+```html
+<template>
+  <div id="app">
+    <router-view></router-view>
+  </div>
+</template>
+
+<script>
+  export default {
+    name: 'App',
+    metaInfo: {
+      // if no subcomponents specify a metaInfo.title, this title will be used
+      title: 'Default Title',
+      // all titles will be injected into this template
+      titleTemplate: '%s | My Awesome Webapp'
+    }
+  }
+</script>
+```
+
+**Home.vue**
+```html
+<template>
+  <div id="page">
+    <h1>Home Page</h1>
+  </div>
+</template>
+
+<script>
+  export default {
+    name: 'Home',
+    metaInfo: {
+      title: 'My Awesome Webapp',
+      // override the parent template and just use the above title only
+      titleTemplate: null
+    }
+  }
+</script>
+```
+
+**About.vue**
+```html
+<template>
+  <div id="page">
+    <h1>About Page</h1>
+  </div>
+</template>
+
+<script>
+  export default {
+    name: 'About',
+    metaInfo: {
+      // title will be injected into parent titleTemplate
+      title: 'About Us'
+    }
+  }
+</script>
+```
+
+### Recognized `metaInfo` Properties
+
+#### `title` (String)
+
+Maps to the inner-text value of the `<title>` element.
+
+```js
+{
+  metaInfo: {
+    title: 'Foo Bar'
+  }
+}
+```
+
+```html
+<title>Foo Bar</title>
+```
+
+#### `titleTemplate` (String | Function)
+
+The value of `title` will be injected into the `%s` placeholder in `titleTemplate` before being rendered. The original title will be available on `metaInfo.titleChunk`.
+
+```js
+{
+  metaInfo: {
+    title: 'Foo Bar',
+    titleTemplate: '%s - Baz'
+  }
+}
+```
+
+```html
+<title>Foo Bar - Baz</title>
+```
+
+The property can also be a function (from [v1.2.0](https://github.com/nuxt/vue-meta/releases/tag/v1.2.0)):
+
+```js
+titleTemplate: (titleChunk) => {
+  // If undefined or blank then we don't need the hyphen
+  return titleChunk ? `${titleChunk} - Site Title` : 'Site Title';
+}
+```
+
+#### `htmlAttrs` (Object)
+
+Each **key:value** maps to the equivalent **attribute:value** of the `<html>` element.
+
+```js
+{
+  metaInfo: {
+    htmlAttrs: {
+      foo: 'bar',
+      amp: undefined
+    }
+  }
+}
+```
+
+```html
+<html foo="bar" amp></html>
+```
+
+#### `headAttrs` (Object)
+
+Each **key:value** maps to the equivalent **attribute:value** of the `<head>` element.
+
+```js
+{
+  metaInfo: {
+    headAttrs: {
+      foo: 'bar'
+    }
+  }
+}
+```
+
+```html
+<head foo="bar"></head>
+```
+
+#### `bodyAttrs` (Object)
+
+Each **key:value** maps to the equivalent **attribute:value** of the `<body>` element.
+
+```js
+{
+  metaInfo: {
+    bodyAttrs: {
+      bar: 'baz'
+    }
+  }
+}
+```
+
+```html
+<body bar="baz">Foo Bar</body>
+```
+
+#### `base` (Object)
+
+Maps to a newly-created `<base>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    base: { target: '_blank', href: '/' }
+  }
+}
+```
+
+```html
+<base target="_blank" href="/">
+```
+
+#### `meta` ([Object])
+
+Each item in the array maps to a newly-created `<meta>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    meta: [
+      { charset: 'utf-8' },
+      { name: 'viewport', content: 'width=device-width, initial-scale=1' }
+    ]
+  }
+}
+```
+
+```html
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+```
+
+Since v1.5.0, you can now set up meta templates that work similar to the titleTemplate:
+
+```js
+{
+  metaInfo: {
+    meta: [
+      { charset: 'utf-8' },
+      {
+        'property': 'og:title',
+        'content': 'Test title',
+        'template': chunk => `${chunk} - My page`, //or as string template: '%s - My page',
+        'vmid': 'og:title'
+      }
+    ]
+  }
+}
+```
+
+```html
+<meta charset="utf-8">
+<meta name="og:title" property="og:title" content="Test title - My page">
+```
+
+
+#### `link` ([Object])
+
+Each item in the array maps to a newly-created `<link>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    link: [
+      { rel: 'stylesheet', href: '/css/index.css' },
+      { rel: 'favicon', href: 'favicon.ico' }
+    ]
+  }
+}
+```
+
+```html
+<link rel="stylesheet" href="/css/index.css">
+<link rel="favicon" href="favicon.ico">
+```
+
+#### `style` ([Object])
+
+Each item in the array maps to a newly-created `<style>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    style: [
+      { cssText: '.foo { color: red }', type: 'text/css' }
+    ]
+  }
+}
+```
+
+```html
+<style type="text/css">.foo { color: red }</style>
+```
+
+#### `script` ([Object])
+
+Each item in the array maps to a newly-created `<script>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    script: [
+      { src: 'https://cdn.jsdelivr.net/npm/vue/dist/vue.js', async: true, defer: true }
+    ],
+  }
+}
+```
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js" async="true" defer="true"></script>
+```
+
+:warning: You have to disable sanitizers so the content of `innerHTML` won't be escaped. Please refer to [\__dangerouslyDisableSanitizers](#__dangerouslydisablesanitizers-string) section below for more info on related risks.
+
+```js
+{
+  metaInfo: {
+    script: [
+      { innerHTML: '{ "@context": "http://schema.org" }', type: 'application/ld+json' }
+    ],
+    __dangerouslyDisableSanitizers: ['script'],
+  }
+}
+```
+
+```html
+<script type="application/ld+json">{ "@context": "http://schema.org" }</script>
+```
+
+If your browser doesn't support `defer` or any other reason, you want to put `<script>` before `</body>`, use `body`.
+
+```js
+{
+  metaInfo: {
+    script: [
+      { innerHTML: 'console.log("I am in body");', type: 'text/javascript', body: true }
+    ]
+  }
+}
+```
+
+#### `noscript` ([Object])
+
+Each item in the array maps to a newly-created `<noscript>` element, where object properties map to attributes.
+
+```js
+{
+  metaInfo: {
+    noscript: [
+      { innerHTML: 'This website requires JavaScript.' }
+    ]
+  }
+}
+```
+
+```html
+<noscript>This website requires JavaScript.</noscript>
+```
+
+#### `__dangerouslyDisableSanitizers` ([String])
+
+By default, `vue-meta` sanitizes HTML entities in _every_ property. You can disable this behaviour on a per-property basis using `__dangerouslyDisableSantizers`. Just pass it a list of properties you want sanitization to be disabled on:
+
+```js
+{
+  metaInfo: {
+    title: '<I will be sanitized>',
+    meta: [{ vmid: 'description', name: 'description', content: '& I will not be <sanitized>'}],
+    __dangerouslyDisableSanitizers: ['meta']
+  }
+}
+```
+
+```html
+<title>&lt;I will be sanitized&gt;</title>
+<meta vmid="description" name="description" content="& I will not be <sanitized>">
+```
+
+:warning: **Using this option is not recommended unless you know exactly what you are doing.** By disabling sanitization, you are opening potential vectors for attacks such as SQL injection & Cross-Site Scripting (XSS). Be very careful to not compromise your application.
+
+#### `__dangerouslyDisableSanitizersByTagID` ({[String]})
+
+Provides same functionality as `__dangerouslyDisableSanitizers` but you can specify which property for which `tagIDKeyName`'s sanitization should be disabled. It expects an object with the vmid's as key and an array with property names value:
+
+```js
+{
+  metaInfo: {
+    title: '<I will be sanitized>',
+    meta: [{ vmid: 'description', name: 'still-&-sanitized', content: '& I will not be <sanitized>'}],
+    __dangerouslyDisableSanitizersByTagID: { description: ['content'] }
+  }
+}
+```
+
+```html
+<title>&lt;I will be sanitized&gt;</title>
+<meta vmid="description" name="still-&amp;-sanitized" content="& I will not be <sanitized>">
+```
+
+:warning: **Using this option is not recommended unless you know exactly what you are doing.** By disabling sanitization, you are opening potential vectors for attacks such as SQL injection & Cross-Site Scripting (XSS). Be very careful to not compromise your application.
+
+#### `changed` (Function)
+
+Will be called when the client `metaInfo` updates/changes. Receives the following parameters:
+- `newInfo` (Object) - The new state of the `metaInfo` object.
+- `addedTags` ([HTMLElement]) - a list of elements that were added.
+- `removedTags` ([HTMLElement]) - a list of elements that were removed.
+
+`this` context is the component instance `changed` is defined on.
+
+```js
+{
+  metaInfo: {
+    changed (newInfo, addedTags, removedTags) {
+      console.log('Meta info was updated!')
+    }
+  }
+}
+```
+
+### How `metaInfo` is Resolved
+
+You can define a `metaInfo` property on any component in the tree. Child components that have `metaInfo` will recursively merge their `metaInfo` into the parent context, overwriting any duplicate properties. To better illustrate, consider this component heirarchy:
+
+```html
+<parent>
+  <child></child>
+</parent>
+```
+
+If both `<parent>` _and_ `<child>` define a `title` property inside `metaInfo`, then the `title` that gets rendered will resolve to the `title` defined inside `<child>`.
+
+#### Lists of Tags
+
+When specifying an array in `metaInfo`, like in the below examples, the default behaviour is to simply concatenate the lists.
+
+**Input:**
+```js
+// parent component
+{
+  metaInfo: {
+    meta: [
+      { charset: 'utf-8' },
+      { name: 'description', content: 'foo' }
+    ]
+  }
+}
+// child component
+{
+  metaInfo: {
+    meta: [
+      { name: 'description', content: 'bar' }
+    ]
+  }
+}
+```
+
+**Output:**
+```html
+<meta charset="utf-8">
+<meta name="description" content="foo">
+<meta name="description" content="bar">
+```
+
+This is not what we want, since the meta `description` needs to be unique for every page. If you want to change this behaviour such that `description` is instead replaced, then give it a `vmid`:
+
+**Input:**
+```js
+// parent component
+{
+  metaInfo: {
+    meta: [
+      { charset: 'utf-8' },
+      { vmid: 'description', name: 'description', content: 'foo' }
+    ]
+  }
+}
+// child component
+{
+  metaInfo: {
+    meta: [
+      { vmid: 'description', name: 'description', content: 'bar' }
+    ]
+  }
+}
+```
+
+**Output:**
+```html
+<meta charset="utf-8">
+<meta vmid="description" name="description" content="bar">
+```
+
+While solutions like `react-helmet` manage the occurrence order and merge behaviour for you automatically, it involves a lot more code and is therefore prone to failure in some edge-cases, whereas this method is _almost_ bulletproof because of its versatility; _at the expense of one tradeoff:_ these `vmid` properties will be rendered out in the final markup (`vue-meta` uses these client-side to prevent duplicating or overriding markup). If you are serving your content GZIP'ped, then the slight increase in HTTP payload size is negligible.
+
+# Performance
+
+On the client, `vue-meta` batches DOM updates using [`requestAnimationFrame`](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame). It needs to do this because it registers a Vue mixin that subscribes to the [`beforeMount`](https://vuejs.org/api/#beforeMount) lifecycle hook on all components in order to be notified that renders have occurred and data is ready. If `vue-meta` did not batch updates, the DOM meta info would be re-calculated and re-updated for every component on the page in quick-succession.
+
+Thanks to batch updating, the update will only occurr once - even if the correct meta info has already been compiled by the server. If you don't want this behaviour, see below.
+
+### How to prevent the update on the initial page render
+
+Add the `data-vue-meta-server-rendered` attribute to the `<html>` tag on the server-side:
+
+```html
+<html data-vue-meta-server-rendered>
+...
+```
+
+`vue-meta` will check for this attribute whenever it attempts to update the DOM - if it exists, `vue-meta` will just remove it and perform no updates. If it does not exist, `vue-meta` will perform updates as usual.
+
+> **Note:** While this may seem verbose, it _is_ intentional. Having `vue-meta` handle this for you automatically would limit interoperability with other server-side programming languages. If you use PHP to power your server, for example, you might also have meta info handled on the server already and want to prevent this extraneous update.
+
+# FAQ
+
+Here are some answers to some frequently asked questions.
+
+## How do I use component props and/or component data in `metaInfo`?
+
+Easy. Instead of defining `metaInfo` as an object, define it as a function and access `this` as usual:
+
+**Post.vue:**
+```html
+<template>
+  <div>
+    <h1>{{{ title }}}</h1>
+  </div>
+</template>
+
+<script>
+  export default {
+    name: 'post',
+    props: ['title'],
+    data () {
+      return {
+        description: 'A blog post about some stuff'
+      }
+    },
+    metaInfo () {
+      return {
+        title: this.title,
+        meta: [
+          { vmid: 'description', name: 'description', content: this.description }
+        ]
+      }
+    }
+  }
+</script>
+```
+
+**PostContainer.vue:**
+```html
+<template>
+  <div>
+    <post :title="title"></post>
+  </div>
+</template>
+
+<script>
+  import Post from './Post.vue'
+
+  export default {
+    name: 'post-container',
+    components: { Post },
+    data () {
+      return {
+        title: 'Example blog post'
+      }
+    }
+  }
+</script>
+```
+
+## How do I populate `metaInfo` from the result of an asynchronous action?
+
+`vue-meta` will do this for you automatically when your component state changes.
+
+Just make sure that you're using the function form of `metaInfo`:
+
+```js
+{
+  data () {
+    return {
+      title: 'Foo Bar Baz'
+    }
+  },
+  metaInfo () {
+    return {
+      title: this.title
+    }
+  }
+}
+```
+
+Check out the [vuex-async](https://github.com/nuxt/vue-meta/tree/master/examples/vuex-async) example for a far more detailed demonstration if you have doubts.
+
+Credit & Thanks for this feature goes to [Sébastien Chopin](https://github.com/Atinux).
+
+## Why doesn't `vue-meta` support `jsnext:main`?
+
+Originally, it did - however, it caused [problems](https://github.com/nuxt/vue-meta/issues/25). Essentially, Vue [does not support](https://github.com/vuejs/vue/issues/2880) `jsnext:main`, and does not introspect for the `default` property that is transpiled from the ES2015 source, thus breaking module resolution.
+
+Given that `jsnext:main` is a non-standard property that won't stick around for long, and `vue-meta` is bundled into one file with no dynamic module internals as well as the fact that if you're using `vue-meta`, you're 99.9% likely to not be using it conditionally - the decision has been made to drop support for it entirely.
+
+If this were not the case, you would have to instruct Babel to convert `default` imports to the proper commonjs module syntax via a plugin, which is not ideal since many users in the Vue landscape write their code in TypeScript, not Babel.
+
+# Examples
+
+To run the examples; clone this repository & run `npm install` in the root directory, and then run `npm run dev`. Head to http://localhost:8080.

node_modules/vue-meta/node_modules/deepmerge/changelog.md

@@ -0,0 +1,121 @@
+# [3.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.2.0)
+
+- feature: added the [`customMerge`](https://github.com/TehShrike/deepmerge#custommerge) option [#133](https://github.com/TehShrike/deepmerge/pull/133)
+
+# [3.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.1.0)
+
+- typescript typing: make the `all` function generic [#129](https://github.com/TehShrike/deepmerge/pull/129)
+
+# [3.0.0](https://github.com/TehShrike/deepmerge/releases/tag/v3.0.0)
+
+- drop ES module build [#123](https://github.com/TehShrike/deepmerge/issues/123)
+
+# [2.2.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.2.1)
+
+- bug: typescript export type was wrong [#121](https://github.com/TehShrike/deepmerge/pull/121)
+
+# [2.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.2.0)
+
+- feature: added TypeScript typings [#119](https://github.com/TehShrike/deepmerge/pull/119)
+
+# [2.1.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.1.1)
+
+- documentation: Rename "methods" to "api", note ESM syntax [#103](https://github.com/TehShrike/deepmerge/pull/103)
+- documentation: Fix grammar [#107](https://github.com/TehShrike/deepmerge/pull/107)
+- documentation: Restructure headers for clarity + some wording tweaks [108](https://github.com/TehShrike/deepmerge/pull/108) + [109](https://github.com/TehShrike/deepmerge/pull/109)
+
+
+# [2.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.1.0)
+
+- feature: Support a custom `isMergeableObject` function [#96](https://github.com/TehShrike/deepmerge/pull/96)
+- documentation: note a Webpack bug that some users might need to work around [#100](https://github.com/TehShrike/deepmerge/pull/100)
+
+# [2.0.1](https://github.com/TehShrike/deepmerge/releases/tag/v2.0.1)
+
+- documentation: fix the old array merge algorithm in the readme.  [#84](https://github.com/TehShrike/deepmerge/pull/84)
+
+# [2.0.0](https://github.com/TehShrike/deepmerge/releases/tag/v2.0.0)
+
+- breaking: the array merge algorithm has changed from a complicated thing to `target.concat(source).map(element => cloneUnlessOtherwiseSpecified(element, optionsArgument))`
+- breaking: The `clone` option now defaults to `true`
+- feature: `merge.all` now accepts an array of any size, even 0 or 1 elements
+
+See [pull request 77](https://github.com/TehShrike/deepmerge/pull/77).
+
+# [1.5.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.2)
+
+- fix: no longer attempts to merge React elements [#76](https://github.com/TehShrike/deepmerge/issues/76)
+
+# [1.5.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.1)
+
+- bower support: officially dropping bower support.  If you use bower, please depend on the [unpkg distribution](https://unpkg.com/deepmerge/dist/umd.js).  See [#63](https://github.com/TehShrike/deepmerge/issues/63)
+
+# [1.5.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.5.0)
+
+- bug fix: merging objects into arrays was allowed, and doesn't make any sense. [#65](https://github.com/TehShrike/deepmerge/issues/65) published as a feature release instead of a patch because it is a decent behavior change.
+
+# [1.4.4](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.4)
+
+- bower support: updated `main` in bower.json
+
+# [1.4.3](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.3)
+
+- bower support: inline is-mergeable-object in a new CommonJS build, so that people using both bower and CommonJS can bundle the library [0b34e6](https://github.com/TehShrike/deepmerge/commit/0b34e6e95f989f2fc8091d25f0d291c08f3d2d24)
+
+# [1.4.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.2)
+
+- performance: bump is-mergeable-object dependency version for a slight performance improvement [5906c7](https://github.com/TehShrike/deepmerge/commit/5906c765d691d48e83d76efbb0d4b9ca150dc12c)
+
+# [1.4.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.1)
+
+- documentation: fix unpkg link [acc45b](https://github.com/TehShrike/deepmerge/commit/acc45be85519c1df906a72ecb24764b622d18d47)
+
+# [1.4.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.4.0)
+
+- api: instead of only exporting a UMD module, expose a UMD module with `pkg.main`, a CJS module with `pkg.browser`, and an ES module with `pkg.module` [#62](https://github.com/TehShrike/deepmerge/pull/62)
+
+# [1.3.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.2)
+
+- documentation: note the minified/gzipped file sizes [56](https://github.com/TehShrike/deepmerge/pull/56)
+- documentation: make data structures more readable in merge example: pull request [57](https://github.com/TehShrike/deepmerge/pull/57)
+
+# [1.3.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.1)
+
+- documentation: clarify and test some array merging documentation: pull request [51](https://github.com/TehShrike/deepmerge/pull/51)
+
+# [1.3.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.3.0)
+
+- feature: `merge.all`, a merge function that merges any number of objects: pull request [50](https://github.com/TehShrike/deepmerge/pull/50)
+
+# [1.2.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.2.0)
+
+- fix: an error that would be thrown when an array would be merged onto a truthy non-array value: pull request [46](https://github.com/TehShrike/deepmerge/pull/46)
+- feature: the ability to clone: Issue [28](https://github.com/TehShrike/deepmerge/issues/28), pull requests [44](https://github.com/TehShrike/deepmerge/pull/44) and [48](https://github.com/TehShrike/deepmerge/pull/48)
+- maintenance: added tests + travis to `.npmignore`: pull request [47](https://github.com/TehShrike/deepmerge/pull/47)
+
+# [1.1.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.1.1)
+
+- fix an issue where an error was thrown when merging an array onto a non-array: [Pull request 46](https://github.com/TehShrike/deepmerge/pull/46)
+
+# [1.1.0](https://github.com/TehShrike/deepmerge/releases/tag/v1.1.0)
+
+- allow consumers to specify their own array merging algorithm: [Pull request 37](https://github.com/TehShrike/deepmerge/pull/37)
+
+# [1.0.3](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.3)
+
+- adding bower.json back: [Issue 38](https://github.com/TehShrike/deepmerge/pull/38)
+- updating keywords and Github links in package.json [bc3898e](https://github.com/TehShrike/deepmerge/commit/bc3898e587a56f74591328f40f656b0152c1d5eb)
+
+# [1.0.2](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.2)
+
+- Updating the readme: dropping bower, testing that the example works: [7102fc](https://github.com/TehShrike/deepmerge/commit/7102fcc4ddec11e2d33205866f9f18df14e5aeb5)
+
+# [1.0.1](https://github.com/TehShrike/deepmerge/releases/tag/v1.0.1)
+
+- `null`, dates, and regular expressions are now properly merged in arrays: [Issue 18](https://github.com/TehShrike/deepmerge/pull/18), plus commit: [ef1c6b](https://github.com/TehShrike/deepmerge/commit/ef1c6bac8350ba12a24966f0bc7da02560827586)
+
+# 1.0.0
+
+- Should only be a patch change, because this module is READY. [Issue 15](https://github.com/TehShrike/deepmerge/issues/15)
+- Regular expressions are now treated like primitive values when merging: [Issue 30](https://github.com/TehShrike/deepmerge/pull/30)
+- Dates are now treated like primitives when merging: [Issue 31](https://github.com/TehShrike/deepmerge/issues/31)

node_modules/vue-meta/node_modules/deepmerge/dist/umd.js

@@ -0,0 +1,105 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global.deepmerge = factory());
+}(this, (function () { 'use strict';
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key);
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function mergeObject(target, source, options) {
+	var destination = {};
+	if (options.isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!options.isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		} else {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {};
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+};
+
+var deepmerge_1 = deepmerge;
+
+return deepmerge_1;
+
+})));

node_modules/vue-meta/node_modules/deepmerge/index.d.ts

@@ -0,0 +1,16 @@
+declare function deepmerge<T>(x: Partial<T>, y: Partial<T>, options?: deepmerge.Options): T;
+declare function deepmerge<T1, T2>(x: Partial<T1>, y: Partial<T2>, options?: deepmerge.Options): T1 & T2;
+
+declare namespace deepmerge {
+	export interface Options {
+		arrayMerge?(target: any[], source: any[], options?: Options): any[];
+		clone?: boolean;
+		customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | undefined;
+		isMergeableObject?(value: object): boolean;
+	}
+
+	export function all (objects: object[], options?: Options): object;
+	export function all<T> (objects: Partial<T>[], options?: Options): T;
+}
+
+export = deepmerge;

node_modules/vue-meta/node_modules/deepmerge/index.js

@@ -0,0 +1,72 @@
+var defaultIsMergeableObject = require('is-mergeable-object')
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function getMergeFunction(key, options) {
+	if (!options.customMerge) {
+		return deepmerge
+	}
+	var customMerge = options.customMerge(key)
+	return typeof customMerge === 'function' ? customMerge : deepmerge
+}
+
+function mergeObject(target, source, options) {
+	var destination = {}
+	if (options.isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options)
+		})
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!options.isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options)
+		} else {
+			destination[key] = getMergeFunction(key, options)(target[key], source[key], options)
+		}
+	})
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {}
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge
+	options.isMergeableObject = options.isMergeableObject || defaultIsMergeableObject
+
+	var sourceIsArray = Array.isArray(source)
+	var targetIsArray = Array.isArray(target)
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+}
+
+module.exports = deepmerge

node_modules/vue-meta/node_modules/deepmerge/license.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Nicholas Fisher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/vue-meta/node_modules/deepmerge/package.json

@@ -0,0 +1,73 @@
+{
+  "_from": "deepmerge@^3.2.0",
+  "_id": "deepmerge@3.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-6+LuZGU7QCNUnAJyX8cIrlzoEgggTM6B7mm+znKOX4t5ltluT9KLjN6g61ECMS0LTsLW7yDpNoxhix5FZcrIow==",
+  "_location": "/vue-meta/deepmerge",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "deepmerge@^3.2.0",
+    "name": "deepmerge",
+    "escapedName": "deepmerge",
+    "rawSpec": "^3.2.0",
+    "saveSpec": null,
+    "fetchSpec": "^3.2.0"
+  },
+  "_requiredBy": [
+    "/vue-meta"
+  ],
+  "_resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-3.2.0.tgz",
+  "_shasum": "58ef463a57c08d376547f8869fdc5bcee957f44e",
+  "_spec": "deepmerge@^3.2.0",
+  "_where": "D:\\Atom\\Git\\Laravel_CSSd\\node_modules\\vue-meta",
+  "author": {
+    "name": "Nick Fisher"
+  },
+  "bugs": {
+    "url": "https://github.com/TehShrike/deepmerge/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "A library for deep (recursive) merging of Javascript objects",
+  "devDependencies": {
+    "is-mergeable-object": "1.1.0",
+    "is-plain-object": "^2.0.4",
+    "jsmd": "0.3.1",
+    "rollup": "0.49.3",
+    "rollup-plugin-commonjs": "8.2.1",
+    "rollup-plugin-node-resolve": "3.0.0",
+    "tap": "12.0.1",
+    "ts-node": "7.0.1",
+    "typescript": "=2.2.2",
+    "uglify-js": "^3.3.12"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "homepage": "https://github.com/TehShrike/deepmerge",
+  "keywords": [
+    "merge",
+    "deep",
+    "extend",
+    "copy",
+    "clone",
+    "recursive"
+  ],
+  "license": "MIT",
+  "main": "dist/umd.js",
+  "name": "deepmerge",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/TehShrike/deepmerge.git"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "size": "npm run build && uglifyjs --compress --mangle -- ./dist/umd.js | gzip -c | wc -c",
+    "test": "npm run build && tap test/*.js && jsmd readme.md && npm run test:typescript",
+    "test:typescript": "tsc --noEmit test/typescript.ts && ts-node test/typescript.ts"
+  },
+  "version": "3.2.0"
+}

node_modules/vue-meta/node_modules/deepmerge/readme.md

@@ -0,0 +1,279 @@
+# deepmerge
+
+Merges the enumerable attributes of two or more objects deeply.
+
+> UMD bundle is 567B minified+gzipped
+
+
+### Migration from 1.x to 2+
+
+[***Check out the changes from version 1.x to 2.0.0***](https://github.com/KyleAMathews/deepmerge/blob/master/changelog.md#200)
+
+For the legacy array element-merging algorithm, see [the `arrayMerge` option below](#arraymerge).
+
+
+## Getting Started
+
+### Example Usage
+<!--js
+var merge = require('./')
+-->
+
+```js
+var x = {
+	foo: { bar: 3 },
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}]
+}
+
+var y = {
+	foo: { baz: 4 },
+	quux: 5,
+	array: [{
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}]
+}
+
+var expected = {
+	foo: {
+		bar: 3,
+		baz: 4
+	},
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}, {
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}],
+	quux: 5
+}
+
+merge(x, y) // => expected
+```
+
+
+### Installation
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm install deepmerge
+```
+
+deepmerge can be used directly in the browser without the use of package managers/bundlers as well:  [UMD version from unpkg.com](https://unpkg.com/deepmerge/dist/umd.js).
+
+
+### Includes
+
+CommonJS:
+```
+var merge = require('deepmerge')
+```
+
+ES Modules:
+```
+import * as deepmerge from 'deepmerge'
+```
+
+(support for `import merge from 'deepmerge'` was removed because of a [Webpack bug](https://github.com/webpack/webpack/issues/6584)).
+
+
+# API
+
+
+## `merge(x, y, [options])`
+
+Merge two objects `x` and `y` deeply, returning a new merged object with the
+elements from both `x` and `y`.
+
+If an element at the same key is present for both `x` and `y`, the value from
+`y` will appear in the result.
+
+Merging creates a new object, so that neither `x` or `y` is modified.
+
+**Note:** By default, arrays are merged by concatenating them.
+
+## `merge.all(arrayOfObjects, [options])`
+
+Merges any number of objects into a single result object.
+
+```js
+var x = { foo: { bar: 3 } }
+var y = { foo: { baz: 4 } }
+var z = { bar: 'yay!' }
+
+var expected = { foo: { bar: 3, baz: 4 }, bar: 'yay!' }
+
+merge.all([x, y, z]) // => expected
+```
+
+
+## Options
+
+### `arrayMerge`
+
+There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.
+
+#### Overwrite Array
+
+Overwrites the existing array values completely rather than concatenating them
+
+```js
+const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray
+
+merge(
+	[1, 2, 3],
+	[3, 2, 1],
+	{ arrayMerge: overwriteMerge }
+) // => [3, 2, 1]
+```
+
+#### Combine Array
+
+Combine arrays, such as overwriting existing defaults while also adding/keeping values that are different names
+
+To use the legacy (pre-version-2.0.0) array merging algorithm, use the following:
+
+```js
+const emptyTarget = value => Array.isArray(value) ? [] : {}
+const clone = (value, options) => merge(emptyTarget(value), value, options)
+
+function combineMerge(target, source, options) {
+	const destination = target.slice()
+
+	source.forEach(function(e, i) {
+		if (typeof destination[i] === 'undefined') {
+			const cloneRequested = options.clone !== false
+			const shouldClone = cloneRequested && options.isMergeableObject(e)
+			destination[i] = shouldClone ? clone(e, options) : e
+		} else if (options.isMergeableObject(e)) {
+			destination[i] = merge(target[i], e, options)
+		} else if (target.indexOf(e) === -1) {
+			destination.push(e)
+		}
+	})
+	return destination
+}
+
+merge(
+	[{ a: true }],
+	[{ b: true }, 'ah yup'],
+	{ arrayMerge: combineMerge }
+) // => [{ a: true, b: true }, 'ah yup']
+```
+
+### `isMergeableObject`
+
+By default, deepmerge clones every property from almost every kind of object.
+
+You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.
+
+You can accomplish this by passing in a function for the `isMergeableObject` option.
+
+If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in [`is-plain-object`](https://github.com/jonschlinkert/is-plain-object).
+
+```js
+const isPlainObject = require('is-plain-object')
+
+function SuperSpecial() {
+	this.special = 'oh yeah man totally'
+}
+
+const instantiatedSpecialObject = new SuperSpecial()
+
+const target = {
+	someProperty: {
+		cool: 'oh for sure'
+	}
+}
+
+const source = {
+	someProperty: instantiatedSpecialObject
+}
+
+const defaultOutput = merge(target, source)
+
+defaultOutput.someProperty.cool // => 'oh for sure'
+defaultOutput.someProperty.special // => 'oh yeah man totally'
+defaultOutput.someProperty instanceof SuperSpecial // => false
+
+const customMergeOutput = merge(target, source, {
+	isMergeableObject: isPlainObject
+})
+
+customMergeOutput.someProperty.cool // => undefined
+customMergeOutput.someProperty.special // => 'oh yeah man totally'
+customMergeOutput.someProperty instanceof SuperSpecial // => true
+```
+
+### `customMerge`
+
+Specifies a function which can be used to override the default merge behavior for a property, based on the property name.
+
+The `customMerge` function will be passed the key for each property, and should return the function which should be used to merge the values for that property.
+
+It may also return undefined, in which case the default merge behaviour will be used.
+
+```js
+const alex = {
+    name: {
+        first: 'Alex',
+        last: 'Alexson'
+    },
+    pets: ['Cat', 'Parrot']
+}
+
+const tony = {
+    name: {
+        first: 'Tony',
+        last: 'Tonison'
+    },
+    pets: ['Dog']
+}
+
+const mergeNames = (nameA, nameB) => `${nameA.first} and ${nameB.first}`
+
+const options = {
+    customMerge: (key) => {
+        if (key === 'name') {
+            return mergeNames
+        }
+    }
+}
+
+const result = merge(alex, tony, options)
+
+result.name // => 'Alex and Tony'
+result.pets // => ['Cat', 'Parrot', 'Dog']
+```
+
+
+### `clone`
+
+*Deprecated.*
+
+Defaults to `true`.
+
+If `clone` is `false` then child objects will be copied directly instead of being cloned.  This was the default behavior before version 2.x.
+
+
+# Testing
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm test
+```
+
+
+# License
+
+MIT

node_modules/vue-meta/node_modules/deepmerge/rollup.config.js

@@ -0,0 +1,16 @@
+import resolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+
+const pkg = require(`./package.json`)
+
+export default {
+	input: `index.js`,
+	name: `deepmerge`,
+	plugins: [
+		commonjs(),
+		resolve(),
+	],
+	output: [
+		{ file: pkg.main, format: `umd` },
+	],
+}

node_modules/vue-meta/package.json

@@ -0,0 +1,154 @@
+{
+  "_from": "vue-meta@^1.5.2",
+  "_id": "vue-meta@1.6.0",
+  "_inBundle": false,
+  "_integrity": "sha512-LLHejsOYbJiSEDSgZvjHB3fFY7lUxsDFLkuSqf5eBohEvhhddBTOHa3heoFTcI5sxsZSZt26uUzoLVe4CT6Y4A==",
+  "_location": "/vue-meta",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vue-meta@^1.5.2",
+    "name": "vue-meta",
+    "escapedName": "vue-meta",
+    "rawSpec": "^1.5.2",
+    "saveSpec": null,
+    "fetchSpec": "^1.5.2"
+  },
+  "_requiredBy": [
+    "#DEV:/"
+  ],
+  "_resolved": "https://registry.npmjs.org/vue-meta/-/vue-meta-1.6.0.tgz",
+  "_shasum": "89b664f6011a207e098e8ba3b9d32e29c819b65d",
+  "_spec": "vue-meta@^1.5.2",
+  "_where": "D:\\Atom\\Git\\Laravel_CSSd",
+  "author": {
+    "name": "Declan de Wet",
+    "email": "declandewet@me.com"
+  },
+  "bugs": {
+    "url": "https://github.com/declandewet/vue-meta/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "deepmerge": "^3.2.0",
+    "lodash.isplainobject": "^4.0.6",
+    "lodash.uniqueid": "^4.0.1",
+    "object-assign": "^4.1.1"
+  },
+  "deprecated": false,
+  "description": "manage page meta info in Vue 2.0 server-rendered apps",
+  "devDependencies": {
+    "@babel/cli": "^7.2.3",
+    "@babel/core": "^7.4.0",
+    "@babel/node": "^7.2.2",
+    "@babel/preset-env": "^7.4.2",
+    "@babel/register": "^7.4.0",
+    "babel-loader": "^8.0.5",
+    "babel-plugin-istanbul": "^5.1.1",
+    "chai": "^4.2.0",
+    "codecov": "^3.2.0",
+    "cross-env": "^5.2.0",
+    "css-loader": "^2.1.1",
+    "doctoc": "^1.4.0",
+    "es6-promise": "^4.2.6",
+    "express": "^4.16.4",
+    "express-urlrewrite": "^1.2.0",
+    "file-loader": "^3.0.1",
+    "karma": "^4.0.1",
+    "karma-chai": "^0.1.0",
+    "karma-coverage": "^1.1.2",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "karma-sourcemap-loader": "^0.3.7",
+    "karma-webpack": "^3.0.5",
+    "mocha": "^6.0.2",
+    "phantomjs-prebuilt": "^2.1.16",
+    "rimraf": "^2.6.3",
+    "rollup": "^1.7.4",
+    "rollup-plugin-buble": "^0.19.6",
+    "rollup-plugin-commonjs": "^9.2.2",
+    "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-node-resolve": "^4.0.1",
+    "snazzy": "^8.0.0",
+    "standard": "^12.0.1",
+    "uglify-js": "^3.5.2",
+    "update-section": "^0.3.3",
+    "vue": "^2.6.10",
+    "vue-loader": "^15.7.0",
+    "vue-router": "^3.0.2",
+    "vue-server-renderer": "^2.6.10",
+    "vue-template-compiler": "^2.6.10",
+    "vuex": "^3.1.0",
+    "webpack": "^4.29.6",
+    "webpack-dev-server": "^3.2.1"
+  },
+  "files": [
+    "lib",
+    "types/index.d.ts",
+    "types/vue.d.ts"
+  ],
+  "homepage": "https://github.com/declandewet/vue-meta",
+  "keywords": [
+    "attribute",
+    "google",
+    "head",
+    "helmet",
+    "info",
+    "meta",
+    "seo",
+    "server",
+    "ssr",
+    "title",
+    "universal",
+    "vue"
+  ],
+  "license": "MIT",
+  "main": "lib/vue-meta.js",
+  "name": "vue-meta",
+  "nyc": {
+    "exclude": [
+      "test/**/*.js"
+    ]
+  },
+  "repository": {
+    "url": "git+ssh://git@github.com/declandewet/vue-meta.git",
+    "type": "git"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "codecov": "codecov",
+    "deploy": "npm version",
+    "dev": "babel-node examples/server.js",
+    "lint": "standard --verbose | snazzy",
+    "minify": "uglifyjs lib/vue-meta.js -cm --comments -o lib/vue-meta.min.js",
+    "postbuild": "npm run minify",
+    "postdeploy": "git push origin master --follow-tags && npm run release",
+    "postversion": "npm run update-cdn && git add . && git commit -m \":ship: CDN update\"",
+    "prebuild": "rimraf lib",
+    "predeploy": "git checkout master && git pull -r",
+    "prerelease": "npm run build",
+    "pretest": "npm run lint",
+    "preversion": "npm run toc",
+    "release": "npm publish",
+    "test": "cross-env NODE_ENV=test karma start karma.conf.js",
+    "toc": "doctoc README.md --title '# Table of Contents'",
+    "update-cdn": "babel-node scripts/update-cdn.js"
+  },
+  "standard": {
+    "globals": [
+      "Vue",
+      "define",
+      "describe",
+      "it",
+      "expect",
+      "before",
+      "beforeEach",
+      "after",
+      "afterEach"
+    ]
+  },
+  "typings": "types/index.d.ts",
+  "version": "1.6.0"
+}

node_modules/vue-meta/types/index.d.ts

@@ -0,0 +1,49 @@
+import './vue';
+import { PluginFunction } from 'vue/types/plugin';
+
+/**
+ * Installation function
+ *
+ * @param {Vue} Vue - the Vue constructor.
+ * @param {{
+ *   keyName: string, // the component option name that vue-meta looks for meta info on.
+ *   attribute: string, // the attribute name vue-meta adds to the tags it observes
+ *   ssrAttribute: string, // the attribute name that lets vue-meta know that meta info has already been server-rendered
+ *   tagIDKeyName: string // the property name that vue-meta uses to determine whether to overwrite or append a tag
+ * }} options
+ */
+declare const Meta: PluginFunction<{
+  keyName: string, // the component option name that vue-meta looks for meta info on.
+  attribute: string, // the attribute name vue-meta adds to the tags it observes
+  ssrAttribute: string, // the attribute name that lets vue-meta know that meta info has already been server-rendered
+  tagIDKeyName: string // the property name that vue-meta uses to determine whether to overwrite or append a tag
+}>;
+
+export default Meta;
+
+export interface MetaInfo {
+  title?: string
+  titleTemplate?: string | ((titleChunk: string) => string)
+  htmlAttrs?: { [key: string]: string }
+  bodyAttrs?: { [key: string]: string }
+  base?: { target: string, href: string }
+
+  meta?: {
+    vmid?: string,
+    charset?: string,
+    content?: string,
+    'http-equiv'?: 'content-security-policy' | 'refresh',
+    name?: string,
+      [key: string]: any
+  }[]
+
+  link?: { rel: string, href: string, [key: string]: any }[]
+  style?: { cssText: string, type: string, [key: string]: any }[]
+  script?: { innerHTML?: string, src?: string, type: string, [key: string]: any }[]
+  noscript?: { innerHTML: string, [key: string]: any }[]
+
+  __dangerouslyDisableSanitizers?: string[]
+  __dangerouslyDisableSanitizersByTagID?: string[]
+
+  changed?: <T extends object>(newInfo: T, addedTags: HTMLElement[], removedTags: HTMLElement[]) => void
+}

node_modules/vue-meta/types/vue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Augment the typings of Vue.js
+ */
+
+import Vue, { ComponentOptions } from "vue";
+import { MetaInfo } from './index';
+
+declare module "vue/types/options" {
+  interface ComponentOptions<V extends Vue> {
+    metaInfo?: MetaInfo | (() => MetaInfo)
+  }
+}
+
+declare module "vue/types/vue" {
+  interface Vue {
+    $meta(): MetaInfo
+  }
+}