[VersionBeta] V.1.0.0.0

[Adds]
1.拖拽的资源包

node_modules/vuedraggable/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2019 David Desmaisons
+
+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/vuedraggable/README.md

@@ -0,0 +1,387 @@
+<p align="center"><img width="140"src="https://raw.githubusercontent.com/SortableJS/Vue.Draggable/master/logo.svg?sanitize=true"></p>
+<h1 align="center">Vue.Draggable</h1>
+
+[![CircleCI](https://circleci.com/gh/SortableJS/Vue.Draggable.svg?style=shield)](https://circleci.com/gh/SortableJS/Vue.Draggable)
+[![Coverage](https://codecov.io/gh/SortableJS/Vue.Draggable/branch/master/graph/badge.svg)](https://codecov.io/gh/SortableJS/Vue.Draggable)
+[![codebeat badge](https://codebeat.co/badges/7a6c27c8-2d0b-47b9-af55-c2eea966e713)](https://codebeat.co/projects/github-com-sortablejs-vue-draggable-master)
+[![GitHub open issues](https://img.shields.io/github/issues/SortableJS/Vue.Draggable.svg)](https://github.com/SortableJS/Vue.Draggable/issues?q=is%3Aopen+is%3Aissue)
+[![npm download](https://img.shields.io/npm/dt/vuedraggable.svg?maxAge=30)](https://www.npmjs.com/package/vuedraggable)
+[![npm download per month](https://img.shields.io/npm/dm/vuedraggable.svg)](https://www.npmjs.com/package/vuedraggable)
+[![npm version](https://img.shields.io/npm/v/vuedraggable.svg)](https://www.npmjs.com/package/vuedraggable)
+[![MIT License](https://img.shields.io/github/license/SortableJS/Vue.Draggable.svg)](https://github.com/SortableJS/Vue.Draggable/blob/master/LICENSE)
+
+
+Vue component (Vue.js 2.0) or directive (Vue.js 1.0) allowing drag-and-drop and synchronization with view model array.
+
+Based on and offering all features of [Sortable.js](https://github.com/RubaXa/Sortable)
+
+## Demo
+
+![demo gif](https://raw.githubusercontent.com/SortableJS/Vue.Draggable/master/example.gif)
+
+## Live Demos
+
+https://sortablejs.github.io/Vue.Draggable/
+
+https://david-desmaisons.github.io/draggable-example/
+
+## Features
+
+* Full support of [Sortable.js](https://github.com/RubaXa/Sortable) features:
+    * Supports touch devices
+    * Supports drag handles and selectable text
+    * Smart auto-scrolling
+    * Support drag and drop between different lists
+    * No jQuery dependency
+* Keeps in sync HTML and view model list
+* Compatible with Vue.js 2.0 transition-group
+* Cancellation support
+* Events reporting any changes when full control is needed
+* Reuse existing UI library components (such as [vuetify](https://vuetifyjs.com), [element](http://element.eleme.io/), or [vue material](https://vuematerial.io) etc...) and make them draggable using `tag` and `componentData` props
+
+## Backers
+
+ <a href="https://flatlogic.com/admin-dashboards">
+ <img width="190" style="margin-top: 10px;" src="https://flatlogic.com/assets/logo-d9e7751df5fddd11c911945a75b56bf72bcfe809a7f6dca0e32d7b407eacedae.svg">
+ </a>
+
+Admin Dashboard Templates made with Vue, React and Angular.
+
+
+## Donate
+
+Find this project useful? You can buy me a :coffee: or a :beer:
+
+[![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=GYAEKQZJ4FQT2&currency_code=USD&source=url)
+
+
+## Installation
+
+### With npm or yarn 
+
+```bash
+yarn add vuedraggable
+
+npm i -S vuedraggable
+```
+
+**Beware it is vuedraggable for Vue 2.0 and not vue-draggable which is for version 1.0**
+
+### with direct link 
+```html
+
+<script src="//cdnjs.cloudflare.com/ajax/libs/vue/2.5.2/vue.min.js"></script>
+<!-- CDNJS :: Sortable (https://cdnjs.com/) -->
+<script src="//cdn.jsdelivr.net/npm/sortablejs@1.8.4/Sortable.min.js"></script>
+<!-- CDNJS :: Vue.Draggable (https://cdnjs.com/) -->
+<script src="//cdnjs.cloudflare.com/ajax/libs/Vue.Draggable/2.20.0/vuedraggable.umd.min.js"></script>
+
+```
+
+[cf example section](https://github.com/SortableJS/Vue.Draggable/tree/master/example)
+
+## For Vue.js 2.0
+
+Use draggable component:
+
+### Typical use:
+``` html
+<draggable v-model="myArray" group="people" @start="drag=true" @end="drag=false">
+   <div v-for="element in myArray" :key="element.id">{{element.name}}</div>
+</draggable>
+```
+.vue file:
+``` js
+  import draggable from 'vuedraggable'
+  ...
+  export default {
+        components: {
+            draggable,
+        },
+  ...
+```
+
+### With `transition-group`:
+``` html
+<draggable v-model="myArray">
+    <transition-group>
+        <div v-for="element in myArray" :key="element.id">
+            {{element.name}}
+        </div>
+    </transition-group>
+</draggable>
+```
+
+Draggable component should directly wrap the draggable elements, or a `transition-component` containing the draggable elements.
+
+
+### With footer slot:
+``` html
+<draggable v-model="myArray" draggable=".item">
+    <div v-for="element in myArray" :key="element.id" class="item">
+        {{element.name}}
+    </div>
+    <button slot="footer" @click="addPeople">Add</button>
+</draggable>
+```
+### With header slot:
+``` html
+<draggable v-model="myArray" draggable=".item'">
+    <div v-for="element in myArray" :key="element.id" class="item">
+        {{element.name}}
+    </div>
+    <button slot="header" @click="addPeople">Add</button>
+</draggable>
+```
+
+### With Vuex:
+
+```html
+<draggable v-model='myList'>
+``` 
+
+```javascript
+computed: {
+    myList: {
+        get() {
+            return this.$store.state.myList
+        },
+        set(value) {
+            this.$store.commit('updateList', value)
+        }
+    }
+}
+```
+
+
+### Props
+#### value
+Type: `Array`<br>
+Required: `false`<br>
+Default: `null`
+
+Input array to draggable component. Typically same array as referenced by inner element v-for directive.<br>
+This is the preferred way to use Vue.draggable as it is compatible with Vuex.<br>
+It should not be used directly but only though the `v-model` directive:
+```html
+<draggable v-model="myArray">
+```
+
+#### list
+Type: `Array`<br>
+Required: `false`<br>
+Default: `null`
+
+Alternative to the `value` prop, list is an array to be synchronized with drag-and-drop.<br>
+The main difference is that `list` prop is updated by draggable component using splice method, whereas `value` is immutable.<br>
+**Do not use in conjunction with value prop.**
+
+#### All sortable options
+New in version 2.19
+
+Sortable options can be set directly as vue.draggable props since version 2.19.
+
+This means that all [sortable option](https://github.com/RubaXa/Sortable#options) are valid sortable props with the notable exception of all the method starting by "on" as draggable component expose the same API via events.
+
+kebab-case propery are supported: for example `ghost-class` props will be converted to `ghostClass` sortable option.
+
+Example setting handle, sortable and a group option:
+```HTML
+<draggable
+        v-model="list"
+        handle=".handle"
+        :group="{ name: 'people', pull: 'clone', put: false }"
+        ghost-class="ghost"
+        :sort="false"
+        @change="log"
+      >
+      <!-- -->
+</draggable>
+```
+
+#### tag
+Type: `String`<br>
+Default: `'div'`
+
+HTML node type of the element that draggable component create as outer element for the included slot.<br>
+It is also possible to pass the name of vue component as element. In this case, draggable attribute will be passed to the create component.<br>
+See also [componentData](#componentdata) if you need to set props or event to the created component.
+
+#### clone
+Type: `Function`<br>
+Required: `false`<br>
+Default: `(original) => { return original;}`<br>
+
+Function called on the source component to clone element when clone option is true. The unique argument is the viewModel element to be cloned and the returned value is its cloned version.<br>
+By default vue.draggable reuses the viewModel element, so you have to use this hook if you want to clone or deep clone it.
+
+#### move
+Type: `Function`<br>
+Required: `false`<br>
+Default: `null`<br>
+
+If not null this function will be called in a similar way as [Sortable onMove callback](https://github.com/RubaXa/Sortable#move-event-object).
+Returning false will cancel the drag operation.
+
+```javascript
+function onMoveCallback(evt, originalEvent){
+   ...
+    // return false; — for cancel
+}
+```
+evt object has same property as [Sortable onMove event](https://github.com/RubaXa/Sortable#move-event-object), and 3 additional properties:
+ - `draggedContext`:  context linked to dragged element
+   - `index`: dragged element index
+   - `element`: dragged element underlying view model element
+   - `futureIndex`:  potential index of the dragged element if the drop operation is accepted
+ - `relatedContext`: context linked to current drag operation
+   - `index`: target element index
+   - `element`: target element view model element
+   - `list`: target list
+   - `component`: target VueComponent
+
+HTML:
+```HTML
+<draggable :list="list" :move="checkMove">
+```
+javascript:
+```javascript
+checkMove: function(evt){
+    return (evt.draggedContext.element.name!=='apple');
+}
+```
+See complete example: [Cancel.html](https://github.com/SortableJS/Vue.Draggable/blob/master/examples/Cancel.html), [cancel.js](https://github.com/SortableJS/Vue.Draggable/blob/master/examples/script/cancel.js)
+
+#### componentData
+Type: `Object`<br>
+Required: `false`<br>
+Default: `null`<br>
+
+This props is used to pass additional information to child component declared by [tag props](#tag).<br>
+Value:
+* `props`: props to be passed to the child component
+* `attrs`: attrs to be passed to the child component
+* `on`: events to be subscribe in the child component
+
+Example (using [element UI library](http://element.eleme.io/#/en-US)):
+```HTML
+<draggable tag="el-collapse" :list="list" :component-data="getComponentData()">
+    <el-collapse-item v-for="e in list" :title="e.title" :name="e.name" :key="e.name">
+        <div>{{e.description}}</div>
+     </el-collapse-item>
+</draggable>
+```
+```javascript
+methods: {
+    handleChange() {
+      console.log('changed');
+    },
+    inputChanged(value) {
+      this.activeNames = value;
+    },
+    getComponentData() {
+      return {
+        on: {
+          change: this.handleChange,
+          input: this.inputChanged
+        },
+        attrs:{
+          wrap: true
+        },
+        props: {
+          value: this.activeNames
+        }
+      };
+    }
+  }
+```
+
+### Events
+
+* Support for Sortable events:
+
+  `start`, `add`, `remove`, `update`, `end`, `choose`, `unchoose`, `sort`, `filter`, `clone`<br>
+  Events are called whenever onStart, onAdd, onRemove, onUpdate, onEnd, onChoose, onUnchoose, onSort, onClone are fired by Sortable.js with the same argument.<br>
+  [See here for reference](https://github.com/RubaXa/Sortable#event-object-demo)
+
+  Note that SortableJS OnMove callback is mapped with the [move prop](https://github.com/SortableJS/Vue.Draggable/blob/master/README.md#move)
+
+HTML:
+```HTML
+<draggable :list="list" @end="onEnd">
+```
+
+* change event
+
+  `change` event is triggered when list prop is not null and the corresponding array is altered due to drag-and-drop operation.<br>
+  This event is called with one argument containing one of the following properties:
+  - `added`:  contains information of an element added to the array
+    - `newIndex`: the index of the added element
+    - `element`: the added element
+  - `removed`:  contains information of an element removed from to the array
+    - `oldIndex`: the index of the element before remove
+    - `element`: the removed element
+  - `moved`:  contains information of an element moved within the array
+    - `newIndex`: the current index of the moved element
+    - `oldIndex`: the old index of the moved element
+    - `element`: the moved element
+
+### Slots
+
+Limitation: neither header or footer slot works in conjunction with transition-group.
+
+#### Header
+Use the `header` slot to add none-draggable element inside the vuedraggable component.
+Important: it should be used in conjunction with draggable option to tag draggable element.
+Note that header slot will always be added before the default slot regardless its position in the template.
+Ex:
+
+``` html
+<draggable v-model="myArray" draggable=".item">
+    <div v-for="element in myArray" :key="element.id" class="item">
+        {{element.name}}
+    </div>
+    <button slot="header" @click="addPeople">Add</button>
+</draggable>
+```
+
+#### Footer
+Use the `footer` slot to add none-draggable element inside the vuedraggable component.
+Important: it should be used in conjunction with draggable option to tag draggable elements.
+Note that footer slot will always be added after the default slot regardless its position in the template.
+Ex:
+
+``` html
+<draggable v-model="myArray" draggable=".item">
+    <div v-for="element in myArray" :key="element.id" class="item">
+        {{element.name}}
+    </div>
+    <button slot="footer" @click="addPeople">Add</button>
+</draggable>
+```
+ ### Gotchas
+ 
+ - Vue.draggable children should always map the list or value prop using a v-for directive
+   * You may use [header](https://github.com/SortableJS/Vue.Draggable#header) and [footer](https://github.com/SortableJS/Vue.Draggable#footer) slot to by-pass this limitation.
+ 
+ - Children elements inside v-for should be keyed as any element in Vue.js. Be carefull to provide revelant key values in particular:
+    * typically providing array index as keys won't work as key should be linked to the items content
+    * cloned elements should provide updated keys, it is doable using the [clone props](#clone) for example
+
+
+ ### Example 
+  * [Clone](https://sortablejs.github.io/Vue.Draggable/#/custom-clone)
+  * [Handle](https://sortablejs.github.io/Vue.Draggable/#/handle)
+  * [Transition](https://sortablejs.github.io/Vue.Draggable/#/transition-example-2)
+  * [Nested](https://sortablejs.github.io/Vue.Draggable/#/nested-example)
+  * [Table](https://sortablejs.github.io/Vue.Draggable/#/table-example)
+ 
+ ### Full demo example
+
+[draggable-example](https://github.com/David-Desmaisons/draggable-example)
+
+## For Vue.js 1.0
+
+[See here](documentation/Vue.draggable.for.ReadME.md)
+
+```

node_modules/vuedraggable/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "vuedraggable",
+  "version": "2.23.2",
+  "description": "draggable component for vue",
+  "license": "MIT",
+  "main": "dist/vuedraggable.umd.min.js",
+  "private": false,
+  "scripts": {
+    "serve": "vue-cli-service serve ./example/main.js --open --mode local",
+    "build:doc": "vue-cli-service build ./example/main.js --dest docs --mode development",
+    "build": "vue-cli-service build --name vuedraggable --entry ./src/vuedraggable.js --target lib",
+    "lint": "vue-cli-service lint src example",
+    "prepublishOnly": "npm run lint && npm run test:unit && npm run build:doc && npm run build",
+    "test:unit": "vue-cli-service test:unit --coverage",
+    "test:coverage": "vue-cli-service test:unit --coverage --verbose && codecov"
+  },
+  "keywords": [
+    "vue",
+    "vuejs",
+    "drag",
+    "and",
+    "drop",
+    "list",
+    "Sortable.js",
+    "component",
+    "nested"
+  ],
+  "dependencies": {
+    "sortablejs": "^1.10.1"
+  },
+  "devDependencies": {
+    "@vue/cli-plugin-babel": "^3.4.0",
+    "@vue/cli-plugin-eslint": "^3.4.0",
+    "@vue/cli-plugin-unit-jest": "^3.4.0",
+    "@vue/cli-service": "^3.4.0",
+    "@vue/eslint-config-prettier": "^4.0.1",
+    "@vue/test-utils": "^1.0.0-beta.20",
+    "babel-core": "7.0.0-bridge.0",
+    "babel-eslint": "^10.0.1",
+    "babel-jest": "^23.6.0",
+    "bootstrap": "^4.3.1",
+    "codecov": "^3.2.0",
+    "component-fixture": "^0.4.1",
+    "element-ui": "^2.5.4",
+    "eslint": "^5.8.0",
+    "eslint-plugin-vue": "^5.0.0",
+    "font-awesome": "^4.7.0",
+    "jquery": "^3.3.1",
+    "vue": "^2.6.8",
+    "vue-cli-plugin-component": "^1.10.5",
+    "vue-router": "^3.0.2",
+    "vue-server-renderer": "^2.6.8",
+    "vue-template-compiler": "^2.6.8",
+    "vuetify": "^1.5.16",
+    "vuex": "^3.1.1"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "node": true
+    },
+    "extends": [
+      "plugin:vue/essential",
+      "@vue/prettier"
+    ],
+    "rules": {},
+    "parserOptions": {
+      "parser": "babel-eslint"
+    }
+  },
+  "postcss": {
+    "plugins": {
+      "autoprefixer": {}
+    }
+  },
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not ie <= 8"
+  ],
+  "files": [
+    "dist/*.css",
+    "dist/*.map",
+    "dist/*.js",
+    "src/*"
+  ],
+  "module": "dist/vuedraggable.common.js"
+}

node_modules/vuedraggable/src/util/helper.js

@@ -0,0 +1,36 @@
+function getConsole() {
+  if (typeof window !== "undefined") {
+    return window.console;
+  }
+  return global.console;
+}
+const console = getConsole();
+
+function cached(fn) {
+  const cache = Object.create(null);
+  return function cachedFn(str) {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+}
+
+const regex = /-(\w)/g;
+const camelize = cached(str =>
+  str.replace(regex, (_, c) => (c ? c.toUpperCase() : ""))
+);
+
+function removeNode(node) {
+  if (node.parentElement !== null) {
+    node.parentElement.removeChild(node);
+  }
+}
+
+function insertNodeAt(fatherNode, node, position) {
+  const refNode =
+    position === 0
+      ? fatherNode.children[0]
+      : fatherNode.children[position - 1].nextSibling;
+  fatherNode.insertBefore(node, refNode);
+}
+
+export { insertNodeAt, camelize, console, removeNode };

node_modules/vuedraggable/src/vuedraggable.js

@@ -0,0 +1,485 @@
+import Sortable from "sortablejs";
+import { insertNodeAt, camelize, console, removeNode } from "./util/helper";
+
+function buildAttribute(object, propName, value) {
+  if (value === undefined) {
+    return object;
+  }
+  object = object || {};
+  object[propName] = value;
+  return object;
+}
+
+function computeVmIndex(vnodes, element) {
+  return vnodes.map(elt => elt.elm).indexOf(element);
+}
+
+function computeIndexes(slots, children, isTransition, footerOffset) {
+  if (!slots) {
+    return [];
+  }
+
+  const elmFromNodes = slots.map(elt => elt.elm);
+  const footerIndex = children.length - footerOffset;
+  const rawIndexes = [...children].map((elt, idx) =>
+    idx >= footerIndex ? elmFromNodes.length : elmFromNodes.indexOf(elt)
+  );
+  return isTransition ? rawIndexes.filter(ind => ind !== -1) : rawIndexes;
+}
+
+function emit(evtName, evtData) {
+  this.$nextTick(() => this.$emit(evtName.toLowerCase(), evtData));
+}
+
+function delegateAndEmit(evtName) {
+  return evtData => {
+    if (this.realList !== null) {
+      this["onDrag" + evtName](evtData);
+    }
+    emit.call(this, evtName, evtData);
+  };
+}
+
+function isTransitionName(name) {
+  return ["transition-group", "TransitionGroup"].includes(name);
+}
+
+function isTransition(slots) {
+  if (!slots || slots.length !== 1) {
+    return false;
+  }
+  const [{ componentOptions }] = slots;
+  if (!componentOptions) {
+    return false;
+  }
+  return isTransitionName(componentOptions.tag);
+}
+
+function getSlot(slot, scopedSlot, key) {
+  return slot[key] || (scopedSlot[key] ? scopedSlot[key]() : undefined);
+}
+
+function computeChildrenAndOffsets(children, slot, scopedSlot) {
+  let headerOffset = 0;
+  let footerOffset = 0;
+  const header = getSlot(slot, scopedSlot, "header");
+  if (header) {
+    headerOffset = header.length;
+    children = children ? [...header, ...children] : [...header];
+  }
+  const footer = getSlot(slot, scopedSlot, "footer");
+  if (footer) {
+    footerOffset = footer.length;
+    children = children ? [...children, ...footer] : [...footer];
+  }
+  return { children, headerOffset, footerOffset };
+}
+
+function getComponentAttributes($attrs, componentData) {
+  let attributes = null;
+  const update = (name, value) => {
+    attributes = buildAttribute(attributes, name, value);
+  };
+  const attrs = Object.keys($attrs)
+    .filter(key => key === "id" || key.startsWith("data-"))
+    .reduce((res, key) => {
+      res[key] = $attrs[key];
+      return res;
+    }, {});
+  update("attrs", attrs);
+
+  if (!componentData) {
+    return attributes;
+  }
+  const { on, props, attrs: componentDataAttrs } = componentData;
+  update("on", on);
+  update("props", props);
+  Object.assign(attributes.attrs, componentDataAttrs);
+  return attributes;
+}
+
+const eventsListened = ["Start", "Add", "Remove", "Update", "End"];
+const eventsToEmit = ["Choose", "Unchoose", "Sort", "Filter", "Clone"];
+const readonlyProperties = ["Move", ...eventsListened, ...eventsToEmit].map(
+  evt => "on" + evt
+);
+var draggingElement = null;
+
+const props = {
+  options: Object,
+  list: {
+    type: Array,
+    required: false,
+    default: null
+  },
+  value: {
+    type: Array,
+    required: false,
+    default: null
+  },
+  noTransitionOnDrag: {
+    type: Boolean,
+    default: false
+  },
+  clone: {
+    type: Function,
+    default: original => {
+      return original;
+    }
+  },
+  element: {
+    type: String,
+    default: "div"
+  },
+  tag: {
+    type: String,
+    default: null
+  },
+  move: {
+    type: Function,
+    default: null
+  },
+  componentData: {
+    type: Object,
+    required: false,
+    default: null
+  }
+};
+
+const draggableComponent = {
+  name: "draggable",
+
+  inheritAttrs: false,
+
+  props,
+
+  data() {
+    return {
+      transitionMode: false,
+      noneFunctionalComponentMode: false
+    };
+  },
+
+  render(h) {
+    const slots = this.$slots.default;
+    this.transitionMode = isTransition(slots);
+    const { children, headerOffset, footerOffset } = computeChildrenAndOffsets(
+      slots,
+      this.$slots,
+      this.$scopedSlots
+    );
+    this.headerOffset = headerOffset;
+    this.footerOffset = footerOffset;
+    const attributes = getComponentAttributes(this.$attrs, this.componentData);
+    return h(this.getTag(), attributes, children);
+  },
+
+  created() {
+    if (this.list !== null && this.value !== null) {
+      console.error(
+        "Value and list props are mutually exclusive! Please set one or another."
+      );
+    }
+
+    if (this.element !== "div") {
+      console.warn(
+        "Element props is deprecated please use tag props instead. See https://github.com/SortableJS/Vue.Draggable/blob/master/documentation/migrate.md#element-props"
+      );
+    }
+
+    if (this.options !== undefined) {
+      console.warn(
+        "Options props is deprecated, add sortable options directly as vue.draggable item, or use v-bind. See https://github.com/SortableJS/Vue.Draggable/blob/master/documentation/migrate.md#options-props"
+      );
+    }
+  },
+
+  mounted() {
+    this.noneFunctionalComponentMode =
+      this.getTag().toLowerCase() !== this.$el.nodeName.toLowerCase() &&
+      !this.getIsFunctional();
+    if (this.noneFunctionalComponentMode && this.transitionMode) {
+      throw new Error(
+        `Transition-group inside component is not supported. Please alter tag value or remove transition-group. Current tag value: ${this.getTag()}`
+      );
+    }
+    const optionsAdded = {};
+    eventsListened.forEach(elt => {
+      optionsAdded["on" + elt] = delegateAndEmit.call(this, elt);
+    });
+
+    eventsToEmit.forEach(elt => {
+      optionsAdded["on" + elt] = emit.bind(this, elt);
+    });
+
+    const attributes = Object.keys(this.$attrs).reduce((res, key) => {
+      res[camelize(key)] = this.$attrs[key];
+      return res;
+    }, {});
+
+    const options = Object.assign({}, this.options, attributes, optionsAdded, {
+      onMove: (evt, originalEvent) => {
+        return this.onDragMove(evt, originalEvent);
+      }
+    });
+    !("draggable" in options) && (options.draggable = ">*");
+    this._sortable = new Sortable(this.rootContainer, options);
+    this.computeIndexes();
+  },
+
+  beforeDestroy() {
+    if (this._sortable !== undefined) this._sortable.destroy();
+  },
+
+  computed: {
+    rootContainer() {
+      return this.transitionMode ? this.$el.children[0] : this.$el;
+    },
+
+    realList() {
+      return this.list ? this.list : this.value;
+    }
+  },
+
+  watch: {
+    options: {
+      handler(newOptionValue) {
+        this.updateOptions(newOptionValue);
+      },
+      deep: true
+    },
+
+    $attrs: {
+      handler(newOptionValue) {
+        this.updateOptions(newOptionValue);
+      },
+      deep: true
+    },
+
+    realList() {
+      this.computeIndexes();
+    }
+  },
+
+  methods: {
+    getIsFunctional() {
+      const { fnOptions } = this._vnode;
+      return fnOptions && fnOptions.functional;
+    },
+
+    getTag() {
+      return this.tag || this.element;
+    },
+
+    updateOptions(newOptionValue) {
+      for (var property in newOptionValue) {
+        const value = camelize(property);
+        if (readonlyProperties.indexOf(value) === -1) {
+          this._sortable.option(value, newOptionValue[property]);
+        }
+      }
+    },
+
+    getChildrenNodes() {
+      if (this.noneFunctionalComponentMode) {
+        return this.$children[0].$slots.default;
+      }
+      const rawNodes = this.$slots.default;
+      return this.transitionMode ? rawNodes[0].child.$slots.default : rawNodes;
+    },
+
+    computeIndexes() {
+      this.$nextTick(() => {
+        this.visibleIndexes = computeIndexes(
+          this.getChildrenNodes(),
+          this.rootContainer.children,
+          this.transitionMode,
+          this.footerOffset
+        );
+      });
+    },
+
+    getUnderlyingVm(htmlElt) {
+      const index = computeVmIndex(this.getChildrenNodes() || [], htmlElt);
+      if (index === -1) {
+        //Edge case during move callback: related element might be
+        //an element different from collection
+        return null;
+      }
+      const element = this.realList[index];
+      return { index, element };
+    },
+
+    getUnderlyingPotencialDraggableComponent({ __vue__: vue }) {
+      if (
+        !vue ||
+        !vue.$options ||
+        !isTransitionName(vue.$options._componentTag)
+      ) {
+        if (
+          !("realList" in vue) &&
+          vue.$children.length === 1 &&
+          "realList" in vue.$children[0]
+        )
+          return vue.$children[0];
+
+        return vue;
+      }
+      return vue.$parent;
+    },
+
+    emitChanges(evt) {
+      this.$nextTick(() => {
+        this.$emit("change", evt);
+      });
+    },
+
+    alterList(onList) {
+      if (this.list) {
+        onList(this.list);
+        return;
+      }
+      const newList = [...this.value];
+      onList(newList);
+      this.$emit("input", newList);
+    },
+
+    spliceList() {
+      const spliceList = list => list.splice(...arguments);
+      this.alterList(spliceList);
+    },
+
+    updatePosition(oldIndex, newIndex) {
+      const updatePosition = list =>
+        list.splice(newIndex, 0, list.splice(oldIndex, 1)[0]);
+      this.alterList(updatePosition);
+    },
+
+    getRelatedContextFromMoveEvent({ to, related }) {
+      const component = this.getUnderlyingPotencialDraggableComponent(to);
+      if (!component) {
+        return { component };
+      }
+      const list = component.realList;
+      const context = { list, component };
+      if (to !== related && list && component.getUnderlyingVm) {
+        const destination = component.getUnderlyingVm(related);
+        if (destination) {
+          return Object.assign(destination, context);
+        }
+      }
+      return context;
+    },
+
+    getVmIndex(domIndex) {
+      const indexes = this.visibleIndexes;
+      const numberIndexes = indexes.length;
+      return domIndex > numberIndexes - 1 ? numberIndexes : indexes[domIndex];
+    },
+
+    getComponent() {
+      return this.$slots.default[0].componentInstance;
+    },
+
+    resetTransitionData(index) {
+      if (!this.noTransitionOnDrag || !this.transitionMode) {
+        return;
+      }
+      var nodes = this.getChildrenNodes();
+      nodes[index].data = null;
+      const transitionContainer = this.getComponent();
+      transitionContainer.children = [];
+      transitionContainer.kept = undefined;
+    },
+
+    onDragStart(evt) {
+      this.context = this.getUnderlyingVm(evt.item);
+      evt.item._underlying_vm_ = this.clone(this.context.element);
+      draggingElement = evt.item;
+    },
+
+    onDragAdd(evt) {
+      const element = evt.item._underlying_vm_;
+      if (element === undefined) {
+        return;
+      }
+      removeNode(evt.item);
+      const newIndex = this.getVmIndex(evt.newIndex);
+      this.spliceList(newIndex, 0, element);
+      this.computeIndexes();
+      const added = { element, newIndex };
+      this.emitChanges({ added });
+    },
+
+    onDragRemove(evt) {
+      insertNodeAt(this.rootContainer, evt.item, evt.oldIndex);
+      if (evt.pullMode === "clone") {
+        removeNode(evt.clone);
+        return;
+      }
+      const oldIndex = this.context.index;
+      this.spliceList(oldIndex, 1);
+      const removed = { element: this.context.element, oldIndex };
+      this.resetTransitionData(oldIndex);
+      this.emitChanges({ removed });
+    },
+
+    onDragUpdate(evt) {
+      removeNode(evt.item);
+      insertNodeAt(evt.from, evt.item, evt.oldIndex);
+      const oldIndex = this.context.index;
+      const newIndex = this.getVmIndex(evt.newIndex);
+      this.updatePosition(oldIndex, newIndex);
+      const moved = { element: this.context.element, oldIndex, newIndex };
+      this.emitChanges({ moved });
+    },
+
+    updateProperty(evt, propertyName) {
+      evt.hasOwnProperty(propertyName) &&
+        (evt[propertyName] += this.headerOffset);
+    },
+
+    computeFutureIndex(relatedContext, evt) {
+      if (!relatedContext.element) {
+        return 0;
+      }
+      const domChildren = [...evt.to.children].filter(
+        el => el.style["display"] !== "none"
+      );
+      const currentDOMIndex = domChildren.indexOf(evt.related);
+      const currentIndex = relatedContext.component.getVmIndex(currentDOMIndex);
+      const draggedInList = domChildren.indexOf(draggingElement) !== -1;
+      return draggedInList || !evt.willInsertAfter
+        ? currentIndex
+        : currentIndex + 1;
+    },
+
+    onDragMove(evt, originalEvent) {
+      const onMove = this.move;
+      if (!onMove || !this.realList) {
+        return true;
+      }
+
+      const relatedContext = this.getRelatedContextFromMoveEvent(evt);
+      const draggedContext = this.context;
+      const futureIndex = this.computeFutureIndex(relatedContext, evt);
+      Object.assign(draggedContext, { futureIndex });
+      const sendEvt = Object.assign({}, evt, {
+        relatedContext,
+        draggedContext
+      });
+      return onMove(sendEvt, originalEvent);
+    },
+
+    onDragEnd() {
+      this.computeIndexes();
+      draggingElement = null;
+    }
+  }
+};
+
+if (typeof window !== "undefined" && "Vue" in window) {
+  window.Vue.component("draggable", draggableComponent);
+}
+
+export default draggableComponent;

node_modules/vuetify/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2020 John Jeremy Leider
+
+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/vuetify/es5/components/VAlert/VAlert.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VAlert/VAlert.sass");
+
+var _VSheet = _interopRequireDefault(require("../VSheet"));
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _toggleable = _interopRequireDefault(require("../../mixins/toggleable"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _transitionable = _interopRequireDefault(require("../../mixins/transitionable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _console = require("../../util/console");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_VSheet.default, _toggleable.default, _transitionable.default).extend({
+  name: 'v-alert',
+  props: {
+    border: {
+      type: String,
+      validator: function validator(val) {
+        return ['top', 'right', 'bottom', 'left'].includes(val);
+      }
+    },
+    closeLabel: {
+      type: String,
+      default: '$vuetify.close'
+    },
+    coloredBorder: Boolean,
+    dense: Boolean,
+    dismissible: Boolean,
+    icon: {
+      default: '',
+      type: [Boolean, String],
+      validator: function validator(val) {
+        return typeof val === 'string' || val === false;
+      }
+    },
+    outlined: Boolean,
+    prominent: Boolean,
+    text: Boolean,
+    type: {
+      type: String,
+      validator: function validator(val) {
+        return ['info', 'error', 'success', 'warning'].includes(val);
+      }
+    },
+    value: {
+      type: Boolean,
+      default: true
+    }
+  },
+  computed: {
+    __cachedBorder: function __cachedBorder() {
+      if (!this.border) return null;
+      var data = {
+        staticClass: 'v-alert__border',
+        class: _defineProperty({}, "v-alert__border--".concat(this.border), true)
+      };
+
+      if (this.coloredBorder) {
+        data = this.setBackgroundColor(this.computedColor, data);
+        data.class['v-alert__border--has-color'] = true;
+      }
+
+      return this.$createElement('div', data);
+    },
+    __cachedDismissible: function __cachedDismissible() {
+      var _this = this;
+
+      if (!this.dismissible) return null;
+      var color = this.iconColor;
+      return this.$createElement(_VBtn.default, {
+        staticClass: 'v-alert__dismissible',
+        props: {
+          color: color,
+          icon: true,
+          small: true
+        },
+        attrs: {
+          'aria-label': this.$vuetify.lang.t(this.closeLabel)
+        },
+        on: {
+          click: function click() {
+            return _this.isActive = false;
+          }
+        }
+      }, [this.$createElement(_VIcon.default, {
+        props: {
+          color: color
+        }
+      }, '$cancel')]);
+    },
+    __cachedIcon: function __cachedIcon() {
+      if (!this.computedIcon) return null;
+      return this.$createElement(_VIcon.default, {
+        staticClass: 'v-alert__icon',
+        props: {
+          color: this.iconColor
+        }
+      }, this.computedIcon);
+    },
+    classes: function classes() {
+      var classes = _objectSpread({}, _VSheet.default.options.computed.classes.call(this), {
+        'v-alert--border': Boolean(this.border),
+        'v-alert--dense': this.dense,
+        'v-alert--outlined': this.outlined,
+        'v-alert--prominent': this.prominent,
+        'v-alert--text': this.text
+      });
+
+      if (this.border) {
+        classes["v-alert--border-".concat(this.border)] = true;
+      }
+
+      return classes;
+    },
+    computedColor: function computedColor() {
+      return this.color || this.type;
+    },
+    computedIcon: function computedIcon() {
+      if (this.icon === false) return false;
+      if (typeof this.icon === 'string' && this.icon) return this.icon;
+      if (!['error', 'info', 'success', 'warning'].includes(this.type)) return false;
+      return "$".concat(this.type);
+    },
+    hasColoredIcon: function hasColoredIcon() {
+      return this.hasText || Boolean(this.border) && this.coloredBorder;
+    },
+    hasText: function hasText() {
+      return this.text || this.outlined;
+    },
+    iconColor: function iconColor() {
+      return this.hasColoredIcon ? this.computedColor : undefined;
+    },
+    isDark: function isDark() {
+      if (this.type && !this.coloredBorder && !this.outlined) return true;
+      return _themeable.default.options.computed.isDark.call(this);
+    }
+  },
+  created: function created() {
+    /* istanbul ignore next */
+    if (this.$attrs.hasOwnProperty('outline')) {
+      (0, _console.breaking)('outline', 'outlined', this);
+    }
+  },
+  methods: {
+    genWrapper: function genWrapper() {
+      var children = [this.$slots.prepend || this.__cachedIcon, this.genContent(), this.__cachedBorder, this.$slots.append, this.$scopedSlots.close ? this.$scopedSlots.close({
+        toggle: this.toggle
+      }) : this.__cachedDismissible];
+      var data = {
+        staticClass: 'v-alert__wrapper'
+      };
+      return this.$createElement('div', data, children);
+    },
+    genContent: function genContent() {
+      return this.$createElement('div', {
+        staticClass: 'v-alert__content'
+      }, this.$slots.default);
+    },
+    genAlert: function genAlert() {
+      var data = {
+        staticClass: 'v-alert',
+        attrs: {
+          role: 'alert'
+        },
+        class: this.classes,
+        style: this.styles,
+        directives: [{
+          name: 'show',
+          value: this.isActive
+        }]
+      };
+
+      if (!this.coloredBorder) {
+        var setColor = this.hasText ? this.setTextColor : this.setBackgroundColor;
+        data = setColor(this.computedColor, data);
+      }
+
+      return this.$createElement('div', data, [this.genWrapper()]);
+    },
+
+    /** @public */
+    toggle: function toggle() {
+      this.isActive = !this.isActive;
+    }
+  },
+  render: function render(h) {
+    var render = this.genAlert();
+    if (!this.transition) return render;
+    return h('transition', {
+      props: {
+        name: this.transition,
+        origin: this.origin,
+        mode: this.mode
+      }
+    }, [render]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VAlert.js.map

node_modules/vuetify/es5/components/VAlert/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VAlert", {
+  enumerable: true,
+  get: function get() {
+    return _VAlert.default;
+  }
+});
+exports.default = void 0;
+
+var _VAlert = _interopRequireDefault(require("./VAlert"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VAlert.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VAlert/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAlert/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,e","sourcesContent":["import VAlert from './VAlert'\n\nexport { VAlert }\nexport default VAlert\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VApp/VApp.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VApp/VApp.sass");
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_themeable.default).extend({
+  name: 'v-app',
+  props: {
+    dark: {
+      type: Boolean,
+      default: undefined
+    },
+    id: {
+      type: String,
+      default: 'app'
+    },
+    light: {
+      type: Boolean,
+      default: undefined
+    }
+  },
+  computed: {
+    isDark: function isDark() {
+      return this.$vuetify.theme.dark;
+    }
+  },
+  beforeCreate: function beforeCreate() {
+    if (!this.$vuetify || this.$vuetify === this.$root) {
+      throw new Error('Vuetify is not properly initialized, see https://vuetifyjs.com/getting-started/quick-start#bootstrapping-the-vuetify-object');
+    }
+  },
+  render: function render(h) {
+    var wrapper = h('div', {
+      staticClass: 'v-application--wrap'
+    }, this.$slots.default);
+    return h('div', {
+      staticClass: 'v-application',
+      class: _objectSpread({
+        'v-application--is-rtl': this.$vuetify.rtl,
+        'v-application--is-ltr': !this.$vuetify.rtl
+      }, this.themeClasses),
+      attrs: {
+        'data-app': true
+      },
+      domProps: {
+        id: this.id
+      }
+    }, [wrapper]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VApp.js.map

node_modules/vuetify/es5/components/VApp/VApp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VApp/VApp.ts"],"names":[],"mappings":";;;;;;;AACA;;AAGA;;AAGA;;;;;;;;;;AAEA;eACe,qBACb,kBADa,EAEb,MAFa,CAEN;AACP,EAAA,IAAI,EAAE,OADC;AAGP,EAAA,KAAK,EAAE;AACL,IAAA,IAAI,EAAE;AACJ,MAAA,IAAI,EAAE,OADF;AAEJ,MAAA,OAAO,EAAE;AAFL,KADD;AAKL,IAAA,EAAE,EAAE;AACF,MAAA,IAAI,EAAE,MADJ;AAEF,MAAA,OAAO,EAAE;AAFP,KALC;AASL,IAAA,KAAK,EAAE;AACL,MAAA,IAAI,EAAE,OADD;AAEL,MAAA,OAAO,EAAE;AAFJ;AATF,GAHA;AAkBP,EAAA,QAAQ,EAAE;AACR,IAAA,MADQ,oBACF;AACJ,aAAO,KAAK,QAAL,CAAc,KAAd,CAAoB,IAA3B;AACD;AAHO,GAlBH;AAwBP,EAAA,YAxBO,0BAwBK;AACV,QAAI,CAAC,KAAK,QAAN,IAAmB,KAAK,QAAL,KAAkB,KAAK,KAA9C,EAA6D;AAC3D,YAAM,IAAI,KAAJ,CAAU,6HAAV,CAAN;AACD;AACF,GA5BM;AA8BP,EAAA,MA9BO,kBA8BC,CA9BD,EA8BE;AACP,QAAM,OAAO,GAAG,CAAC,CAAC,KAAD,EAAQ;AAAE,MAAA,WAAW,EAAE;AAAf,KAAR,EAAgD,KAAK,MAAL,CAAY,OAA5D,CAAjB;AAEA,WAAO,CAAC,CAAC,KAAD,EAAQ;AACd,MAAA,WAAW,EAAE,eADC;AAEd,MAAA,KAAK;AACH,iCAAyB,KAAK,QAAL,CAAc,GADpC;AAEH,iCAAyB,CAAC,KAAK,QAAL,CAAc;AAFrC,SAGA,KAAK,YAHL,CAFS;AAOd,MAAA,KAAK,EAAE;AAAE,oBAAY;AAAd,OAPO;AAQd,MAAA,QAAQ,EAAE;AAAE,QAAA,EAAE,EAAE,KAAK;AAAX;AARI,KAAR,EASL,CAAC,OAAD,CATK,CAAR;AAUD;AA3CM,CAFM,C","sourcesContent":["// Styles\nimport './VApp.sass'\n\n// Mixins\nimport Themeable from '../../mixins/themeable'\n\n// Utilities\nimport mixins from '../../util/mixins'\n\n/* @vue/component */\nexport default mixins(\n  Themeable\n).extend({\n  name: 'v-app',\n\n  props: {\n    dark: {\n      type: Boolean,\n      default: undefined,\n    },\n    id: {\n      type: String,\n      default: 'app',\n    },\n    light: {\n      type: Boolean,\n      default: undefined,\n    },\n  },\n\n  computed: {\n    isDark (): boolean {\n      return this.$vuetify.theme.dark\n    },\n  },\n\n  beforeCreate () {\n    if (!this.$vuetify || (this.$vuetify === this.$root as any)) {\n      throw new Error('Vuetify is not properly initialized, see https://vuetifyjs.com/getting-started/quick-start#bootstrapping-the-vuetify-object')\n    }\n  },\n\n  render (h) {\n    const wrapper = h('div', { staticClass: 'v-application--wrap' }, this.$slots.default)\n\n    return h('div', {\n      staticClass: 'v-application',\n      class: {\n        'v-application--is-rtl': this.$vuetify.rtl,\n        'v-application--is-ltr': !this.$vuetify.rtl,\n        ...this.themeClasses,\n      },\n      attrs: { 'data-app': true },\n      domProps: { id: this.id },\n    }, [wrapper])\n  },\n})\n"],"sourceRoot":"","file":"VApp.js"}

node_modules/vuetify/es5/components/VApp/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VApp", {
+  enumerable: true,
+  get: function get() {
+    return _VApp.default;
+  }
+});
+exports.default = void 0;
+
+var _VApp = _interopRequireDefault(require("./VApp"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VApp.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VApp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VApp/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,a","sourcesContent":["import VApp from './VApp'\n\nexport { VApp }\nexport default VApp\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VAppBar/VAppBar.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VAppBar/VAppBar.sass");
+
+var _VToolbar = _interopRequireDefault(require("../VToolbar/VToolbar"));
+
+var _scroll = _interopRequireDefault(require("../../directives/scroll"));
+
+var _applicationable = _interopRequireDefault(require("../../mixins/applicationable"));
+
+var _scrollable = _interopRequireDefault(require("../../mixins/scrollable"));
+
+var _ssrBootable = _interopRequireDefault(require("../../mixins/ssr-bootable"));
+
+var _toggleable = _interopRequireDefault(require("../../mixins/toggleable"));
+
+var _helpers = require("../../util/helpers");
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var baseMixins = (0, _mixins.default)(_VToolbar.default, _scrollable.default, _ssrBootable.default, _toggleable.default, (0, _applicationable.default)('top', ['clippedLeft', 'clippedRight', 'computedHeight', 'invertedScroll', 'isExtended', 'isProminent', 'value']));
+/* @vue/component */
+
+var _default = baseMixins.extend({
+  name: 'v-app-bar',
+  directives: {
+    Scroll: _scroll.default
+  },
+  props: {
+    clippedLeft: Boolean,
+    clippedRight: Boolean,
+    collapseOnScroll: Boolean,
+    elevateOnScroll: Boolean,
+    fadeImgOnScroll: Boolean,
+    hideOnScroll: Boolean,
+    invertedScroll: Boolean,
+    scrollOffScreen: Boolean,
+    shrinkOnScroll: Boolean,
+    value: {
+      type: Boolean,
+      default: true
+    }
+  },
+  data: function data() {
+    return {
+      isActive: this.value
+    };
+  },
+  computed: {
+    applicationProperty: function applicationProperty() {
+      return !this.bottom ? 'top' : 'bottom';
+    },
+    canScroll: function canScroll() {
+      return _scrollable.default.options.computed.canScroll.call(this) && (this.invertedScroll || this.elevateOnScroll || this.hideOnScroll || this.collapseOnScroll || this.isBooted || // If falsey, user has provided an
+      // explicit value which should
+      // overwrite anything we do
+      !this.value);
+    },
+    classes: function classes() {
+      return _objectSpread({}, _VToolbar.default.options.computed.classes.call(this), {
+        'v-toolbar--collapse': this.collapse || this.collapseOnScroll,
+        'v-app-bar': true,
+        'v-app-bar--clipped': this.clippedLeft || this.clippedRight,
+        'v-app-bar--fade-img-on-scroll': this.fadeImgOnScroll,
+        'v-app-bar--elevate-on-scroll': this.elevateOnScroll,
+        'v-app-bar--fixed': !this.absolute && (this.app || this.fixed),
+        'v-app-bar--hide-shadow': this.hideShadow,
+        'v-app-bar--is-scrolled': this.currentScroll > 0,
+        'v-app-bar--shrink-on-scroll': this.shrinkOnScroll
+      });
+    },
+    computedContentHeight: function computedContentHeight() {
+      if (!this.shrinkOnScroll) return _VToolbar.default.options.computed.computedContentHeight.call(this);
+      var height = this.computedOriginalHeight;
+      var min = this.dense ? 48 : 56;
+      var max = height;
+      var difference = max - min;
+      var iteration = difference / this.computedScrollThreshold;
+      var offset = this.currentScroll * iteration;
+      return Math.max(min, max - offset);
+    },
+    computedFontSize: function computedFontSize() {
+      if (!this.isProminent) return undefined;
+      var max = this.dense ? 96 : 128;
+      var difference = max - this.computedContentHeight;
+      var increment = 0.00347; // 1.5rem to a minimum of 1.25rem
+
+      return Number((1.50 - difference * increment).toFixed(2));
+    },
+    computedLeft: function computedLeft() {
+      if (!this.app || this.clippedLeft) return 0;
+      return this.$vuetify.application.left;
+    },
+    computedMarginTop: function computedMarginTop() {
+      if (!this.app) return 0;
+      return this.$vuetify.application.bar;
+    },
+    computedOpacity: function computedOpacity() {
+      if (!this.fadeImgOnScroll) return undefined;
+      var opacity = Math.max((this.computedScrollThreshold - this.currentScroll) / this.computedScrollThreshold, 0);
+      return Number(parseFloat(opacity).toFixed(2));
+    },
+    computedOriginalHeight: function computedOriginalHeight() {
+      var height = _VToolbar.default.options.computed.computedContentHeight.call(this);
+
+      if (this.isExtended) height += parseInt(this.extensionHeight);
+      return height;
+    },
+    computedRight: function computedRight() {
+      if (!this.app || this.clippedRight) return 0;
+      return this.$vuetify.application.right;
+    },
+    computedScrollThreshold: function computedScrollThreshold() {
+      if (this.scrollThreshold) return Number(this.scrollThreshold);
+      return this.computedOriginalHeight - (this.dense ? 48 : 56);
+    },
+    computedTransform: function computedTransform() {
+      if (!this.canScroll || this.elevateOnScroll && this.currentScroll === 0 && this.isActive) return 0;
+      if (this.isActive) return 0;
+      var scrollOffScreen = this.scrollOffScreen ? this.computedHeight : this.computedContentHeight;
+      return this.bottom ? scrollOffScreen : -scrollOffScreen;
+    },
+    hideShadow: function hideShadow() {
+      if (this.elevateOnScroll && this.isExtended) {
+        return this.currentScroll < this.computedScrollThreshold;
+      }
+
+      if (this.elevateOnScroll) {
+        return this.currentScroll === 0 || this.computedTransform < 0;
+      }
+
+      return (!this.isExtended || this.scrollOffScreen) && this.computedTransform !== 0;
+    },
+    isCollapsed: function isCollapsed() {
+      if (!this.collapseOnScroll) {
+        return _VToolbar.default.options.computed.isCollapsed.call(this);
+      }
+
+      return this.currentScroll > 0;
+    },
+    isProminent: function isProminent() {
+      return _VToolbar.default.options.computed.isProminent.call(this) || this.shrinkOnScroll;
+    },
+    styles: function styles() {
+      return _objectSpread({}, _VToolbar.default.options.computed.styles.call(this), {
+        fontSize: (0, _helpers.convertToUnit)(this.computedFontSize, 'rem'),
+        marginTop: (0, _helpers.convertToUnit)(this.computedMarginTop),
+        transform: "translateY(".concat((0, _helpers.convertToUnit)(this.computedTransform), ")"),
+        left: (0, _helpers.convertToUnit)(this.computedLeft),
+        right: (0, _helpers.convertToUnit)(this.computedRight)
+      });
+    }
+  },
+  watch: {
+    canScroll: 'onScroll',
+    computedTransform: function computedTransform() {
+      // Normally we do not want the v-app-bar
+      // to update the application top value
+      // to avoid screen jump. However, in
+      // this situation, we must so that
+      // the clipped drawer can update
+      // its top value when scrolled
+      if (!this.canScroll || !this.clippedLeft && !this.clippedRight) return;
+      this.callUpdate();
+    },
+    invertedScroll: function invertedScroll(val) {
+      this.isActive = !val || this.currentScroll !== 0;
+    }
+  },
+  created: function created() {
+    if (this.invertedScroll) this.isActive = false;
+  },
+  methods: {
+    genBackground: function genBackground() {
+      var render = _VToolbar.default.options.methods.genBackground.call(this);
+
+      render.data = this._b(render.data || {}, render.tag, {
+        style: {
+          opacity: this.computedOpacity
+        }
+      });
+      return render;
+    },
+    updateApplication: function updateApplication() {
+      return this.invertedScroll ? 0 : this.computedHeight + this.computedTransform;
+    },
+    thresholdMet: function thresholdMet() {
+      if (this.invertedScroll) {
+        this.isActive = this.currentScroll > this.computedScrollThreshold;
+        return;
+      }
+
+      if (this.hideOnScroll) {
+        this.isActive = this.isScrollingUp || this.currentScroll < this.computedScrollThreshold;
+      }
+
+      if (this.currentThreshold < this.computedScrollThreshold) return;
+      this.savedScroll = this.currentScroll;
+    }
+  },
+  render: function render(h) {
+    var render = _VToolbar.default.options.render.call(this, h);
+
+    render.data = render.data || {};
+
+    if (this.canScroll) {
+      render.data.directives = render.data.directives || [];
+      render.data.directives.push({
+        arg: this.scrollTarget,
+        name: 'scroll',
+        value: this.onScroll
+      });
+    }
+
+    return render;
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VAppBar.js.map

node_modules/vuetify/es5/components/VAppBar/VAppBarNavIcon.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _VBtn = _interopRequireDefault(require("../VBtn/VBtn"));
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _vue.default.extend({
+  name: 'v-app-bar-nav-icon',
+  functional: true,
+  render: function render(h, _ref) {
+    var slots = _ref.slots,
+        listeners = _ref.listeners,
+        props = _ref.props,
+        data = _ref.data;
+    var d = Object.assign(data, {
+      staticClass: "v-app-bar__nav-icon ".concat(data.staticClass || '').trim(),
+      props: _objectSpread({}, props, {
+        icon: true
+      }),
+      on: listeners
+    });
+    var defaultSlot = slots().default;
+    return h(_VBtn.default, d, defaultSlot || [h(_VIcon.default, '$menu')]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VAppBarNavIcon.js.map

node_modules/vuetify/es5/components/VAppBar/VAppBarNavIcon.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAppBar/VAppBarNavIcon.ts"],"names":[],"mappings":";;;;;;;AACA;;AACA;;AAGA;;;;;;;;;;AAEA;eACe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,oBADkB;AAGxB,EAAA,UAAU,EAAE,IAHY;AAKxB,EAAA,MALwB,kBAKhB,CALgB,QAKoB;AAAA,QAA/B,KAA+B,QAA/B,KAA+B;AAAA,QAAxB,SAAwB,QAAxB,SAAwB;AAAA,QAAb,KAAa,QAAb,KAAa;AAAA,QAAN,IAAM,QAAN,IAAM;AAC1C,QAAM,CAAC,GAAG,MAAM,CAAC,MAAP,CAAc,IAAd,EAAoB;AAC5B,MAAA,WAAW,EAAE,8BAAwB,IAAI,CAAC,WAAL,IAAoB,EAA5C,EAAkD,IAAlD,EADe;AAE5B,MAAA,KAAK,oBACA,KADA;AAEH,QAAA,IAAI,EAAE;AAFH,QAFuB;AAM5B,MAAA,EAAE,EAAE;AANwB,KAApB,CAAV;AASA,QAAM,WAAW,GAAG,KAAK,GAAG,OAA5B;AAEA,WAAO,CAAC,CAAC,aAAD,EAAO,CAAP,EAAU,WAAW,IAAI,CAAC,CAAC,CAAC,cAAD,EAAQ,OAAR,CAAF,CAAzB,CAAR;AACD;AAlBuB,CAAX,C","sourcesContent":["// Components\nimport VIcon from '../VIcon'\nimport VBtn from '../VBtn/VBtn'\n\n// Types\nimport Vue from 'vue'\n\n/* @vue/component */\nexport default Vue.extend({\n  name: 'v-app-bar-nav-icon',\n\n  functional: true,\n\n  render (h, { slots, listeners, props, data }) {\n    const d = Object.assign(data, {\n      staticClass: (`v-app-bar__nav-icon ${data.staticClass || ''}`).trim(),\n      props: {\n        ...props,\n        icon: true,\n      },\n      on: listeners,\n    })\n\n    const defaultSlot = slots().default\n\n    return h(VBtn, d, defaultSlot || [h(VIcon, '$menu')])\n  },\n})\n"],"sourceRoot":"","file":"VAppBarNavIcon.js"}

node_modules/vuetify/es5/components/VAppBar/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VAppBar", {
+  enumerable: true,
+  get: function get() {
+    return _VAppBar.default;
+  }
+});
+Object.defineProperty(exports, "VAppBarNavIcon", {
+  enumerable: true,
+  get: function get() {
+    return _VAppBarNavIcon.default;
+  }
+});
+exports.default = void 0;
+
+var _VAppBar = _interopRequireDefault(require("./VAppBar"));
+
+var _VAppBarNavIcon = _interopRequireDefault(require("./VAppBarNavIcon"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  $_vuetify_subcomponents: {
+    VAppBar: _VAppBar.default,
+    VAppBarNavIcon: _VAppBarNavIcon.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VAppBar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAppBar/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;eAIe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,OAAO,EAAP,gBADuB;AAEvB,IAAA,cAAc,EAAd;AAFuB;AADZ,C","sourcesContent":["import VAppBar from './VAppBar'\nimport VAppBarNavIcon from './VAppBarNavIcon'\n\nexport { VAppBar, VAppBarNavIcon }\n\nexport default {\n  $_vuetify_subcomponents: {\n    VAppBar,\n    VAppBarNavIcon,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VAutocomplete/VAutocomplete.js

@@ -0,0 +1,373 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VAutocomplete/VAutocomplete.sass");
+
+var _VSelect = _interopRequireWildcard(require("../VSelect/VSelect"));
+
+var _VTextField = _interopRequireDefault(require("../VTextField/VTextField"));
+
+var _mergeData = _interopRequireDefault(require("../../util/mergeData"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var defaultMenuProps = _objectSpread({}, _VSelect.defaultMenuProps, {
+  offsetY: true,
+  offsetOverflow: true,
+  transition: false
+});
+/* @vue/component */
+
+
+var _default2 = _VSelect.default.extend({
+  name: 'v-autocomplete',
+  props: {
+    allowOverflow: {
+      type: Boolean,
+      default: true
+    },
+    autoSelectFirst: {
+      type: Boolean,
+      default: false
+    },
+    filter: {
+      type: Function,
+      default: function _default(item, queryText, itemText) {
+        return itemText.toLocaleLowerCase().indexOf(queryText.toLocaleLowerCase()) > -1;
+      }
+    },
+    hideNoData: Boolean,
+    menuProps: {
+      type: _VSelect.default.options.props.menuProps.type,
+      default: function _default() {
+        return defaultMenuProps;
+      }
+    },
+    noFilter: Boolean,
+    searchInput: {
+      type: String,
+      default: undefined
+    }
+  },
+  data: function data() {
+    return {
+      lazySearch: this.searchInput
+    };
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({}, _VSelect.default.options.computed.classes.call(this), {
+        'v-autocomplete': true,
+        'v-autocomplete--is-selecting-index': this.selectedIndex > -1
+      });
+    },
+    computedItems: function computedItems() {
+      return this.filteredItems;
+    },
+    selectedValues: function selectedValues() {
+      var _this = this;
+
+      return this.selectedItems.map(function (item) {
+        return _this.getValue(item);
+      });
+    },
+    hasDisplayedItems: function hasDisplayedItems() {
+      var _this2 = this;
+
+      return this.hideSelected ? this.filteredItems.some(function (item) {
+        return !_this2.hasItem(item);
+      }) : this.filteredItems.length > 0;
+    },
+    currentRange: function currentRange() {
+      if (this.selectedItem == null) return 0;
+      return String(this.getText(this.selectedItem)).length;
+    },
+    filteredItems: function filteredItems() {
+      var _this3 = this;
+
+      if (!this.isSearching || this.noFilter || this.internalSearch == null) return this.allItems;
+      return this.allItems.filter(function (item) {
+        var text = _this3.getText(item); // Remove items without text to match
+
+
+        if (text == null || _typeof(text) === 'object') return false;
+        return _this3.filter(item, String(_this3.internalSearch), String(text));
+      });
+    },
+    internalSearch: {
+      get: function get() {
+        return this.lazySearch;
+      },
+      set: function set(val) {
+        this.lazySearch = val;
+        this.$emit('update:search-input', val);
+      }
+    },
+    isAnyValueAllowed: function isAnyValueAllowed() {
+      return false;
+    },
+    isDirty: function isDirty() {
+      return this.searchIsDirty || this.selectedItems.length > 0;
+    },
+    isSearching: function isSearching() {
+      return this.multiple && this.searchIsDirty || this.searchIsDirty && this.internalSearch !== this.getText(this.selectedItem);
+    },
+    menuCanShow: function menuCanShow() {
+      if (!this.isFocused) return false;
+      return this.hasDisplayedItems || !this.hideNoData;
+    },
+    $_menuProps: function $_menuProps() {
+      var props = _VSelect.default.options.computed.$_menuProps.call(this);
+
+      props.contentClass = "v-autocomplete__content ".concat(props.contentClass || '').trim();
+      return _objectSpread({}, defaultMenuProps, {}, props);
+    },
+    searchIsDirty: function searchIsDirty() {
+      return this.internalSearch != null && this.internalSearch !== '';
+    },
+    selectedItem: function selectedItem() {
+      var _this4 = this;
+
+      if (this.multiple) return null;
+      return this.selectedItems.find(function (i) {
+        return _this4.valueComparator(_this4.getValue(i), _this4.getValue(_this4.internalValue));
+      });
+    },
+    listData: function listData() {
+      var data = _VSelect.default.options.computed.listData.call(this);
+
+      data.props = _objectSpread({}, data.props, {
+        items: this.virtualizedItems,
+        noFilter: this.noFilter || !this.isSearching || !this.filteredItems.length,
+        searchInput: this.internalSearch
+      });
+      return data;
+    }
+  },
+  watch: {
+    filteredItems: 'onFilteredItemsChanged',
+    internalValue: 'setSearch',
+    isFocused: function isFocused(val) {
+      if (val) {
+        document.addEventListener('copy', this.onCopy);
+        this.$refs.input && this.$refs.input.select();
+      } else {
+        document.removeEventListener('copy', this.onCopy);
+        this.updateSelf();
+      }
+    },
+    isMenuActive: function isMenuActive(val) {
+      if (val || !this.hasSlot) return;
+      this.lazySearch = undefined;
+    },
+    items: function items(val, oldVal) {
+      // If we are focused, the menu
+      // is not active, hide no data is enabled,
+      // and items change
+      // User is probably async loading
+      // items, try to activate the menu
+      if (!(oldVal && oldVal.length) && this.hideNoData && this.isFocused && !this.isMenuActive && val.length) this.activateMenu();
+    },
+    searchInput: function searchInput(val) {
+      this.lazySearch = val;
+    },
+    internalSearch: 'onInternalSearchChanged',
+    itemText: 'updateSelf'
+  },
+  created: function created() {
+    this.setSearch();
+  },
+  methods: {
+    onFilteredItemsChanged: function onFilteredItemsChanged(val, oldVal) {
+      var _this5 = this;
+
+      // TODO: How is the watcher triggered
+      // for duplicate items? no idea
+      if (val === oldVal) return;
+      this.setMenuIndex(-1);
+      this.$nextTick(function () {
+        if (!_this5.internalSearch || val.length !== 1 && !_this5.autoSelectFirst) return;
+
+        _this5.$refs.menu.getTiles();
+
+        _this5.setMenuIndex(0);
+      });
+    },
+    onInternalSearchChanged: function onInternalSearchChanged() {
+      this.updateMenuDimensions();
+    },
+    updateMenuDimensions: function updateMenuDimensions() {
+      // Type from menuable is not making it through
+      this.isMenuActive && this.$refs.menu && this.$refs.menu.updateDimensions();
+    },
+    changeSelectedIndex: function changeSelectedIndex(keyCode) {
+      // Do not allow changing of selectedIndex
+      // when search is dirty
+      if (this.searchIsDirty) return;
+
+      if (this.multiple && keyCode === _helpers.keyCodes.left) {
+        if (this.selectedIndex === -1) {
+          this.selectedIndex = this.selectedItems.length - 1;
+        } else {
+          this.selectedIndex--;
+        }
+      } else if (this.multiple && keyCode === _helpers.keyCodes.right) {
+        if (this.selectedIndex >= this.selectedItems.length - 1) {
+          this.selectedIndex = -1;
+        } else {
+          this.selectedIndex++;
+        }
+      } else if (keyCode === _helpers.keyCodes.backspace || keyCode === _helpers.keyCodes.delete) {
+        this.deleteCurrentItem();
+      }
+    },
+    deleteCurrentItem: function deleteCurrentItem() {
+      if (this.readonly) return;
+      var index = this.selectedItems.length - 1;
+
+      if (this.selectedIndex === -1 && index !== 0) {
+        this.selectedIndex = index;
+        return;
+      }
+
+      var currentItem = this.selectedItems[this.selectedIndex];
+      if (this.getDisabled(currentItem)) return;
+      var newIndex = this.selectedIndex === index ? this.selectedIndex - 1 : this.selectedItems[this.selectedIndex + 1] ? this.selectedIndex : -1;
+
+      if (newIndex === -1) {
+        this.setValue(this.multiple ? [] : undefined);
+      } else {
+        this.selectItem(currentItem);
+      }
+
+      this.selectedIndex = newIndex;
+    },
+    clearableCallback: function clearableCallback() {
+      this.internalSearch = undefined;
+
+      _VSelect.default.options.methods.clearableCallback.call(this);
+    },
+    genInput: function genInput() {
+      var input = _VTextField.default.options.methods.genInput.call(this);
+
+      input.data = (0, _mergeData.default)(input.data, {
+        attrs: {
+          'aria-activedescendant': (0, _helpers.getObjectValueByPath)(this.$refs.menu, 'activeTile.id'),
+          autocomplete: (0, _helpers.getObjectValueByPath)(input.data, 'attrs.autocomplete', 'off')
+        },
+        domProps: {
+          value: this.internalSearch
+        }
+      });
+      return input;
+    },
+    genInputSlot: function genInputSlot() {
+      var slot = _VSelect.default.options.methods.genInputSlot.call(this);
+
+      slot.data.attrs.role = 'combobox';
+      return slot;
+    },
+    genSelections: function genSelections() {
+      return this.hasSlot || this.multiple ? _VSelect.default.options.methods.genSelections.call(this) : [];
+    },
+    onClick: function onClick(e) {
+      if (this.isDisabled) return;
+      this.selectedIndex > -1 ? this.selectedIndex = -1 : this.onFocus();
+      if (!this.isAppendInner(e.target)) this.activateMenu();
+    },
+    onInput: function onInput(e) {
+      if (this.selectedIndex > -1 || !e.target) return;
+      var target = e.target;
+      var value = target.value; // If typing and menu is not currently active
+
+      if (target.value) this.activateMenu();
+      this.internalSearch = value;
+      this.badInput = target.validity && target.validity.badInput;
+    },
+    onKeyDown: function onKeyDown(e) {
+      var keyCode = e.keyCode;
+
+      _VSelect.default.options.methods.onKeyDown.call(this, e); // The ordering is important here
+      // allows new value to be updated
+      // and then moves the index to the
+      // proper location
+
+
+      this.changeSelectedIndex(keyCode);
+    },
+    onSpaceDown: function onSpaceDown(e) {},
+    onTabDown: function onTabDown(e) {
+      _VSelect.default.options.methods.onTabDown.call(this, e);
+
+      this.updateSelf();
+    },
+    onUpDown: function onUpDown(e) {
+      // Prevent screen from scrolling
+      e.preventDefault(); // For autocomplete / combobox, cycling
+      // interfers with native up/down behavior
+      // instead activate the menu
+
+      this.activateMenu();
+    },
+    selectItem: function selectItem(item) {
+      _VSelect.default.options.methods.selectItem.call(this, item);
+
+      this.setSearch();
+    },
+    setSelectedItems: function setSelectedItems() {
+      _VSelect.default.options.methods.setSelectedItems.call(this); // #4273 Don't replace if searching
+      // #4403 Don't replace if focused
+
+
+      if (!this.isFocused) this.setSearch();
+    },
+    setSearch: function setSearch() {
+      var _this6 = this;
+
+      // Wait for nextTick so selectedItem
+      // has had time to update
+      this.$nextTick(function () {
+        if (!_this6.multiple || !_this6.internalSearch || !_this6.isMenuActive) {
+          _this6.internalSearch = !_this6.selectedItems.length || _this6.multiple || _this6.hasSlot ? null : _this6.getText(_this6.selectedItem);
+        }
+      });
+    },
+    updateSelf: function updateSelf() {
+      if (!this.searchIsDirty && !this.internalValue) return;
+
+      if (!this.valueComparator(this.internalSearch, this.getValue(this.internalValue))) {
+        this.setSearch();
+      }
+    },
+    hasItem: function hasItem(item) {
+      return this.selectedValues.indexOf(this.getValue(item)) > -1;
+    },
+    onCopy: function onCopy(event) {
+      if (this.selectedIndex === -1) return;
+      var currentItem = this.selectedItems[this.selectedIndex];
+      var currentItemText = this.getText(currentItem);
+      event.clipboardData.setData('text/plain', currentItemText);
+      event.clipboardData.setData('text/vnd.vuetify.autocomplete.item+plain', currentItemText);
+      event.preventDefault();
+    }
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VAutocomplete.js.map

node_modules/vuetify/es5/components/VAutocomplete/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VAutocomplete", {
+  enumerable: true,
+  get: function get() {
+    return _VAutocomplete.default;
+  }
+});
+exports.default = void 0;
+
+var _VAutocomplete = _interopRequireDefault(require("./VAutocomplete"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VAutocomplete.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VAutocomplete/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAutocomplete/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,sB","sourcesContent":["import VAutocomplete from './VAutocomplete'\n\nexport { VAutocomplete }\nexport default VAutocomplete\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VAvatar/VAvatar.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VAvatar/VAvatar.sass");
+
+var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
+
+var _measurable = _interopRequireDefault(require("../../mixins/measurable"));
+
+var _helpers = require("../../util/helpers");
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = (0, _mixins.default)(_colorable.default, _measurable.default
+/* @vue/component */
+).extend({
+  name: 'v-avatar',
+  props: {
+    left: Boolean,
+    right: Boolean,
+    size: {
+      type: [Number, String],
+      default: 48
+    },
+    tile: Boolean
+  },
+  computed: {
+    classes: function classes() {
+      return {
+        'v-avatar--left': this.left,
+        'v-avatar--right': this.right,
+        'v-avatar--tile': this.tile
+      };
+    },
+    styles: function styles() {
+      return _objectSpread({
+        height: (0, _helpers.convertToUnit)(this.size),
+        minWidth: (0, _helpers.convertToUnit)(this.size),
+        width: (0, _helpers.convertToUnit)(this.size)
+      }, this.measurableStyles);
+    }
+  },
+  render: function render(h) {
+    var data = {
+      staticClass: 'v-avatar',
+      class: this.classes,
+      style: this.styles,
+      on: this.$listeners
+    };
+    return h('div', this.setBackgroundColor(this.color, data), this.$slots.default);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VAvatar.js.map

node_modules/vuetify/es5/components/VAvatar/VAvatar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAvatar/VAvatar.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAGA;;AACA;;AACA;;AAIA;;;;;;;;;;eAEe,qBACb,kBADa,EAEb;AACA;AAHa,EAIb,MAJa,CAIN;AACP,EAAA,IAAI,EAAE,UADC;AAGP,EAAA,KAAK,EAAE;AACL,IAAA,IAAI,EAAE,OADD;AAEL,IAAA,KAAK,EAAE,OAFF;AAGL,IAAA,IAAI,EAAE;AACJ,MAAA,IAAI,EAAE,CAAC,MAAD,EAAS,MAAT,CADF;AAEJ,MAAA,OAAO,EAAE;AAFL,KAHD;AAOL,IAAA,IAAI,EAAE;AAPD,GAHA;AAaP,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL,aAAO;AACL,0BAAkB,KAAK,IADlB;AAEL,2BAAmB,KAAK,KAFnB;AAGL,0BAAkB,KAAK;AAHlB,OAAP;AAKD,KAPO;AAQR,IAAA,MARQ,oBAQF;AACJ;AACE,QAAA,MAAM,EAAE,4BAAc,KAAK,IAAnB,CADV;AAEE,QAAA,QAAQ,EAAE,4BAAc,KAAK,IAAnB,CAFZ;AAGE,QAAA,KAAK,EAAE,4BAAc,KAAK,IAAnB;AAHT,SAIK,KAAK,gBAJV;AAMD;AAfO,GAbH;AA+BP,EAAA,MA/BO,kBA+BC,CA/BD,EA+BE;AACP,QAAM,IAAI,GAAG;AACX,MAAA,WAAW,EAAE,UADF;AAEX,MAAA,KAAK,EAAE,KAAK,OAFD;AAGX,MAAA,KAAK,EAAE,KAAK,MAHD;AAIX,MAAA,EAAE,EAAE,KAAK;AAJE,KAAb;AAOA,WAAO,CAAC,CAAC,KAAD,EAAQ,KAAK,kBAAL,CAAwB,KAAK,KAA7B,EAAoC,IAApC,CAAR,EAAmD,KAAK,MAAL,CAAY,OAA/D,CAAR;AACD;AAxCM,CAJM,C","sourcesContent":["import './VAvatar.sass'\n\n// Mixins\nimport Colorable from '../../mixins/colorable'\nimport Measurable from '../../mixins/measurable'\nimport { convertToUnit } from '../../util/helpers'\n\n// Types\nimport { VNode } from 'vue'\nimport mixins from '../../util/mixins'\n\nexport default mixins(\n  Colorable,\n  Measurable\n  /* @vue/component */\n).extend({\n  name: 'v-avatar',\n\n  props: {\n    left: Boolean,\n    right: Boolean,\n    size: {\n      type: [Number, String],\n      default: 48,\n    },\n    tile: Boolean,\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        'v-avatar--left': this.left,\n        'v-avatar--right': this.right,\n        'v-avatar--tile': this.tile,\n      }\n    },\n    styles (): object {\n      return {\n        height: convertToUnit(this.size),\n        minWidth: convertToUnit(this.size),\n        width: convertToUnit(this.size),\n        ...this.measurableStyles,\n      }\n    },\n  },\n\n  render (h): VNode {\n    const data = {\n      staticClass: 'v-avatar',\n      class: this.classes,\n      style: this.styles,\n      on: this.$listeners,\n    }\n\n    return h('div', this.setBackgroundColor(this.color, data), this.$slots.default)\n  },\n})\n"],"sourceRoot":"","file":"VAvatar.js"}

node_modules/vuetify/es5/components/VAvatar/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VAvatar", {
+  enumerable: true,
+  get: function get() {
+    return _VAvatar.default;
+  }
+});
+exports.default = void 0;
+
+var _VAvatar = _interopRequireDefault(require("./VAvatar"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VAvatar.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VAvatar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VAvatar/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,gB","sourcesContent":["import VAvatar from './VAvatar'\n\nexport { VAvatar }\nexport default VAvatar\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBadge/VBadge.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBadge/VBadge.sass");
+
+var _VIcon = _interopRequireDefault(require("../VIcon/VIcon"));
+
+var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _toggleable = _interopRequireDefault(require("../../mixins/toggleable"));
+
+var _transitionable = _interopRequireDefault(require("../../mixins/transitionable"));
+
+var _positionable = require("../../mixins/positionable");
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = (0, _mixins.default)(_colorable.default, (0, _positionable.factory)(['left', 'bottom']), _themeable.default, _toggleable.default, _transitionable.default).extend({
+  name: 'v-badge',
+  props: {
+    avatar: Boolean,
+    bordered: Boolean,
+    color: {
+      type: String,
+      default: 'primary'
+    },
+    content: {
+      required: false
+    },
+    dot: Boolean,
+    label: {
+      type: String,
+      default: '$vuetify.badge'
+    },
+    icon: String,
+    inline: Boolean,
+    offsetX: [Number, String],
+    offsetY: [Number, String],
+    overlap: Boolean,
+    tile: Boolean,
+    transition: {
+      type: String,
+      default: 'scale-rotate-transition'
+    },
+    value: {
+      default: true
+    }
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-badge--avatar': this.avatar,
+        'v-badge--bordered': this.bordered,
+        'v-badge--bottom': this.bottom,
+        'v-badge--dot': this.dot,
+        'v-badge--icon': this.icon != null,
+        'v-badge--inline': this.inline,
+        'v-badge--left': this.left,
+        'v-badge--overlap': this.overlap,
+        'v-badge--tile': this.tile
+      }, this.themeClasses);
+    },
+    computedBottom: function computedBottom() {
+      return this.bottom ? 'auto' : this.computedYOffset;
+    },
+    computedLeft: function computedLeft() {
+      if (this.isRtl) {
+        return this.left ? this.computedXOffset : 'auto';
+      }
+
+      return this.left ? 'auto' : this.computedXOffset;
+    },
+    computedRight: function computedRight() {
+      if (this.isRtl) {
+        return this.left ? 'auto' : this.computedXOffset;
+      }
+
+      return !this.left ? 'auto' : this.computedXOffset;
+    },
+    computedTop: function computedTop() {
+      return this.bottom ? this.computedYOffset : 'auto';
+    },
+    computedXOffset: function computedXOffset() {
+      return this.calcPosition(this.offsetX);
+    },
+    computedYOffset: function computedYOffset() {
+      return this.calcPosition(this.offsetY);
+    },
+    isRtl: function isRtl() {
+      return this.$vuetify.rtl;
+    },
+    // Default fallback if offsetX
+    // or offsetY are undefined.
+    offset: function offset() {
+      if (this.overlap) return this.dot ? 8 : 12;
+      return this.dot ? 2 : 4;
+    },
+    styles: function styles() {
+      if (this.inline) return {};
+      return {
+        bottom: this.computedBottom,
+        left: this.computedLeft,
+        right: this.computedRight,
+        top: this.computedTop
+      };
+    }
+  },
+  methods: {
+    calcPosition: function calcPosition(offset) {
+      return "calc(100% - ".concat((0, _helpers.convertToUnit)(offset || this.offset), ")");
+    },
+    genBadge: function genBadge() {
+      var lang = this.$vuetify.lang;
+      var label = this.$attrs['aria-label'] || lang.t(this.label);
+      var data = this.setBackgroundColor(this.color, {
+        staticClass: 'v-badge__badge',
+        style: this.styles,
+        attrs: {
+          'aria-atomic': this.$attrs['aria-atomic'] || 'true',
+          'aria-label': label,
+          'aria-live': this.$attrs['aria-live'] || 'polite',
+          title: this.$attrs.title,
+          role: this.$attrs.role || 'status'
+        },
+        directives: [{
+          name: 'show',
+          value: this.isActive
+        }]
+      });
+      var badge = this.$createElement('span', data, [this.genBadgeContent()]);
+      if (!this.transition) return badge;
+      return this.$createElement('transition', {
+        props: {
+          name: this.transition,
+          origin: this.origin,
+          mode: this.mode
+        }
+      }, [badge]);
+    },
+    genBadgeContent: function genBadgeContent() {
+      // Dot prop shows no content
+      if (this.dot) return undefined;
+      var slot = (0, _helpers.getSlot)(this, 'badge');
+      if (slot) return slot;
+      if (this.content) return String(this.content);
+      if (this.icon) return this.$createElement(_VIcon.default, this.icon);
+      return undefined;
+    },
+    genBadgeWrapper: function genBadgeWrapper() {
+      return this.$createElement('span', {
+        staticClass: 'v-badge__wrapper'
+      }, [this.genBadge()]);
+    }
+  },
+  render: function render(h) {
+    var badge = [this.genBadgeWrapper()];
+    var children = [(0, _helpers.getSlot)(this)];
+
+    var _this$$attrs = this.$attrs,
+        _x = _this$$attrs['aria-atomic'],
+        _y = _this$$attrs['aria-label'],
+        _z = _this$$attrs['aria-live'],
+        role = _this$$attrs.role,
+        title = _this$$attrs.title,
+        attrs = _objectWithoutProperties(_this$$attrs, ["aria-atomic", "aria-label", "aria-live", "role", "title"]);
+
+    if (this.inline && this.left) children.unshift(badge);else children.push(badge);
+    return h('span', {
+      staticClass: 'v-badge',
+      attrs: attrs,
+      class: this.classes
+    }, children);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBadge.js.map

node_modules/vuetify/es5/components/VBadge/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBadge", {
+  enumerable: true,
+  get: function get() {
+    return _VBadge.default;
+  }
+});
+exports.default = void 0;
+
+var _VBadge = _interopRequireDefault(require("./VBadge"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBadge.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBadge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBadge/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,e","sourcesContent":["import VBadge from './VBadge'\n\nexport { VBadge }\nexport default VBadge\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBanner/VBanner.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBanner/VBanner.sass");
+
+var _VSheet = _interopRequireDefault(require("../VSheet"));
+
+var _VAvatar = _interopRequireDefault(require("../VAvatar"));
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _transitions = require("../transitions");
+
+var _toggleable = _interopRequireDefault(require("../../mixins/toggleable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_VSheet.default, _toggleable.default).extend({
+  name: 'v-banner',
+  inheritAttrs: false,
+  props: {
+    app: Boolean,
+    icon: String,
+    iconColor: String,
+    mobileBreakPoint: {
+      type: [Number, String],
+      default: 960
+    },
+    singleLine: Boolean,
+    sticky: Boolean,
+    tile: {
+      type: Boolean,
+      default: true
+    },
+    value: {
+      type: Boolean,
+      default: true
+    }
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({}, _VSheet.default.options.computed.classes.call(this), {
+        'v-banner--has-icon': this.hasIcon,
+        'v-banner--is-mobile': this.isMobile,
+        'v-banner--single-line': this.singleLine,
+        'v-banner--sticky': this.isSticky
+      });
+    },
+    hasIcon: function hasIcon() {
+      return Boolean(this.icon || this.$slots.icon);
+    },
+    isMobile: function isMobile() {
+      return this.$vuetify.breakpoint.width < Number(this.mobileBreakPoint);
+    },
+    isSticky: function isSticky() {
+      return this.sticky || this.app;
+    },
+    styles: function styles() {
+      var styles = _objectSpread({}, _VSheet.default.options.computed.styles.call(this));
+
+      if (this.isSticky) {
+        var top = !this.app ? 0 : this.$vuetify.application.bar + this.$vuetify.application.top;
+        styles.top = (0, _helpers.convertToUnit)(top);
+        styles.position = 'sticky';
+        styles.zIndex = 1;
+      }
+
+      return styles;
+    }
+  },
+  methods: {
+    /** @public */
+    toggle: function toggle() {
+      this.isActive = !this.isActive;
+    },
+    iconClick: function iconClick(e) {
+      this.$emit('click:icon', e);
+    },
+    genIcon: function genIcon() {
+      if (!this.hasIcon) return undefined;
+      var content;
+
+      if (this.icon) {
+        content = this.$createElement(_VIcon.default, {
+          props: {
+            color: this.iconColor,
+            size: 28
+          }
+        }, [this.icon]);
+      } else {
+        content = this.$slots.icon;
+      }
+
+      return this.$createElement(_VAvatar.default, {
+        staticClass: 'v-banner__icon',
+        props: {
+          color: this.color,
+          size: 40
+        },
+        on: {
+          click: this.iconClick
+        }
+      }, [content]);
+    },
+    genText: function genText() {
+      return this.$createElement('div', {
+        staticClass: 'v-banner__text'
+      }, this.$slots.default);
+    },
+    genActions: function genActions() {
+      var _this = this;
+
+      var children = (0, _helpers.getSlot)(this, 'actions', {
+        dismiss: function dismiss() {
+          return _this.isActive = false;
+        }
+      });
+      if (!children) return undefined;
+      return this.$createElement('div', {
+        staticClass: 'v-banner__actions'
+      }, children);
+    },
+    genContent: function genContent() {
+      return this.$createElement('div', {
+        staticClass: 'v-banner__content'
+      }, [this.genIcon(), this.genText()]);
+    },
+    genWrapper: function genWrapper() {
+      return this.$createElement('div', {
+        staticClass: 'v-banner__wrapper'
+      }, [this.genContent(), this.genActions()]);
+    }
+  },
+  render: function render(h) {
+    return h(_transitions.VExpandTransition, [h('div', this.setBackgroundColor(this.color, {
+      staticClass: 'v-banner',
+      attrs: this.attrs$,
+      class: this.classes,
+      style: this.styles,
+      directives: [{
+        name: 'show',
+        value: this.isActive
+      }]
+    }), [this.genWrapper()])]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBanner.js.map

node_modules/vuetify/es5/components/VBanner/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBanner", {
+  enumerable: true,
+  get: function get() {
+    return _VBanner.default;
+  }
+});
+exports.default = void 0;
+
+var _VBanner = _interopRequireDefault(require("./VBanner"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBanner.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBanner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBanner/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,gB","sourcesContent":["import VBanner from './VBanner'\n\nexport { VBanner }\nexport default VBanner\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBottomNavigation/VBottomNavigation.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBottomNavigation/VBottomNavigation.sass");
+
+var _applicationable = _interopRequireDefault(require("../../mixins/applicationable"));
+
+var _buttonGroup = _interopRequireDefault(require("../../mixins/button-group"));
+
+var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
+
+var _measurable = _interopRequireDefault(require("../../mixins/measurable"));
+
+var _proxyable = _interopRequireDefault(require("../../mixins/proxyable"));
+
+var _scrollable = _interopRequireDefault(require("../../mixins/scrollable"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _toggleable = require("../../mixins/toggleable");
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _console = require("../../util/console");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = (0, _mixins.default)((0, _applicationable.default)('bottom', ['height', 'inputValue']), _colorable.default, _measurable.default, (0, _toggleable.factory)('inputValue'), _proxyable.default, _scrollable.default, _themeable.default
+/* @vue/component */
+).extend({
+  name: 'v-bottom-navigation',
+  props: {
+    activeClass: {
+      type: String,
+      default: 'v-btn--active'
+    },
+    backgroundColor: String,
+    grow: Boolean,
+    height: {
+      type: [Number, String],
+      default: 56
+    },
+    hideOnScroll: Boolean,
+    horizontal: Boolean,
+    inputValue: {
+      type: Boolean,
+      default: true
+    },
+    mandatory: Boolean,
+    shift: Boolean
+  },
+  data: function data() {
+    return {
+      isActive: this.inputValue
+    };
+  },
+  computed: {
+    canScroll: function canScroll() {
+      return _scrollable.default.options.computed.canScroll.call(this) && (this.hideOnScroll || !this.inputValue);
+    },
+    classes: function classes() {
+      return {
+        'v-bottom-navigation--absolute': this.absolute,
+        'v-bottom-navigation--grow': this.grow,
+        'v-bottom-navigation--fixed': !this.absolute && (this.app || this.fixed),
+        'v-bottom-navigation--horizontal': this.horizontal,
+        'v-bottom-navigation--shift': this.shift
+      };
+    },
+    styles: function styles() {
+      return _objectSpread({}, this.measurableStyles, {
+        transform: this.isActive ? 'none' : 'translateY(100%)'
+      });
+    }
+  },
+  created: function created() {
+    /* istanbul ignore next */
+    if (this.$attrs.hasOwnProperty('active')) {
+      (0, _console.breaking)('active.sync', 'value or v-model', this);
+    }
+  },
+  methods: {
+    thresholdMet: function thresholdMet() {
+      this.isActive = !this.isScrollingUp;
+      this.$emit('update:input-value', this.isActive);
+    },
+    updateApplication: function updateApplication() {
+      return this.$el ? this.$el.clientHeight : 0;
+    },
+    updateValue: function updateValue(val) {
+      this.$emit('change', val);
+    }
+  },
+  render: function render(h) {
+    var data = this.setBackgroundColor(this.backgroundColor, {
+      staticClass: 'v-bottom-navigation',
+      class: this.classes,
+      style: this.styles,
+      props: {
+        activeClass: this.activeClass,
+        mandatory: Boolean(this.mandatory || this.value !== undefined),
+        value: this.internalValue
+      },
+      on: {
+        change: this.updateValue
+      }
+    });
+
+    if (this.canScroll) {
+      data.directives = data.directives || [];
+      data.directives.push({
+        arg: this.scrollTarget,
+        name: 'scroll',
+        value: this.onScroll
+      });
+    }
+
+    return h(_buttonGroup.default, this.setTextColor(this.color, data), this.$slots.default);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBottomNavigation.js.map

node_modules/vuetify/es5/components/VBottomNavigation/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBottomNavigation", {
+  enumerable: true,
+  get: function get() {
+    return _VBottomNavigation.default;
+  }
+});
+exports.default = void 0;
+
+var _VBottomNavigation = _interopRequireDefault(require("./VBottomNavigation"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBottomNavigation.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBottomNavigation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBottomNavigation/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,0B","sourcesContent":["import VBottomNavigation from './VBottomNavigation'\n\nexport { VBottomNavigation }\nexport default VBottomNavigation\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBottomSheet/VBottomSheet.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBottomSheet/VBottomSheet.sass");
+
+var _VDialog = _interopRequireDefault(require("../VDialog/VDialog"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _VDialog.default.extend({
+  name: 'v-bottom-sheet',
+  props: {
+    inset: Boolean,
+    maxWidth: {
+      type: [String, Number],
+      default: 'auto'
+    },
+    transition: {
+      type: String,
+      default: 'bottom-sheet-transition'
+    }
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({}, _VDialog.default.options.computed.classes.call(this), {
+        'v-bottom-sheet': true,
+        'v-bottom-sheet--inset': this.inset
+      });
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBottomSheet.js.map

node_modules/vuetify/es5/components/VBottomSheet/VBottomSheet.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBottomSheet/VBottomSheet.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAGA;;;;;;;;;;AAEA;eACe,iBAAQ,MAAR,CAAe;AAC5B,EAAA,IAAI,EAAE,gBADsB;AAG5B,EAAA,KAAK,EAAE;AACL,IAAA,KAAK,EAAE,OADF;AAEL,IAAA,QAAQ,EAAE;AACR,MAAA,IAAI,EAAE,CAAC,MAAD,EAAS,MAAT,CADE;AAER,MAAA,OAAO,EAAE;AAFD,KAFL;AAML,IAAA,UAAU,EAAE;AACV,MAAA,IAAI,EAAE,MADI;AAEV,MAAA,OAAO,EAAE;AAFC;AANP,GAHqB;AAe5B,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL,+BACK,iBAAQ,OAAR,CAAgB,QAAhB,CAAyB,OAAzB,CAAiC,IAAjC,CAAsC,IAAtC,CADL;AAEE,0BAAkB,IAFpB;AAGE,iCAAyB,KAAK;AAHhC;AAKD;AAPO;AAfkB,CAAf,C","sourcesContent":["import './VBottomSheet.sass'\n\n// Extensions\nimport VDialog from '../VDialog/VDialog'\n\n/* @vue/component */\nexport default VDialog.extend({\n  name: 'v-bottom-sheet',\n\n  props: {\n    inset: Boolean,\n    maxWidth: {\n      type: [String, Number],\n      default: 'auto',\n    },\n    transition: {\n      type: String,\n      default: 'bottom-sheet-transition',\n    },\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        ...VDialog.options.computed.classes.call(this),\n        'v-bottom-sheet': true,\n        'v-bottom-sheet--inset': this.inset,\n      }\n    },\n  },\n})\n"],"sourceRoot":"","file":"VBottomSheet.js"}

node_modules/vuetify/es5/components/VBottomSheet/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBottomSheet", {
+  enumerable: true,
+  get: function get() {
+    return _VBottomSheet.default;
+  }
+});
+exports.default = void 0;
+
+var _VBottomSheet = _interopRequireDefault(require("./VBottomSheet"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBottomSheet.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBottomSheet/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBottomSheet/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,qB","sourcesContent":["import VBottomSheet from './VBottomSheet'\n\nexport { VBottomSheet }\nexport default VBottomSheet\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbs.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBreadcrumbs/VBreadcrumbs.sass");
+
+var _VBreadcrumbsItem = _interopRequireDefault(require("./VBreadcrumbsItem"));
+
+var _VBreadcrumbsDivider = _interopRequireDefault(require("./VBreadcrumbsDivider"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default2 = (0, _mixins.default)(_themeable.default
+/* @vue/component */
+).extend({
+  name: 'v-breadcrumbs',
+  props: {
+    divider: {
+      type: String,
+      default: '/'
+    },
+    items: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    large: Boolean
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-breadcrumbs--large': this.large
+      }, this.themeClasses);
+    }
+  },
+  methods: {
+    genDivider: function genDivider() {
+      return this.$createElement(_VBreadcrumbsDivider.default, this.$slots.divider ? this.$slots.divider : this.divider);
+    },
+    genItems: function genItems() {
+      var items = [];
+      var hasSlot = !!this.$scopedSlots.item;
+      var keys = [];
+
+      for (var i = 0; i < this.items.length; i++) {
+        var item = this.items[i];
+        keys.push(item.text);
+        if (hasSlot) items.push(this.$scopedSlots.item({
+          item: item
+        }));else items.push(this.$createElement(_VBreadcrumbsItem.default, {
+          key: keys.join('.'),
+          props: item
+        }, [item.text]));
+        if (i < this.items.length - 1) items.push(this.genDivider());
+      }
+
+      return items;
+    }
+  },
+  render: function render(h) {
+    var children = this.$slots.default || this.genItems();
+    return h('ul', {
+      staticClass: 'v-breadcrumbs',
+      class: this.classes
+    }, children);
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VBreadcrumbs.js.map

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBreadcrumbs/VBreadcrumbs.ts"],"names":[],"mappings":";;;;;;;AACA;;AAMA;;AACA;;AAGA;;AAGA;;;;;;;;;;gBAEe,qBACb;AACA;AAFa,EAGb,MAHa,CAGN;AACP,EAAA,IAAI,EAAE,eADC;AAGP,EAAA,KAAK,EAAE;AACL,IAAA,OAAO,EAAE;AACP,MAAA,IAAI,EAAE,MADC;AAEP,MAAA,OAAO,EAAE;AAFF,KADJ;AAKL,IAAA,KAAK,EAAE;AACL,MAAA,IAAI,EAAE,KADD;AAEL,MAAA,OAAO,EAAE;AAAA,eAAO,EAAP;AAAA;AAFJ,KALF;AASL,IAAA,KAAK,EAAE;AATF,GAHA;AAeP,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL;AACE,gCAAwB,KAAK;AAD/B,SAEK,KAAK,YAFV;AAID;AANO,GAfH;AAwBP,EAAA,OAAO,EAAE;AACP,IAAA,UADO,wBACG;AACR,aAAO,KAAK,cAAL,CAAoB,4BAApB,EAAyC,KAAK,MAAL,CAAY,OAAZ,GAAsB,KAAK,MAAL,CAAY,OAAlC,GAA4C,KAAK,OAA1F,CAAP;AACD,KAHM;AAIP,IAAA,QAJO,sBAIC;AACN,UAAM,KAAK,GAAG,EAAd;AACA,UAAM,OAAO,GAAG,CAAC,CAAC,KAAK,YAAL,CAAkB,IAApC;AACA,UAAM,IAAI,GAAG,EAAb;;AAEA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,KAAL,CAAW,MAA/B,EAAuC,CAAC,EAAxC,EAA4C;AAC1C,YAAM,IAAI,GAAG,KAAK,KAAL,CAAW,CAAX,CAAb;AAEA,QAAA,IAAI,CAAC,IAAL,CAAU,IAAI,CAAC,IAAf;AAEA,YAAI,OAAJ,EAAa,KAAK,CAAC,IAAN,CAAW,KAAK,YAAL,CAAkB,IAAlB,CAAwB;AAAE,UAAA,IAAI,EAAJ;AAAF,SAAxB,CAAX,EAAb,KACK,KAAK,CAAC,IAAN,CAAW,KAAK,cAAL,CAAoB,yBAApB,EAAsC;AAAE,UAAA,GAAG,EAAE,IAAI,CAAC,IAAL,CAAU,GAAV,CAAP;AAAuB,UAAA,KAAK,EAAE;AAA9B,SAAtC,EAA4E,CAAC,IAAI,CAAC,IAAN,CAA5E,CAAX;AAEL,YAAI,CAAC,GAAG,KAAK,KAAL,CAAW,MAAX,GAAoB,CAA5B,EAA+B,KAAK,CAAC,IAAN,CAAW,KAAK,UAAL,EAAX;AAChC;;AAED,aAAO,KAAP;AACD;AArBM,GAxBF;AAgDP,EAAA,MAhDO,kBAgDC,CAhDD,EAgDE;AACP,QAAM,QAAQ,GAAG,KAAK,MAAL,CAAY,OAAZ,IAAuB,KAAK,QAAL,EAAxC;AAEA,WAAO,CAAC,CAAC,IAAD,EAAO;AACb,MAAA,WAAW,EAAE,eADA;AAEb,MAAA,KAAK,EAAE,KAAK;AAFC,KAAP,EAGL,QAHK,CAAR;AAID;AAvDM,CAHM,C","sourcesContent":["// Styles\nimport './VBreadcrumbs.sass'\n\n// Types\nimport { VNode, PropType } from 'vue'\n\n// Components\nimport VBreadcrumbsItem from './VBreadcrumbsItem'\nimport VBreadcrumbsDivider from './VBreadcrumbsDivider'\n\n// Mixins\nimport Themeable from '../../mixins/themeable'\n\n// Utils\nimport mixins from '../../util/mixins'\n\nexport default mixins(\n  Themeable\n  /* @vue/component */\n).extend({\n  name: 'v-breadcrumbs',\n\n  props: {\n    divider: {\n      type: String,\n      default: '/',\n    },\n    items: {\n      type: Array as PropType<any[]>,\n      default: () => ([]),\n    },\n    large: Boolean,\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        'v-breadcrumbs--large': this.large,\n        ...this.themeClasses,\n      }\n    },\n  },\n\n  methods: {\n    genDivider () {\n      return this.$createElement(VBreadcrumbsDivider, this.$slots.divider ? this.$slots.divider : this.divider)\n    },\n    genItems () {\n      const items = []\n      const hasSlot = !!this.$scopedSlots.item\n      const keys = []\n\n      for (let i = 0; i < this.items.length; i++) {\n        const item = this.items[i]\n\n        keys.push(item.text)\n\n        if (hasSlot) items.push(this.$scopedSlots.item!({ item }))\n        else items.push(this.$createElement(VBreadcrumbsItem, { key: keys.join('.'), props: item }, [item.text]))\n\n        if (i < this.items.length - 1) items.push(this.genDivider())\n      }\n\n      return items\n    },\n  },\n\n  render (h): VNode {\n    const children = this.$slots.default || this.genItems()\n\n    return h('ul', {\n      staticClass: 'v-breadcrumbs',\n      class: this.classes,\n    }, children)\n  },\n})\n"],"sourceRoot":"","file":"VBreadcrumbs.js"}

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbsDivider.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _helpers = require("../../util/helpers");
+
+var _default = (0, _helpers.createSimpleFunctional)('v-breadcrumbs__divider', 'li');
+
+exports.default = _default;
+//# sourceMappingURL=VBreadcrumbsDivider.js.map

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbsDivider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBreadcrumbs/VBreadcrumbsDivider.ts"],"names":[],"mappings":";;;;;;;AAAA;;eAEe,qCAAuB,wBAAvB,EAAiD,IAAjD,C","sourcesContent":["import { createSimpleFunctional } from '../../util/helpers'\n\nexport default createSimpleFunctional('v-breadcrumbs__divider', 'li')\n"],"sourceRoot":"","file":"VBreadcrumbsDivider.js"}

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbsItem.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _routable = _interopRequireDefault(require("../../mixins/routable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_routable.default).extend({
+  name: 'v-breadcrumbs-item',
+  props: {
+    // In a breadcrumb, the currently
+    // active item should be dimmed
+    activeClass: {
+      type: String,
+      default: 'v-breadcrumbs__item--disabled'
+    },
+    ripple: {
+      type: [Boolean, Object],
+      default: false
+    }
+  },
+  computed: {
+    classes: function classes() {
+      return _defineProperty({
+        'v-breadcrumbs__item': true
+      }, this.activeClass, this.disabled);
+    }
+  },
+  render: function render(h) {
+    var _this$generateRouteLi = this.generateRouteLink(),
+        tag = _this$generateRouteLi.tag,
+        data = _this$generateRouteLi.data;
+
+    return h('li', [h(tag, _objectSpread({}, data, {
+      attrs: _objectSpread({}, data.attrs, {
+        'aria-current': this.isActive && this.isLink ? 'page' : undefined
+      })
+    }), this.$slots.default)]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBreadcrumbsItem.js.map

node_modules/vuetify/es5/components/VBreadcrumbs/VBreadcrumbsItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBreadcrumbs/VBreadcrumbsItem.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAEA;;;;;;;;;;AAGA;eACe,qBAAO,iBAAP,EAAiB,MAAjB,CAAwB;AACrC,EAAA,IAAI,EAAE,oBAD+B;AAGrC,EAAA,KAAK,EAAE;AACL;AACA;AACA,IAAA,WAAW,EAAE;AACX,MAAA,IAAI,EAAE,MADK;AAEX,MAAA,OAAO,EAAE;AAFE,KAHR;AAOL,IAAA,MAAM,EAAE;AACN,MAAA,IAAI,EAAE,CAAC,OAAD,EAAU,MAAV,CADA;AAEN,MAAA,OAAO,EAAE;AAFH;AAPH,GAH8B;AAgBrC,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL;AACE,+BAAuB;AADzB,SAEG,KAAK,WAFR,EAEsB,KAAK,QAF3B;AAID;AANO,GAhB2B;AAyBrC,EAAA,MAzBqC,kBAyB7B,CAzB6B,EAyB5B;AAAA,gCACe,KAAK,iBAAL,EADf;AAAA,QACC,GADD,yBACC,GADD;AAAA,QACM,IADN,yBACM,IADN;;AAGP,WAAO,CAAC,CAAC,IAAD,EAAO,CACb,CAAC,CAAC,GAAD,oBACI,IADJ;AAEC,MAAA,KAAK,oBACA,IAAI,CAAC,KADL;AAEH,wBAAgB,KAAK,QAAL,IAAiB,KAAK,MAAtB,GAA+B,MAA/B,GAAwC;AAFrD;AAFN,QAME,KAAK,MAAL,CAAY,OANd,CADY,CAAP,CAAR;AASD;AArCoC,CAAxB,C","sourcesContent":["import Routable from '../../mixins/routable'\n\nimport mixins from '../../util/mixins'\nimport { VNode } from 'vue'\n\n/* @vue/component */\nexport default mixins(Routable).extend({\n  name: 'v-breadcrumbs-item',\n\n  props: {\n    // In a breadcrumb, the currently\n    // active item should be dimmed\n    activeClass: {\n      type: String,\n      default: 'v-breadcrumbs__item--disabled',\n    },\n    ripple: {\n      type: [Boolean, Object],\n      default: false,\n    },\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        'v-breadcrumbs__item': true,\n        [this.activeClass]: this.disabled,\n      }\n    },\n  },\n\n  render (h): VNode {\n    const { tag, data } = this.generateRouteLink()\n\n    return h('li', [\n      h(tag, {\n        ...data,\n        attrs: {\n          ...data.attrs,\n          'aria-current': this.isActive && this.isLink ? 'page' : undefined,\n        },\n      }, this.$slots.default),\n    ])\n  },\n})\n"],"sourceRoot":"","file":"VBreadcrumbsItem.js"}

node_modules/vuetify/es5/components/VBreadcrumbs/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBreadcrumbs", {
+  enumerable: true,
+  get: function get() {
+    return _VBreadcrumbs.default;
+  }
+});
+Object.defineProperty(exports, "VBreadcrumbsItem", {
+  enumerable: true,
+  get: function get() {
+    return _VBreadcrumbsItem.default;
+  }
+});
+Object.defineProperty(exports, "VBreadcrumbsDivider", {
+  enumerable: true,
+  get: function get() {
+    return _VBreadcrumbsDivider.default;
+  }
+});
+exports.default = void 0;
+
+var _VBreadcrumbs = _interopRequireDefault(require("./VBreadcrumbs"));
+
+var _VBreadcrumbsItem = _interopRequireDefault(require("./VBreadcrumbsItem"));
+
+var _VBreadcrumbsDivider = _interopRequireDefault(require("./VBreadcrumbsDivider"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  $_vuetify_subcomponents: {
+    VBreadcrumbs: _VBreadcrumbs.default,
+    VBreadcrumbsItem: _VBreadcrumbsItem.default,
+    VBreadcrumbsDivider: _VBreadcrumbsDivider.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBreadcrumbs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBreadcrumbs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;;;eAIe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,YAAY,EAAZ,qBADuB;AAEvB,IAAA,gBAAgB,EAAhB,yBAFuB;AAGvB,IAAA,mBAAmB,EAAnB;AAHuB;AADZ,C","sourcesContent":["import VBreadcrumbs from './VBreadcrumbs'\nimport VBreadcrumbsItem from './VBreadcrumbsItem'\nimport VBreadcrumbsDivider from './VBreadcrumbsDivider'\n\nexport { VBreadcrumbs, VBreadcrumbsItem, VBreadcrumbsDivider }\n\nexport default {\n  $_vuetify_subcomponents: {\n    VBreadcrumbs,\n    VBreadcrumbsItem,\n    VBreadcrumbsDivider,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBtn/VBtn.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBtn/VBtn.sass");
+
+var _VSheet = _interopRequireDefault(require("../VSheet"));
+
+var _VProgressCircular = _interopRequireDefault(require("../VProgressCircular"));
+
+var _groupable = require("../../mixins/groupable");
+
+var _toggleable = require("../../mixins/toggleable");
+
+var _positionable = _interopRequireDefault(require("../../mixins/positionable"));
+
+var _routable = _interopRequireDefault(require("../../mixins/routable"));
+
+var _sizeable = _interopRequireDefault(require("../../mixins/sizeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _console = require("../../util/console");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var baseMixins = (0, _mixins.default)(_VSheet.default, _routable.default, _positionable.default, _sizeable.default, (0, _groupable.factory)('btnToggle'), (0, _toggleable.factory)('inputValue')
+/* @vue/component */
+);
+
+var _default2 = baseMixins.extend().extend({
+  name: 'v-btn',
+  props: {
+    activeClass: {
+      type: String,
+      default: function _default() {
+        if (!this.btnToggle) return '';
+        return this.btnToggle.activeClass;
+      }
+    },
+    block: Boolean,
+    depressed: Boolean,
+    fab: Boolean,
+    icon: Boolean,
+    loading: Boolean,
+    outlined: Boolean,
+    retainFocusOnClick: Boolean,
+    rounded: Boolean,
+    tag: {
+      type: String,
+      default: 'button'
+    },
+    text: Boolean,
+    type: {
+      type: String,
+      default: 'button'
+    },
+    value: null
+  },
+  data: function data() {
+    return {
+      proxyClass: 'v-btn--active'
+    };
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-btn': true
+      }, _routable.default.options.computed.classes.call(this), {
+        'v-btn--absolute': this.absolute,
+        'v-btn--block': this.block,
+        'v-btn--bottom': this.bottom,
+        'v-btn--contained': this.contained,
+        'v-btn--depressed': this.depressed || this.outlined,
+        'v-btn--disabled': this.disabled,
+        'v-btn--fab': this.fab,
+        'v-btn--fixed': this.fixed,
+        'v-btn--flat': this.isFlat,
+        'v-btn--icon': this.icon,
+        'v-btn--left': this.left,
+        'v-btn--loading': this.loading,
+        'v-btn--outlined': this.outlined,
+        'v-btn--right': this.right,
+        'v-btn--round': this.isRound,
+        'v-btn--rounded': this.rounded,
+        'v-btn--router': this.to,
+        'v-btn--text': this.text,
+        'v-btn--tile': this.tile,
+        'v-btn--top': this.top
+      }, this.themeClasses, {}, this.groupClasses, {}, this.elevationClasses, {}, this.sizeableClasses);
+    },
+    contained: function contained() {
+      return Boolean(!this.isFlat && !this.depressed && // Contained class only adds elevation
+      // is not needed if user provides value
+      !this.elevation);
+    },
+    computedRipple: function computedRipple() {
+      var defaultRipple = this.icon || this.fab ? {
+        circle: true
+      } : true;
+      if (this.disabled) return false;else return this.ripple != null ? this.ripple : defaultRipple;
+    },
+    isFlat: function isFlat() {
+      return Boolean(this.icon || this.text || this.outlined);
+    },
+    isRound: function isRound() {
+      return Boolean(this.icon || this.fab);
+    },
+    styles: function styles() {
+      return _objectSpread({}, this.measurableStyles);
+    }
+  },
+  created: function created() {
+    var _this = this;
+
+    var breakingProps = [['flat', 'text'], ['outline', 'outlined'], ['round', 'rounded']];
+    /* istanbul ignore next */
+
+    breakingProps.forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          original = _ref2[0],
+          replacement = _ref2[1];
+
+      if (_this.$attrs.hasOwnProperty(original)) (0, _console.breaking)(original, replacement, _this);
+    });
+  },
+  methods: {
+    click: function click(e) {
+      !this.retainFocusOnClick && !this.fab && e.detail && this.$el.blur();
+      this.$emit('click', e);
+      this.btnToggle && this.toggle();
+    },
+    genContent: function genContent() {
+      return this.$createElement('span', {
+        staticClass: 'v-btn__content'
+      }, this.$slots.default);
+    },
+    genLoader: function genLoader() {
+      return this.$createElement('span', {
+        class: 'v-btn__loader'
+      }, this.$slots.loader || [this.$createElement(_VProgressCircular.default, {
+        props: {
+          indeterminate: true,
+          size: 23,
+          width: 2
+        }
+      })]);
+    }
+  },
+  render: function render(h) {
+    var children = [this.genContent(), this.loading && this.genLoader()];
+    var setColor = !this.isFlat ? this.setBackgroundColor : this.setTextColor;
+
+    var _this$generateRouteLi = this.generateRouteLink(),
+        tag = _this$generateRouteLi.tag,
+        data = _this$generateRouteLi.data;
+
+    if (tag === 'button') {
+      data.attrs.type = this.type;
+      data.attrs.disabled = this.disabled;
+    }
+
+    data.attrs.value = ['string', 'number'].includes(_typeof(this.value)) ? this.value : JSON.stringify(this.value);
+    return h(tag, this.disabled ? data : setColor(this.color, data), children);
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VBtn.js.map

node_modules/vuetify/es5/components/VBtn/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBtn", {
+  enumerable: true,
+  get: function get() {
+    return _VBtn.default;
+  }
+});
+exports.default = void 0;
+
+var _VBtn = _interopRequireDefault(require("./VBtn"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBtn.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBtn/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBtn/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,a","sourcesContent":["import VBtn from './VBtn'\n\nexport { VBtn }\nexport default VBtn\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VBtnToggle/VBtnToggle.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VBtnToggle/VBtnToggle.sass");
+
+var _buttonGroup = _interopRequireDefault(require("../../mixins/button-group"));
+
+var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_buttonGroup.default, _colorable.default).extend({
+  name: 'v-btn-toggle',
+  props: {
+    backgroundColor: String,
+    borderless: Boolean,
+    dense: Boolean,
+    group: Boolean,
+    rounded: Boolean,
+    shaped: Boolean,
+    tile: Boolean
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({}, _buttonGroup.default.options.computed.classes.call(this), {
+        'v-btn-toggle': true,
+        'v-btn-toggle--borderless': this.borderless,
+        'v-btn-toggle--dense': this.dense,
+        'v-btn-toggle--group': this.group,
+        'v-btn-toggle--rounded': this.rounded,
+        'v-btn-toggle--shaped': this.shaped,
+        'v-btn-toggle--tile': this.tile
+      }, this.themeClasses);
+    }
+  },
+  methods: {
+    genData: function genData() {
+      var data = this.setTextColor(this.color, _objectSpread({}, _buttonGroup.default.options.methods.genData.call(this)));
+      if (this.group) return data;
+      return this.setBackgroundColor(this.backgroundColor, data);
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VBtnToggle.js.map

node_modules/vuetify/es5/components/VBtnToggle/VBtnToggle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBtnToggle/VBtnToggle.ts"],"names":[],"mappings":";;;;;;;AACA;;AAGA;;AACA;;AAGA;;;;;;;;;;AAEA;eACe,qBACb,oBADa,EAEb,kBAFa,EAGb,MAHa,CAGN;AACP,EAAA,IAAI,EAAE,cADC;AAGP,EAAA,KAAK,EAAE;AACL,IAAA,eAAe,EAAE,MADZ;AAEL,IAAA,UAAU,EAAE,OAFP;AAGL,IAAA,KAAK,EAAE,OAHF;AAIL,IAAA,KAAK,EAAE,OAJF;AAKL,IAAA,OAAO,EAAE,OALJ;AAML,IAAA,MAAM,EAAE,OANH;AAOL,IAAA,IAAI,EAAE;AAPD,GAHA;AAaP,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL,+BACK,qBAAY,OAAZ,CAAoB,QAApB,CAA6B,OAA7B,CAAqC,IAArC,CAA0C,IAA1C,CADL;AAEE,wBAAgB,IAFlB;AAGE,oCAA4B,KAAK,UAHnC;AAIE,+BAAuB,KAAK,KAJ9B;AAKE,+BAAuB,KAAK,KAL9B;AAME,iCAAyB,KAAK,OANhC;AAOE,gCAAwB,KAAK,MAP/B;AAQE,8BAAsB,KAAK;AAR7B,SASK,KAAK,YATV;AAWD;AAbO,GAbH;AA6BP,EAAA,OAAO,EAAE;AACP,IAAA,OADO,qBACA;AACL,UAAM,IAAI,GAAG,KAAK,YAAL,CAAkB,KAAK,KAAvB,oBACR,qBAAY,OAAZ,CAAoB,OAApB,CAA4B,OAA5B,CAAoC,IAApC,CAAyC,IAAzC,CADQ,EAAb;AAIA,UAAI,KAAK,KAAT,EAAgB,OAAO,IAAP;AAEhB,aAAO,KAAK,kBAAL,CAAwB,KAAK,eAA7B,EAA8C,IAA9C,CAAP;AACD;AATM;AA7BF,CAHM,C","sourcesContent":["// Styles\nimport './VBtnToggle.sass'\n\n// Mixins\nimport ButtonGroup from '../../mixins/button-group'\nimport Colorable from '../../mixins/colorable'\n\n// Utilities\nimport mixins from '../../util/mixins'\n\n/* @vue/component */\nexport default mixins(\n  ButtonGroup,\n  Colorable\n).extend({\n  name: 'v-btn-toggle',\n\n  props: {\n    backgroundColor: String,\n    borderless: Boolean,\n    dense: Boolean,\n    group: Boolean,\n    rounded: Boolean,\n    shaped: Boolean,\n    tile: Boolean,\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        ...ButtonGroup.options.computed.classes.call(this),\n        'v-btn-toggle': true,\n        'v-btn-toggle--borderless': this.borderless,\n        'v-btn-toggle--dense': this.dense,\n        'v-btn-toggle--group': this.group,\n        'v-btn-toggle--rounded': this.rounded,\n        'v-btn-toggle--shaped': this.shaped,\n        'v-btn-toggle--tile': this.tile,\n        ...this.themeClasses,\n      }\n    },\n  },\n\n  methods: {\n    genData () {\n      const data = this.setTextColor(this.color, {\n        ...ButtonGroup.options.methods.genData.call(this),\n      })\n\n      if (this.group) return data\n\n      return this.setBackgroundColor(this.backgroundColor, data)\n    },\n  },\n})\n"],"sourceRoot":"","file":"VBtnToggle.js"}

node_modules/vuetify/es5/components/VBtnToggle/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VBtnToggle", {
+  enumerable: true,
+  get: function get() {
+    return _VBtnToggle.default;
+  }
+});
+exports.default = void 0;
+
+var _VBtnToggle = _interopRequireDefault(require("./VBtnToggle"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _VBtnToggle.default;
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VBtnToggle/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VBtnToggle/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;;;;eAGe,mB","sourcesContent":["import VBtnToggle from './VBtnToggle'\n\nexport { VBtnToggle }\nexport default VBtnToggle\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VCalendar/VCalendar.js

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _calendarWithEvents = _interopRequireDefault(require("./mixins/calendar-with-events"));
+
+var _props = _interopRequireDefault(require("./util/props"));
+
+var _timestamp = require("./util/timestamp");
+
+var _VCalendarMonthly = _interopRequireDefault(require("./VCalendarMonthly"));
+
+var _VCalendarDaily = _interopRequireDefault(require("./VCalendarDaily"));
+
+var _VCalendarWeekly = _interopRequireDefault(require("./VCalendarWeekly"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _calendarWithEvents.default.extend({
+  name: 'v-calendar',
+  props: _objectSpread({}, _props.default.calendar, {}, _props.default.weeks, {}, _props.default.intervals),
+  data: function data() {
+    return {
+      lastStart: null,
+      lastEnd: null
+    };
+  },
+  computed: {
+    parsedValue: function parsedValue() {
+      return (0, _timestamp.validateTimestamp)(this.value) ? (0, _timestamp.parseTimestamp)(this.value, true) : this.parsedStart || this.times.today;
+    },
+    renderProps: function renderProps() {
+      var around = this.parsedValue;
+      var component = null;
+      var maxDays = this.maxDays;
+      var weekdays = this.parsedWeekdays;
+      var start = around;
+      var end = around;
+
+      switch (this.type) {
+        case 'month':
+          component = _VCalendarMonthly.default;
+          start = (0, _timestamp.getStartOfMonth)(around);
+          end = (0, _timestamp.getEndOfMonth)(around);
+          break;
+
+        case 'week':
+          component = _VCalendarDaily.default;
+          start = this.getStartOfWeek(around);
+          end = this.getEndOfWeek(around);
+          maxDays = 7;
+          break;
+
+        case 'day':
+          component = _VCalendarDaily.default;
+          maxDays = 1;
+          weekdays = [start.weekday];
+          break;
+
+        case '4day':
+          component = _VCalendarDaily.default;
+          end = (0, _timestamp.relativeDays)((0, _timestamp.copyTimestamp)(end), _timestamp.nextDay, 4);
+          (0, _timestamp.updateFormatted)(end);
+          maxDays = 4;
+          weekdays = [start.weekday, (start.weekday + 1) % 7, (start.weekday + 2) % 7, (start.weekday + 3) % 7];
+          break;
+
+        case 'custom-weekly':
+          component = _VCalendarWeekly.default;
+          start = this.parsedStart || around;
+          end = this.parsedEnd;
+          break;
+
+        case 'custom-daily':
+          component = _VCalendarDaily.default;
+          start = this.parsedStart || around;
+          end = this.parsedEnd;
+          break;
+
+        default:
+          throw new Error(this.type + ' is not a valid Calendar type');
+      }
+
+      return {
+        component: component,
+        start: start,
+        end: end,
+        maxDays: maxDays,
+        weekdays: weekdays
+      };
+    },
+    eventWeekdays: function eventWeekdays() {
+      return this.renderProps.weekdays;
+    }
+  },
+  watch: {
+    renderProps: 'checkChange'
+  },
+  mounted: function mounted() {
+    this.updateEventVisibility();
+    this.checkChange();
+  },
+  updated: function updated() {
+    window.requestAnimationFrame(this.updateEventVisibility);
+  },
+  methods: {
+    checkChange: function checkChange() {
+      var lastStart = this.lastStart,
+          lastEnd = this.lastEnd;
+      var _this$renderProps = this.renderProps,
+          start = _this$renderProps.start,
+          end = _this$renderProps.end;
+
+      if (!lastStart || !lastEnd || start.date !== lastStart.date || end.date !== lastEnd.date) {
+        this.lastStart = start;
+        this.lastEnd = end;
+        this.$emit('change', {
+          start: start,
+          end: end
+        });
+      }
+    },
+    move: function move() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var moved = (0, _timestamp.copyTimestamp)(this.parsedValue);
+      var forward = amount > 0;
+      var mover = forward ? _timestamp.nextDay : _timestamp.prevDay;
+      var limit = forward ? _timestamp.DAYS_IN_MONTH_MAX : _timestamp.DAY_MIN;
+      var times = forward ? amount : -amount;
+
+      while (--times >= 0) {
+        switch (this.type) {
+          case 'month':
+            moved.day = limit;
+            mover(moved);
+            break;
+
+          case 'week':
+            (0, _timestamp.relativeDays)(moved, mover, _timestamp.DAYS_IN_WEEK);
+            break;
+
+          case 'day':
+            (0, _timestamp.relativeDays)(moved, mover, 1);
+            break;
+
+          case '4day':
+            (0, _timestamp.relativeDays)(moved, mover, 4);
+            break;
+        }
+      }
+
+      (0, _timestamp.updateWeekday)(moved);
+      (0, _timestamp.updateFormatted)(moved);
+      (0, _timestamp.updateRelative)(moved, this.times.now);
+      this.$emit('input', moved.date);
+      this.$emit('moved', moved);
+    },
+    next: function next() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.move(amount);
+    },
+    prev: function prev() {
+      var amount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      this.move(-amount);
+    },
+    timeToY: function timeToY(time) {
+      var clamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var c = this.$children[0];
+
+      if (c && c.timeToY) {
+        return c.timeToY(time, clamp);
+      } else {
+        return false;
+      }
+    },
+    minutesToPixels: function minutesToPixels(minutes) {
+      var c = this.$children[0];
+
+      if (c && c.minutesToPixels) {
+        return c.minutesToPixels(minutes);
+      } else {
+        return -1;
+      }
+    },
+    scrollToTime: function scrollToTime(time) {
+      var c = this.$children[0];
+
+      if (c && c.scrollToTime) {
+        return c.scrollToTime(time);
+      } else {
+        return false;
+      }
+    }
+  },
+  render: function render(h) {
+    var _this = this;
+
+    var _this$renderProps2 = this.renderProps,
+        start = _this$renderProps2.start,
+        end = _this$renderProps2.end,
+        maxDays = _this$renderProps2.maxDays,
+        component = _this$renderProps2.component,
+        weekdays = _this$renderProps2.weekdays;
+    return h(component, {
+      staticClass: 'v-calendar',
+      class: {
+        'v-calendar-events': !this.noEvents
+      },
+      props: _objectSpread({}, this.$props, {
+        start: start.date,
+        end: end.date,
+        maxDays: maxDays,
+        weekdays: weekdays
+      }),
+      directives: [{
+        modifiers: {
+          quiet: true
+        },
+        name: 'resize',
+        value: this.updateEventVisibility
+      }],
+      on: _objectSpread({}, this.$listeners, {
+        'click:date': function clickDate(day) {
+          if (_this.$listeners['input']) {
+            _this.$emit('input', day.date);
+          }
+
+          if (_this.$listeners['click:date']) {
+            _this.$emit('click:date', day);
+          }
+        }
+      }),
+      scopedSlots: this.getScopedSlots()
+    });
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendar.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarDaily.js

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarDaily.sass");
+
+var _resize = _interopRequireDefault(require("../../directives/resize"));
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _calendarWithIntervals = _interopRequireDefault(require("./mixins/calendar-with-intervals"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _calendarWithIntervals.default.extend({
+  name: 'v-calendar-daily',
+  directives: {
+    Resize: _resize.default
+  },
+  data: function data() {
+    return {
+      scrollPush: 0
+    };
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-calendar-daily': true
+      }, this.themeClasses);
+    }
+  },
+  mounted: function mounted() {
+    this.init();
+  },
+  methods: {
+    init: function init() {
+      this.$nextTick(this.onResize);
+    },
+    onResize: function onResize() {
+      this.scrollPush = this.getScrollPush();
+    },
+    getScrollPush: function getScrollPush() {
+      var area = this.$refs.scrollArea;
+      var pane = this.$refs.pane;
+      return area && pane ? area.offsetWidth - pane.offsetWidth : 0;
+    },
+    genHead: function genHead() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__head',
+        style: {
+          marginRight: this.scrollPush + 'px'
+        }
+      }, [this.genHeadIntervals()].concat(_toConsumableArray(this.genHeadDays())));
+    },
+    genHeadIntervals: function genHeadIntervals() {
+      var width = (0, _helpers.convertToUnit)(this.intervalWidth);
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__intervals-head',
+        style: {
+          width: width
+        }
+      }, (0, _helpers.getSlot)(this, 'interval-header'));
+    },
+    genHeadDays: function genHeadDays() {
+      return this.days.map(this.genHeadDay);
+    },
+    genHeadDay: function genHeadDay(day, index) {
+      var _this = this;
+
+      var header = (0, _helpers.getSlot)(this, 'day-header', function () {
+        return _objectSpread({
+          week: _this.days
+        }, day, {
+          index: index
+        });
+      });
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-daily_head-day',
+        class: this.getRelativeClasses(day),
+        on: this.getDefaultMouseEventHandlers(':day', function (_e) {
+          return _this.getSlotScope(day);
+        })
+      }, [this.genHeadWeekday(day), this.genHeadDayLabel(day)].concat(_toConsumableArray(header || [])));
+    },
+    genHeadWeekday: function genHeadWeekday(day) {
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        staticClass: 'v-calendar-daily_head-weekday'
+      }), this.weekdayFormatter(day, this.shortWeekdays));
+    },
+    genHeadDayLabel: function genHeadDayLabel(day) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily_head-day-label'
+      }, (0, _helpers.getSlot)(this, 'day-label-header', day) || [this.genHeadDayButton(day)]);
+    },
+    genHeadDayButton: function genHeadDayButton(day) {
+      var color = day.present ? this.color : 'transparent';
+      return this.$createElement(_VBtn.default, {
+        props: {
+          color: color,
+          fab: true,
+          depressed: true
+        },
+        on: this.getMouseEventHandlers({
+          'click:date': {
+            event: 'click',
+            stop: true
+          },
+          'contextmenu:date': {
+            event: 'contextmenu',
+            stop: true,
+            prevent: true,
+            result: false
+          }
+        }, function (_e) {
+          return day;
+        })
+      }, this.dayFormatter(day, false));
+    },
+    genBody: function genBody() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__body'
+      }, [this.genScrollArea()]);
+    },
+    genScrollArea: function genScrollArea() {
+      return this.$createElement('div', {
+        ref: 'scrollArea',
+        staticClass: 'v-calendar-daily__scroll-area'
+      }, [this.genPane()]);
+    },
+    genPane: function genPane() {
+      return this.$createElement('div', {
+        ref: 'pane',
+        staticClass: 'v-calendar-daily__pane',
+        style: {
+          height: (0, _helpers.convertToUnit)(this.bodyHeight)
+        }
+      }, [this.genDayContainer()]);
+    },
+    genDayContainer: function genDayContainer() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-daily__day-container'
+      }, [this.genBodyIntervals()].concat(_toConsumableArray(this.genDays())));
+    },
+    genDays: function genDays() {
+      return this.days.map(this.genDay);
+    },
+    genDay: function genDay(day, index) {
+      var _this2 = this;
+
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-daily__day',
+        class: this.getRelativeClasses(day),
+        on: this.getDefaultMouseEventHandlers(':time', function (e) {
+          return _this2.getSlotScope(_this2.getTimestampAtEvent(e, day));
+        })
+      }, [].concat(_toConsumableArray(this.genDayIntervals(index)), _toConsumableArray((0, _helpers.getSlot)(this, 'day-body', function () {
+        return _this2.getSlotScope(day);
+      }) || [])));
+    },
+    genDayIntervals: function genDayIntervals(index) {
+      return this.intervals[index].map(this.genDayInterval);
+    },
+    genDayInterval: function genDayInterval(interval) {
+      var _this3 = this;
+
+      var height = (0, _helpers.convertToUnit)(this.intervalHeight);
+      var styler = this.intervalStyle || this.intervalStyleDefault;
+      var data = {
+        key: interval.time,
+        staticClass: 'v-calendar-daily__day-interval',
+        style: _objectSpread({
+          height: height
+        }, styler(interval))
+      };
+      var children = (0, _helpers.getSlot)(this, 'interval', function () {
+        return _this3.getSlotScope(interval);
+      });
+      return this.$createElement('div', data, children);
+    },
+    genBodyIntervals: function genBodyIntervals() {
+      var _this4 = this;
+
+      var width = (0, _helpers.convertToUnit)(this.intervalWidth);
+      var data = {
+        staticClass: 'v-calendar-daily__intervals-body',
+        style: {
+          width: width
+        },
+        on: this.getDefaultMouseEventHandlers(':interval', function (e) {
+          return _this4.getTimestampAtEvent(e, _this4.parsedStart);
+        })
+      };
+      return this.$createElement('div', data, this.genIntervalLabels());
+    },
+    genIntervalLabels: function genIntervalLabels() {
+      if (!this.intervals.length) return null;
+      return this.intervals[0].map(this.genIntervalLabel);
+    },
+    genIntervalLabel: function genIntervalLabel(interval) {
+      var height = (0, _helpers.convertToUnit)(this.intervalHeight);
+      var short = this.shortIntervals;
+      var shower = this.showIntervalLabel || this.showIntervalLabelDefault;
+      var show = shower(interval);
+      var label = show ? this.intervalFormatter(interval, short) : undefined;
+      return this.$createElement('div', {
+        key: interval.time,
+        staticClass: 'v-calendar-daily__interval',
+        style: {
+          height: height
+        }
+      }, [this.$createElement('div', {
+        staticClass: 'v-calendar-daily__interval-text'
+      }, label)]);
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      class: this.classes,
+      nativeOn: {
+        dragstart: function dragstart(e) {
+          e.preventDefault();
+        }
+      },
+      directives: [{
+        modifiers: {
+          quiet: true
+        },
+        name: 'resize',
+        value: this.onResize
+      }]
+    }, [!this.hideHeader ? this.genHead() : '', this.genBody()]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarDaily.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarMonthly.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarWeekly.sass");
+
+var _VCalendarWeekly2 = _interopRequireDefault(require("./VCalendarWeekly"));
+
+var _timestamp = require("./util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Styles
+// Mixins
+// Util
+
+/* @vue/component */
+var _default = _VCalendarWeekly2.default.extend({
+  name: 'v-calendar-monthly',
+  computed: {
+    staticClass: function staticClass() {
+      return 'v-calendar-monthly v-calendar-weekly';
+    },
+    parsedStart: function parsedStart() {
+      return (0, _timestamp.getStartOfMonth)((0, _timestamp.parseTimestamp)(this.start, true));
+    },
+    parsedEnd: function parsedEnd() {
+      return (0, _timestamp.getEndOfMonth)((0, _timestamp.parseTimestamp)(this.end, true));
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarMonthly.js.map

node_modules/vuetify/es5/components/VCalendar/VCalendarMonthly.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VCalendar/VCalendarMonthly.ts"],"names":[],"mappings":";;;;;;;AACA;;AAGA;;AAGA;;;;AAPA;AAGA;AAGA;;AAIA;eACe,0BAAgB,MAAhB,CAAuB;AACpC,EAAA,IAAI,EAAE,oBAD8B;AAGpC,EAAA,QAAQ,EAAE;AACR,IAAA,WADQ,yBACG;AACT,aAAO,sCAAP;AACD,KAHO;AAIR,IAAA,WAJQ,yBAIG;AACT,aAAO,gCAAgB,+BAAe,KAAK,KAApB,EAA2B,IAA3B,CAAhB,CAAP;AACD,KANO;AAOR,IAAA,SAPQ,uBAOC;AACP,aAAO,8BAAc,+BAAe,KAAK,GAApB,EAAyB,IAAzB,CAAd,CAAP;AACD;AATO;AAH0B,CAAvB,C","sourcesContent":["// Styles\nimport './VCalendarWeekly.sass'\n\n// Mixins\nimport VCalendarWeekly from './VCalendarWeekly'\n\n// Util\nimport { parseTimestamp, getStartOfMonth, getEndOfMonth } from './util/timestamp'\nimport { CalendarTimestamp } from 'types'\n\n/* @vue/component */\nexport default VCalendarWeekly.extend({\n  name: 'v-calendar-monthly',\n\n  computed: {\n    staticClass (): string {\n      return 'v-calendar-monthly v-calendar-weekly'\n    },\n    parsedStart (): CalendarTimestamp {\n      return getStartOfMonth(parseTimestamp(this.start, true))\n    },\n    parsedEnd (): CalendarTimestamp {\n      return getEndOfMonth(parseTimestamp(this.end, true))\n    },\n  },\n\n})\n"],"sourceRoot":"","file":"VCalendarMonthly.js"}

node_modules/vuetify/es5/components/VCalendar/VCalendarWeekly.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VCalendar/VCalendarWeekly.sass");
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _calendarBase = _interopRequireDefault(require("./mixins/calendar-base"));
+
+var _helpers = require("../../util/helpers");
+
+var _props = _interopRequireDefault(require("./util/props"));
+
+var _timestamp = require("./util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+/* @vue/component */
+var _default = _calendarBase.default.extend({
+  name: 'v-calendar-weekly',
+  props: _props.default.weeks,
+  computed: {
+    staticClass: function staticClass() {
+      return 'v-calendar-weekly';
+    },
+    classes: function classes() {
+      return this.themeClasses;
+    },
+    parsedMinWeeks: function parsedMinWeeks() {
+      return parseInt(this.minWeeks);
+    },
+    days: function days() {
+      var minDays = this.parsedMinWeeks * this.parsedWeekdays.length;
+      var start = this.getStartOfWeek(this.parsedStart);
+      var end = this.getEndOfWeek(this.parsedEnd);
+      return (0, _timestamp.createDayList)(start, end, this.times.today, this.weekdaySkips, Number.MAX_SAFE_INTEGER, minDays);
+    },
+    todayWeek: function todayWeek() {
+      var today = this.times.today;
+      var start = this.getStartOfWeek(today);
+      var end = this.getEndOfWeek(today);
+      return (0, _timestamp.createDayList)(start, end, today, this.weekdaySkips, this.parsedWeekdays.length, this.parsedWeekdays.length);
+    },
+    monthFormatter: function monthFormatter() {
+      if (this.monthFormat) {
+        return this.monthFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        month: 'long'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        month: 'short'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, short) {
+        return short ? shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    isOutside: function isOutside(day) {
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      return dayIdentifier < (0, _timestamp.getDayIdentifier)(this.parsedStart) || dayIdentifier > (0, _timestamp.getDayIdentifier)(this.parsedEnd);
+    },
+    genHead: function genHead() {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-weekly__head'
+      }, this.genHeadDays());
+    },
+    genHeadDays: function genHeadDays() {
+      return this.todayWeek.map(this.genHeadDay);
+    },
+    genHeadDay: function genHeadDay(day, index) {
+      var outside = this.isOutside(this.days[index]);
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        key: day.date,
+        staticClass: 'v-calendar-weekly__head-weekday',
+        class: this.getRelativeClasses(day, outside)
+      }), this.weekdayFormatter(day, this.shortWeekdays));
+    },
+    genWeeks: function genWeeks() {
+      var days = this.days;
+      var weekDays = this.parsedWeekdays.length;
+      var weeks = [];
+
+      for (var i = 0; i < days.length; i += weekDays) {
+        weeks.push(this.genWeek(days.slice(i, i + weekDays)));
+      }
+
+      return weeks;
+    },
+    genWeek: function genWeek(week) {
+      var _this = this;
+
+      return this.$createElement('div', {
+        key: week[0].date,
+        staticClass: 'v-calendar-weekly__week'
+      }, week.map(function (day, index) {
+        return _this.genDay(day, index, week);
+      }));
+    },
+    genDay: function genDay(day, index, week) {
+      var outside = this.isOutside(day);
+      return this.$createElement('div', {
+        key: day.date,
+        staticClass: 'v-calendar-weekly__day',
+        class: this.getRelativeClasses(day, outside),
+        on: this.getDefaultMouseEventHandlers(':day', function (_e) {
+          return day;
+        })
+      }, [this.genDayLabel(day)].concat(_toConsumableArray((0, _helpers.getSlot)(this, 'day', function () {
+        return _objectSpread({
+          outside: outside,
+          index: index,
+          week: week
+        }, day);
+      }) || [])));
+    },
+    genDayLabel: function genDayLabel(day) {
+      return this.$createElement('div', {
+        staticClass: 'v-calendar-weekly__day-label'
+      }, (0, _helpers.getSlot)(this, 'day-label', day) || [this.genDayLabelButton(day)]);
+    },
+    genDayLabelButton: function genDayLabelButton(day) {
+      var color = day.present ? this.color : 'transparent';
+      var hasMonth = day.day === 1 && this.showMonthOnFirst;
+      return this.$createElement(_VBtn.default, {
+        props: {
+          color: color,
+          fab: true,
+          depressed: true,
+          small: true
+        },
+        on: this.getMouseEventHandlers({
+          'click:date': {
+            event: 'click',
+            stop: true
+          },
+          'contextmenu:date': {
+            event: 'contextmenu',
+            stop: true,
+            prevent: true,
+            result: false
+          }
+        }, function (_e) {
+          return day;
+        })
+      }, hasMonth ? this.monthFormatter(day, this.shortMonths) + ' ' + this.dayFormatter(day, false) : this.dayFormatter(day, false));
+    },
+    genDayMonth: function genDayMonth(day) {
+      var color = day.present ? this.color : undefined;
+      return this.$createElement('div', this.setTextColor(color, {
+        staticClass: 'v-calendar-weekly__day-month'
+      }), (0, _helpers.getSlot)(this, 'day-month', day) || this.monthFormatter(day, this.shortMonths));
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: this.staticClass,
+      class: this.classes,
+      nativeOn: {
+        dragstart: function dragstart(e) {
+          e.preventDefault();
+        }
+      }
+    }, [!this.hideHeader ? this.genHead() : ''].concat(_toConsumableArray(this.genWeeks())));
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VCalendarWeekly.js.map

node_modules/vuetify/es5/components/VCalendar/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VCalendar", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendar.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarDaily", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarDaily.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarWeekly", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarWeekly.default;
+  }
+});
+Object.defineProperty(exports, "VCalendarMonthly", {
+  enumerable: true,
+  get: function get() {
+    return _VCalendarMonthly.default;
+  }
+});
+exports.default = void 0;
+
+var _VCalendar = _interopRequireDefault(require("./VCalendar"));
+
+var _VCalendarDaily = _interopRequireDefault(require("./VCalendarDaily"));
+
+var _VCalendarWeekly = _interopRequireDefault(require("./VCalendarWeekly"));
+
+var _VCalendarMonthly = _interopRequireDefault(require("./VCalendarMonthly"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  $_vuetify_subcomponents: {
+    VCalendar: _VCalendar.default,
+    VCalendarDaily: _VCalendarDaily.default,
+    VCalendarWeekly: _VCalendarWeekly.default,
+    VCalendarMonthly: _VCalendarMonthly.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VCalendar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VCalendar/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;;;eAIe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,SAAS,EAAT,kBADuB;AAEvB,IAAA,cAAc,EAAd,uBAFuB;AAGvB,IAAA,eAAe,EAAf,wBAHuB;AAIvB,IAAA,gBAAgB,EAAhB;AAJuB;AADZ,C","sourcesContent":["import VCalendar from './VCalendar'\nimport VCalendarDaily from './VCalendarDaily'\nimport VCalendarWeekly from './VCalendarWeekly'\nimport VCalendarMonthly from './VCalendarMonthly'\n\nexport { VCalendar, VCalendarDaily, VCalendarWeekly, VCalendarMonthly }\n\nexport default {\n  $_vuetify_subcomponents: {\n    VCalendar,\n    VCalendarDaily,\n    VCalendarWeekly,\n    VCalendarMonthly,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-base.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _mixins = _interopRequireDefault(require("../../../util/mixins"));
+
+var _colorable = _interopRequireDefault(require("../../../mixins/colorable"));
+
+var _localable = _interopRequireDefault(require("../../../mixins/localable"));
+
+var _mouse = _interopRequireDefault(require("./mouse"));
+
+var _themeable = _interopRequireDefault(require("../../../mixins/themeable"));
+
+var _times = _interopRequireDefault(require("./times"));
+
+var _resize = _interopRequireDefault(require("../../../directives/resize"));
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Mixins
+// Directives
+// Util
+var _default = (0, _mixins.default)(_colorable.default, _localable.default, _mouse.default, _themeable.default, _times.default
+/* @vue/component */
+).extend({
+  name: 'calendar-base',
+  directives: {
+    Resize: _resize.default
+  },
+  props: _props.default.base,
+  computed: {
+    parsedWeekdays: function parsedWeekdays() {
+      return Array.isArray(this.weekdays) ? this.weekdays : (this.weekdays || '').split(',').map(function (x) {
+        return parseInt(x, 10);
+      });
+    },
+    weekdaySkips: function weekdaySkips() {
+      return (0, _timestamp.getWeekdaySkips)(this.parsedWeekdays);
+    },
+    weekdaySkipsReverse: function weekdaySkipsReverse() {
+      var reversed = this.weekdaySkips.slice();
+      reversed.reverse();
+      return reversed;
+    },
+    parsedStart: function parsedStart() {
+      return (0, _timestamp.parseTimestamp)(this.start, true);
+    },
+    parsedEnd: function parsedEnd() {
+      var start = this.parsedStart;
+      var end = this.end ? (0, _timestamp.parseTimestamp)(this.end) || start : start;
+      return (0, _timestamp.getTimestampIdentifier)(end) < (0, _timestamp.getTimestampIdentifier)(start) ? start : end;
+    },
+    days: function days() {
+      return (0, _timestamp.createDayList)(this.parsedStart, this.parsedEnd, this.times.today, this.weekdaySkips);
+    },
+    dayFormatter: function dayFormatter() {
+      if (this.dayFormat) {
+        return this.dayFormat;
+      }
+
+      var options = {
+        timeZone: 'UTC',
+        day: 'numeric'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, _short) {
+        return options;
+      });
+    },
+    weekdayFormatter: function weekdayFormatter() {
+      if (this.weekdayFormat) {
+        return this.weekdayFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        weekday: 'long'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        weekday: 'short'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (_tms, short) {
+        return short ? shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    getRelativeClasses: function getRelativeClasses(timestamp) {
+      var outside = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return {
+        'v-present': timestamp.present,
+        'v-past': timestamp.past,
+        'v-future': timestamp.future,
+        'v-outside': outside
+      };
+    },
+    getStartOfWeek: function getStartOfWeek(timestamp) {
+      return (0, _timestamp.getStartOfWeek)(timestamp, this.parsedWeekdays, this.times.today);
+    },
+    getEndOfWeek: function getEndOfWeek(timestamp) {
+      return (0, _timestamp.getEndOfWeek)(timestamp, this.parsedWeekdays, this.times.today);
+    },
+    getFormatter: function getFormatter(options) {
+      return (0, _timestamp.createNativeLocaleFormatter)(this.locale, function (_tms, _short) {
+        return options;
+      });
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-base.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-with-events.js

@@ -0,0 +1,456 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../../src/components/VCalendar/mixins/calendar-with-events.sass");
+
+var _ripple = _interopRequireDefault(require("../../../directives/ripple"));
+
+var _calendarBase = _interopRequireDefault(require("./calendar-base"));
+
+var _helpers = require("../../../util/helpers");
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _modes = require("../modes");
+
+var _timestamp = require("../util/timestamp");
+
+var _events = require("../util/events");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var WIDTH_FULL = 100;
+var WIDTH_START = 95;
+var MINUTES_IN_DAY = 1440;
+/* @vue/component */
+
+var _default = _calendarBase.default.extend({
+  name: 'calendar-with-events',
+  directives: {
+    ripple: _ripple.default
+  },
+  props: _props.default.events,
+  computed: {
+    noEvents: function noEvents() {
+      return this.events.length === 0;
+    },
+    parsedEvents: function parsedEvents() {
+      var _this = this;
+
+      return this.events.map(function (input, index) {
+        return (0, _events.parseEvent)(input, index, _this.eventStart, _this.eventEnd);
+      });
+    },
+    parsedEventOverlapThreshold: function parsedEventOverlapThreshold() {
+      return parseInt(this.eventOverlapThreshold);
+    },
+    eventColorFunction: function eventColorFunction() {
+      var _this2 = this;
+
+      return typeof this.eventColor === 'function' ? this.eventColor : function () {
+        return _this2.eventColor;
+      };
+    },
+    eventTextColorFunction: function eventTextColorFunction() {
+      var _this3 = this;
+
+      return typeof this.eventTextColor === 'function' ? this.eventTextColor : function () {
+        return _this3.eventTextColor;
+      };
+    },
+    eventNameFunction: function eventNameFunction() {
+      var _this4 = this;
+
+      return typeof this.eventName === 'function' ? this.eventName : function (event, timedEvent) {
+        var name = (0, _helpers.escapeHTML)(event.input[_this4.eventName]);
+
+        if (event.start.hasTime) {
+          if (timedEvent) {
+            var showStart = event.start.hour < 12 && event.end.hour >= 12;
+
+            var start = _this4.formatTime(event.start, showStart);
+
+            var end = _this4.formatTime(event.end, true);
+
+            var singline = (0, _timestamp.diffMinutes)(event.start, event.end) <= _this4.parsedEventOverlapThreshold;
+
+            var separator = singline ? ', ' : '<br>';
+            return "<strong>".concat(name, "</strong>").concat(separator).concat(start, " - ").concat(end);
+          } else {
+            var time = _this4.formatTime(event.start, true);
+
+            return "<strong>".concat(time, "</strong> ").concat(name);
+          }
+        }
+
+        return name;
+      };
+    },
+    eventModeFunction: function eventModeFunction() {
+      return typeof this.eventOverlapMode === 'function' ? this.eventOverlapMode : _modes.CalendarEventOverlapModes[this.eventOverlapMode];
+    },
+    eventWeekdays: function eventWeekdays() {
+      return this.parsedWeekdays;
+    }
+  },
+  methods: {
+    formatTime: function formatTime(withTime, ampm) {
+      var formatter = this.getFormatter({
+        timeZone: 'UTC',
+        hour: 'numeric',
+        minute: withTime.minute > 0 ? 'numeric' : undefined
+      });
+      return formatter(withTime, true);
+    },
+    updateEventVisibility: function updateEventVisibility() {
+      if (this.noEvents || !this.eventMore) {
+        return;
+      }
+
+      var eventHeight = this.eventHeight;
+      var eventsMap = this.getEventsMap();
+
+      for (var date in eventsMap) {
+        var _eventsMap$date = eventsMap[date],
+            parent = _eventsMap$date.parent,
+            events = _eventsMap$date.events,
+            more = _eventsMap$date.more;
+
+        if (!more) {
+          break;
+        }
+
+        var parentBounds = parent.getBoundingClientRect();
+        var last = events.length - 1;
+        var hide = false;
+        var hidden = 0;
+
+        for (var i = 0; i <= last; i++) {
+          if (!hide) {
+            var eventBounds = events[i].getBoundingClientRect();
+            hide = i === last ? eventBounds.bottom > parentBounds.bottom : eventBounds.bottom + eventHeight > parentBounds.bottom;
+          }
+
+          if (hide) {
+            events[i].style.display = 'none';
+            hidden++;
+          }
+        }
+
+        if (hide) {
+          more.style.display = '';
+          more.innerHTML = this.$vuetify.lang.t(this.eventMoreText, hidden);
+        } else {
+          more.style.display = 'none';
+        }
+      }
+    },
+    getEventsMap: function getEventsMap() {
+      var eventsMap = {};
+      var elements = this.$refs.events;
+
+      if (!elements || !elements.forEach) {
+        return eventsMap;
+      }
+
+      elements.forEach(function (el) {
+        var date = el.getAttribute('data-date');
+
+        if (el.parentElement && date) {
+          if (!(date in eventsMap)) {
+            eventsMap[date] = {
+              parent: el.parentElement,
+              more: null,
+              events: []
+            };
+          }
+
+          if (el.getAttribute('data-more')) {
+            eventsMap[date].more = el;
+          } else {
+            eventsMap[date].events.push(el);
+            el.style.display = '';
+          }
+        }
+      });
+      return eventsMap;
+    },
+    genDayEvent: function genDayEvent(_ref, day) {
+      var event = _ref.event;
+      var eventHeight = this.eventHeight;
+      var eventMarginBottom = this.eventMarginBottom;
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      var week = day.week;
+      var start = dayIdentifier === event.startIdentifier;
+      var end = dayIdentifier === event.endIdentifier;
+      var width = WIDTH_START;
+
+      for (var i = day.index + 1; i < week.length; i++) {
+        var weekdayIdentifier = (0, _timestamp.getDayIdentifier)(week[i]);
+
+        if (event.endIdentifier >= weekdayIdentifier) {
+          width += WIDTH_FULL;
+
+          if (weekdayIdentifier === event.endIdentifier) {
+            end = true;
+          }
+        } else {
+          end = true;
+          break;
+        }
+      }
+
+      var scope = {
+        event: event.input,
+        day: day,
+        outside: day.outside,
+        start: start,
+        end: end,
+        timed: false
+      };
+      return this.genEvent(event, scope, false, {
+        staticClass: 'v-event',
+        class: {
+          'v-event-start': start,
+          'v-event-end': end
+        },
+        style: {
+          height: "".concat(eventHeight, "px"),
+          width: "".concat(width, "%"),
+          'margin-bottom': "".concat(eventMarginBottom, "px")
+        },
+        attrs: {
+          'data-date': day.date
+        },
+        key: event.index,
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    genTimedEvent: function genTimedEvent(_ref2, day) {
+      var event = _ref2.event,
+          left = _ref2.left,
+          width = _ref2.width;
+      var dayIdentifier = (0, _timestamp.getDayIdentifier)(day);
+      var start = event.startIdentifier >= dayIdentifier;
+      var end = event.endIdentifier > dayIdentifier;
+      var top = start ? day.timeToY(event.start) : 0;
+      var bottom = end ? day.timeToY(MINUTES_IN_DAY) : day.timeToY(event.end);
+      var height = Math.max(this.eventHeight, bottom - top);
+      var scope = {
+        event: event.input,
+        day: day,
+        outside: day.outside,
+        start: start,
+        end: end,
+        timed: true
+      };
+      return this.genEvent(event, scope, true, {
+        staticClass: 'v-event-timed',
+        style: {
+          top: "".concat(top, "px"),
+          height: "".concat(height, "px"),
+          left: "".concat(left, "%"),
+          width: "".concat(width, "%")
+        }
+      });
+    },
+    genEvent: function genEvent(event, scope, timedEvent, data) {
+      var slot = this.$scopedSlots.event;
+      var text = this.eventTextColorFunction(event.input);
+      var background = this.eventColorFunction(event.input);
+      return this.$createElement('div', this.setTextColor(text, this.setBackgroundColor(background, _objectSpread({
+        on: this.getDefaultMouseEventHandlers(':event', function (nativeEvent) {
+          return _objectSpread({}, scope, {
+            nativeEvent: nativeEvent
+          });
+        }),
+        directives: [{
+          name: 'ripple',
+          value: this.eventRipple != null ? this.eventRipple : true
+        }]
+      }, data))), slot ? slot(scope) : [this.genName(event, timedEvent)]);
+    },
+    genName: function genName(event, timedEvent) {
+      return this.$createElement('div', {
+        staticClass: 'pl-1',
+        domProps: {
+          innerHTML: this.eventNameFunction(event, timedEvent)
+        }
+      });
+    },
+    genPlaceholder: function genPlaceholder(day) {
+      var height = this.eventHeight + this.eventMarginBottom;
+      return this.$createElement('div', {
+        style: {
+          height: "".concat(height, "px")
+        },
+        attrs: {
+          'data-date': day.date
+        },
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    genMore: function genMore(day) {
+      var _this5 = this;
+
+      var eventHeight = this.eventHeight;
+      var eventMarginBottom = this.eventMarginBottom;
+      return this.$createElement('div', {
+        staticClass: 'v-event-more pl-1',
+        class: {
+          'v-outside': day.outside
+        },
+        attrs: {
+          'data-date': day.date,
+          'data-more': 1
+        },
+        directives: [{
+          name: 'ripple',
+          value: this.eventRipple != null ? this.eventRipple : true
+        }],
+        on: {
+          click: function click() {
+            return _this5.$emit('click:more', day);
+          }
+        },
+        style: {
+          display: 'none',
+          height: "".concat(eventHeight, "px"),
+          'margin-bottom': "".concat(eventMarginBottom, "px")
+        },
+        ref: 'events',
+        refInFor: true
+      });
+    },
+    getVisibleEvents: function getVisibleEvents() {
+      var start = (0, _timestamp.getDayIdentifier)(this.days[0]);
+      var end = (0, _timestamp.getDayIdentifier)(this.days[this.days.length - 1]);
+      return this.parsedEvents.filter(function (event) {
+        return (0, _events.isEventOverlapping)(event, start, end);
+      });
+    },
+    getEventsForDay: function getEventsForDay(day) {
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      var firstWeekday = this.eventWeekdays[0];
+      return this.parsedEvents.filter(function (event) {
+        return (0, _events.isEventStart)(event, day, identifier, firstWeekday);
+      });
+    },
+    getEventsForDayAll: function getEventsForDayAll(day) {
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      var firstWeekday = this.eventWeekdays[0];
+      return this.parsedEvents.filter(function (event) {
+        return event.allDay && (0, _events.isEventStart)(event, day, identifier, firstWeekday);
+      });
+    },
+    getEventsForDayTimed: function getEventsForDayTimed(day) {
+      var identifier = (0, _timestamp.getDayIdentifier)(day);
+      return this.parsedEvents.filter(function (event) {
+        return !event.allDay && (0, _events.isEventOn)(event, identifier);
+      });
+    },
+    getScopedSlots: function getScopedSlots() {
+      var _this6 = this;
+
+      if (this.noEvents) {
+        return _objectSpread({}, this.$scopedSlots);
+      }
+
+      var mode = this.eventModeFunction(this.parsedEvents, this.eventWeekdays[0], this.parsedEventOverlapThreshold);
+
+      var getSlotChildren = function getSlotChildren(day, getter, mapper, timed) {
+        var events = getter(day);
+
+        if (events.length === 0) {
+          return;
+        }
+
+        var visuals = mode(day, events, timed);
+
+        if (timed) {
+          return visuals.map(function (visual) {
+            return mapper(visual, day);
+          });
+        }
+
+        var children = [];
+        visuals.forEach(function (visual, index) {
+          while (children.length < visual.column) {
+            children.push(_this6.genPlaceholder(day));
+          }
+
+          children.push(mapper(visual, day));
+        });
+        return children;
+      };
+
+      var slots = this.$scopedSlots;
+      var slotDay = slots.day;
+      var slotDayHeader = slots['day-header'];
+      var slotDayBody = slots['day-body'];
+      return _objectSpread({}, slots, {
+        day: function day(_day) {
+          var children = getSlotChildren(_day, _this6.getEventsForDay, _this6.genDayEvent, false);
+
+          if (children && children.length > 0 && _this6.eventMore) {
+            children.push(_this6.genMore(_day));
+          }
+
+          if (slotDay) {
+            var slot = slotDay(_day);
+
+            if (slot) {
+              children = children ? children.concat(slot) : slot;
+            }
+          }
+
+          return children;
+        },
+        'day-header': function dayHeader(day) {
+          var children = getSlotChildren(day, _this6.getEventsForDayAll, _this6.genDayEvent, false);
+
+          if (slotDayHeader) {
+            var slot = slotDayHeader(day);
+
+            if (slot) {
+              children = children ? children.concat(slot) : slot;
+            }
+          }
+
+          return children;
+        },
+        'day-body': function dayBody(day) {
+          var events = getSlotChildren(day, _this6.getEventsForDayTimed, _this6.genTimedEvent, true);
+          var children = [_this6.$createElement('div', {
+            staticClass: 'v-event-timed-container'
+          }, events)];
+
+          if (slotDayBody) {
+            var slot = slotDayBody(day);
+
+            if (slot) {
+              children = children.concat(slot);
+            }
+          }
+
+          return children;
+        }
+      });
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-with-events.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/calendar-with-intervals.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _calendarBase = _interopRequireDefault(require("./calendar-base"));
+
+var _props = _interopRequireDefault(require("../util/props"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Mixins
+// Util
+
+/* @vue/component */
+var _default = _calendarBase.default.extend({
+  name: 'calendar-with-intervals',
+  props: _props.default.intervals,
+  computed: {
+    parsedFirstInterval: function parsedFirstInterval() {
+      return parseInt(this.firstInterval);
+    },
+    parsedIntervalMinutes: function parsedIntervalMinutes() {
+      return parseInt(this.intervalMinutes);
+    },
+    parsedIntervalCount: function parsedIntervalCount() {
+      return parseInt(this.intervalCount);
+    },
+    parsedIntervalHeight: function parsedIntervalHeight() {
+      return parseFloat(this.intervalHeight);
+    },
+    firstMinute: function firstMinute() {
+      return this.parsedFirstInterval * this.parsedIntervalMinutes;
+    },
+    bodyHeight: function bodyHeight() {
+      return this.parsedIntervalCount * this.parsedIntervalHeight;
+    },
+    days: function days() {
+      return (0, _timestamp.createDayList)(this.parsedStart, this.parsedEnd, this.times.today, this.weekdaySkips, this.maxDays);
+    },
+    intervals: function intervals() {
+      var days = this.days;
+      var first = this.parsedFirstInterval;
+      var minutes = this.parsedIntervalMinutes;
+      var count = this.parsedIntervalCount;
+      var now = this.times.now;
+      return days.map(function (d) {
+        return (0, _timestamp.createIntervalList)(d, first, minutes, count, now);
+      });
+    },
+    intervalFormatter: function intervalFormatter() {
+      if (this.intervalFormat) {
+        return this.intervalFormat;
+      }
+
+      var longOptions = {
+        timeZone: 'UTC',
+        hour: '2-digit',
+        minute: '2-digit'
+      };
+      var shortOptions = {
+        timeZone: 'UTC',
+        hour: 'numeric',
+        minute: '2-digit'
+      };
+      var shortHourOptions = {
+        timeZone: 'UTC',
+        hour: 'numeric'
+      };
+      return (0, _timestamp.createNativeLocaleFormatter)(this.currentLocale, function (tms, short) {
+        return short ? tms.minute === 0 ? shortHourOptions : shortOptions : longOptions;
+      });
+    }
+  },
+  methods: {
+    showIntervalLabelDefault: function showIntervalLabelDefault(interval) {
+      var first = this.intervals[0][0];
+      var isFirst = first.hour === interval.hour && first.minute === interval.minute;
+      return !isFirst;
+    },
+    intervalStyleDefault: function intervalStyleDefault(_interval) {
+      return undefined;
+    },
+    getTimestampAtEvent: function getTimestampAtEvent(e, day) {
+      var timestamp = (0, _timestamp.copyTimestamp)(day);
+      var bounds = e.currentTarget.getBoundingClientRect();
+      var baseMinutes = this.firstMinute;
+      var touchEvent = e;
+      var mouseEvent = e;
+      var touches = touchEvent.changedTouches || touchEvent.touches;
+      var clientY = touches && touches[0] ? touches[0].clientY : mouseEvent.clientY;
+      var addIntervals = (clientY - bounds.top) / this.parsedIntervalHeight;
+      var addMinutes = Math.floor(addIntervals * this.parsedIntervalMinutes);
+      var minutes = baseMinutes + addMinutes;
+      return (0, _timestamp.updateMinutes)(timestamp, minutes, this.times.now);
+    },
+    getSlotScope: function getSlotScope(timestamp) {
+      var scope = (0, _timestamp.copyTimestamp)(timestamp);
+      scope.timeToY = this.timeToY;
+      scope.minutesToPixels = this.minutesToPixels;
+      scope.week = this.days;
+      return scope;
+    },
+    scrollToTime: function scrollToTime(time) {
+      var y = this.timeToY(time);
+      var pane = this.$refs.scrollArea;
+
+      if (y === false || !pane) {
+        return false;
+      }
+
+      pane.scrollTop = y;
+      return true;
+    },
+    minutesToPixels: function minutesToPixels(minutes) {
+      return minutes / this.parsedIntervalMinutes * this.parsedIntervalHeight;
+    },
+    timeToY: function timeToY(time) {
+      var clamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var minutes = (0, _timestamp.parseTime)(time);
+
+      if (minutes === false) {
+        return false;
+      }
+
+      var min = this.firstMinute;
+      var gap = this.parsedIntervalCount * this.parsedIntervalMinutes;
+      var delta = (minutes - min) / gap;
+      var y = delta * this.bodyHeight;
+
+      if (clamp) {
+        if (y < 0) {
+          y = 0;
+        }
+
+        if (y > this.bodyHeight) {
+          y = this.bodyHeight;
+        }
+      }
+
+      return y;
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=calendar-with-intervals.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/mouse.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = _vue.default.extend({
+  name: 'mouse',
+  methods: {
+    getDefaultMouseEventHandlers: function getDefaultMouseEventHandlers(suffix, getEvent) {
+      var _this$getMouseEventHa;
+
+      return this.getMouseEventHandlers((_this$getMouseEventHa = {}, _defineProperty(_this$getMouseEventHa, 'click' + suffix, {
+        event: 'click'
+      }), _defineProperty(_this$getMouseEventHa, 'contextmenu' + suffix, {
+        event: 'contextmenu',
+        prevent: true,
+        result: false
+      }), _defineProperty(_this$getMouseEventHa, 'mousedown' + suffix, {
+        event: 'mousedown'
+      }), _defineProperty(_this$getMouseEventHa, 'mousemove' + suffix, {
+        event: 'mousemove'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseup' + suffix, {
+        event: 'mouseup'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseenter' + suffix, {
+        event: 'mouseenter'
+      }), _defineProperty(_this$getMouseEventHa, 'mouseleave' + suffix, {
+        event: 'mouseleave'
+      }), _defineProperty(_this$getMouseEventHa, 'touchstart' + suffix, {
+        event: 'touchstart'
+      }), _defineProperty(_this$getMouseEventHa, 'touchmove' + suffix, {
+        event: 'touchmove'
+      }), _defineProperty(_this$getMouseEventHa, 'touchend' + suffix, {
+        event: 'touchend'
+      }), _this$getMouseEventHa), getEvent);
+    },
+    getMouseEventHandlers: function getMouseEventHandlers(events, getEvent) {
+      var _this = this;
+
+      var on = {};
+
+      var _loop = function _loop(event) {
+        var eventOptions = events[event];
+        if (!_this.$listeners[event]) return "continue"; // TODO somehow pull in modifiers
+
+        var prefix = eventOptions.passive ? '&' : (eventOptions.once ? '~' : '') + (eventOptions.capture ? '!' : '');
+        var key = prefix + eventOptions.event;
+
+        var handler = function handler(e) {
+          var mouseEvent = e;
+
+          if (eventOptions.button === undefined || mouseEvent.buttons > 0 && mouseEvent.button === eventOptions.button) {
+            if (eventOptions.prevent) {
+              e.preventDefault();
+            }
+
+            if (eventOptions.stop) {
+              e.stopPropagation();
+            }
+
+            _this.$emit(event, getEvent(e));
+          }
+
+          return eventOptions.result;
+        };
+
+        if (key in on) {
+          /* istanbul ignore next */
+          if (Array.isArray(on[key])) {
+            on[key].push(handler);
+          } else {
+            on[key] = [on[key], handler];
+          }
+        } else {
+          on[key] = handler;
+        }
+      };
+
+      for (var event in events) {
+        var _ret = _loop(event);
+
+        if (_ret === "continue") continue;
+      }
+
+      return on;
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=mouse.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/mouse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/mixins/mouse.ts"],"names":[],"mappings":";;;;;;;AAAA;;;;;;eAqBe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,OADkB;AAGxB,EAAA,OAAO,EAAE;AACP,IAAA,4BADO,wCACuB,MADvB,EACuC,QADvC,EAC6D;AAAA;;AAClE,aAAO,KAAK,qBAAL,qEACJ,UAAU,MADN,EACe;AAAE,QAAA,KAAK,EAAE;AAAT,OADf,0CAEJ,gBAAgB,MAFZ,EAEqB;AAAE,QAAA,KAAK,EAAE,aAAT;AAAwB,QAAA,OAAO,EAAE,IAAjC;AAAuC,QAAA,MAAM,EAAE;AAA/C,OAFrB,0CAGJ,cAAc,MAHV,EAGmB;AAAE,QAAA,KAAK,EAAE;AAAT,OAHnB,0CAIJ,cAAc,MAJV,EAImB;AAAE,QAAA,KAAK,EAAE;AAAT,OAJnB,0CAKJ,YAAY,MALR,EAKiB;AAAE,QAAA,KAAK,EAAE;AAAT,OALjB,0CAMJ,eAAe,MANX,EAMoB;AAAE,QAAA,KAAK,EAAE;AAAT,OANpB,0CAOJ,eAAe,MAPX,EAOoB;AAAE,QAAA,KAAK,EAAE;AAAT,OAPpB,0CAQJ,eAAe,MARX,EAQoB;AAAE,QAAA,KAAK,EAAE;AAAT,OARpB,0CASJ,cAAc,MATV,EASmB;AAAE,QAAA,KAAK,EAAE;AAAT,OATnB,0CAUJ,aAAa,MAVT,EAUkB;AAAE,QAAA,KAAK,EAAE;AAAT,OAVlB,2BAWJ,QAXI,CAAP;AAYD,KAdM;AAeP,IAAA,qBAfO,iCAegB,MAfhB,EAeqC,QAfrC,EAe2D;AAAA;;AAChE,UAAM,EAAE,GAAmB,EAA3B;;AADgE,iCAGrD,KAHqD;AAI9D,YAAM,YAAY,GAAG,MAAM,CAAC,KAAD,CAA3B;AAEA,YAAI,CAAC,KAAI,CAAC,UAAL,CAAgB,KAAhB,CAAL,EAA6B,kBANiC,CAQ9D;;AAEA,YAAM,MAAM,GAAG,YAAY,CAAC,OAAb,GAAuB,GAAvB,GAA8B,CAAC,YAAY,CAAC,IAAb,GAAoB,GAApB,GAA0B,EAA3B,KAAkC,YAAY,CAAC,OAAb,GAAuB,GAAvB,GAA6B,EAA/D,CAA7C;AACA,YAAM,GAAG,GAAG,MAAM,GAAG,YAAY,CAAC,KAAlC;;AAEA,YAAM,OAAO,GAAiB,SAAxB,OAAwB,CAAA,CAAC,EAAG;AAChC,cAAM,UAAU,GAAe,CAA/B;;AACA,cAAI,YAAY,CAAC,MAAb,KAAwB,SAAxB,IAAsC,UAAU,CAAC,OAAX,GAAqB,CAArB,IAA0B,UAAU,CAAC,MAAX,KAAsB,YAAY,CAAC,MAAvG,EAAgH;AAC9G,gBAAI,YAAY,CAAC,OAAjB,EAA0B;AACxB,cAAA,CAAC,CAAC,cAAF;AACD;;AACD,gBAAI,YAAY,CAAC,IAAjB,EAAuB;AACrB,cAAA,CAAC,CAAC,eAAF;AACD;;AACD,YAAA,KAAI,CAAC,KAAL,CAAW,KAAX,EAAkB,QAAQ,CAAC,CAAD,CAA1B;AACD;;AAED,iBAAO,YAAY,CAAC,MAApB;AACD,SAbD;;AAeA,YAAI,GAAG,IAAI,EAAX,EAAe;AACb;AACA,cAAI,KAAK,CAAC,OAAN,CAAc,EAAE,CAAC,GAAD,CAAhB,CAAJ,EAA4B;AACzB,YAAA,EAAE,CAAC,GAAD,CAAF,CAA2B,IAA3B,CAAgC,OAAhC;AACF,WAFD,MAEO;AACL,YAAA,EAAE,CAAC,GAAD,CAAF,GAAU,CAAC,EAAE,CAAC,GAAD,CAAH,EAAU,OAAV,CAAV;AACD;AACF,SAPD,MAOO;AACL,UAAA,EAAE,CAAC,GAAD,CAAF,GAAU,OAAV;AACD;AArC6D;;AAGhE,WAAK,IAAM,KAAX,IAAoB,MAApB,EAA4B;AAAA,yBAAjB,KAAiB;;AAAA,iCAGG;AAgC9B;;AAED,aAAO,EAAP;AACD;AAxDM;AAHe,CAAX,C","sourcesContent":["import Vue from 'vue'\n\nexport type MouseHandler = (e: MouseEvent | TouchEvent) => any\n\nexport type MouseEvents = {\n  [event: string]: {\n    event: string\n    passive?: boolean\n    capture?: boolean\n    once?: boolean\n    stop?: boolean\n    prevent?: boolean\n    button?: number\n    result?: any\n  }\n}\n\nexport type MouseEventsMap = {\n  [event: string]: MouseHandler | MouseHandler[]\n}\n\nexport default Vue.extend({\n  name: 'mouse',\n\n  methods: {\n    getDefaultMouseEventHandlers (suffix: string, getEvent: MouseHandler): MouseEventsMap {\n      return this.getMouseEventHandlers({\n        ['click' + suffix]: { event: 'click' },\n        ['contextmenu' + suffix]: { event: 'contextmenu', prevent: true, result: false },\n        ['mousedown' + suffix]: { event: 'mousedown' },\n        ['mousemove' + suffix]: { event: 'mousemove' },\n        ['mouseup' + suffix]: { event: 'mouseup' },\n        ['mouseenter' + suffix]: { event: 'mouseenter' },\n        ['mouseleave' + suffix]: { event: 'mouseleave' },\n        ['touchstart' + suffix]: { event: 'touchstart' },\n        ['touchmove' + suffix]: { event: 'touchmove' },\n        ['touchend' + suffix]: { event: 'touchend' },\n      }, getEvent)\n    },\n    getMouseEventHandlers (events: MouseEvents, getEvent: MouseHandler): MouseEventsMap {\n      const on: MouseEventsMap = {}\n\n      for (const event in events) {\n        const eventOptions = events[event]\n\n        if (!this.$listeners[event]) continue\n\n        // TODO somehow pull in modifiers\n\n        const prefix = eventOptions.passive ? '&' : ((eventOptions.once ? '~' : '') + (eventOptions.capture ? '!' : ''))\n        const key = prefix + eventOptions.event\n\n        const handler: MouseHandler = e => {\n          const mouseEvent: MouseEvent = e as MouseEvent\n          if (eventOptions.button === undefined || (mouseEvent.buttons > 0 && mouseEvent.button === eventOptions.button)) {\n            if (eventOptions.prevent) {\n              e.preventDefault()\n            }\n            if (eventOptions.stop) {\n              e.stopPropagation()\n            }\n            this.$emit(event, getEvent(e))\n          }\n\n          return eventOptions.result\n        }\n\n        if (key in on) {\n          /* istanbul ignore next */\n          if (Array.isArray(on[key])) {\n            (on[key] as MouseHandler[]).push(handler)\n          } else {\n            on[key] = [on[key], handler] as MouseHandler[]\n          }\n        } else {\n          on[key] = handler\n        }\n      }\n\n      return on\n    },\n  },\n})\n"],"sourceRoot":"","file":"mouse.js"}

node_modules/vuetify/es5/components/VCalendar/mixins/times.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _timestamp = require("../util/timestamp");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _vue.default.extend({
+  name: 'times',
+  props: {
+    now: {
+      type: String,
+      validator: _timestamp.validateTimestamp
+    }
+  },
+  data: function data() {
+    return {
+      times: {
+        now: (0, _timestamp.parseTimestamp)('0000-00-00 00:00', true),
+        today: (0, _timestamp.parseTimestamp)('0000-00-00', true)
+      }
+    };
+  },
+  computed: {
+    parsedNow: function parsedNow() {
+      return this.now ? (0, _timestamp.parseTimestamp)(this.now, true) : null;
+    }
+  },
+  watch: {
+    parsedNow: 'updateTimes'
+  },
+  created: function created() {
+    this.updateTimes();
+    this.setPresent();
+  },
+  methods: {
+    setPresent: function setPresent() {
+      this.times.now.present = this.times.today.present = true;
+      this.times.now.past = this.times.today.past = false;
+      this.times.now.future = this.times.today.future = false;
+    },
+    updateTimes: function updateTimes() {
+      var now = this.parsedNow || this.getNow();
+      this.updateDay(now, this.times.now);
+      this.updateTime(now, this.times.now);
+      this.updateDay(now, this.times.today);
+    },
+    getNow: function getNow() {
+      return (0, _timestamp.parseDate)(new Date());
+    },
+    updateDay: function updateDay(now, target) {
+      if (now.date !== target.date) {
+        target.year = now.year;
+        target.month = now.month;
+        target.day = now.day;
+        target.weekday = now.weekday;
+        target.date = now.date;
+      }
+    },
+    updateTime: function updateTime(now, target) {
+      if (now.time !== target.time) {
+        target.hour = now.hour;
+        target.minute = now.minute;
+        target.time = now.time;
+      }
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=times.js.map

node_modules/vuetify/es5/components/VCalendar/mixins/times.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/mixins/times.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAEA;;;;eAOe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,OADkB;AAGxB,EAAA,KAAK,EAAE;AACL,IAAA,GAAG,EAAE;AACH,MAAA,IAAI,EAAE,MADH;AAEH,MAAA,SAAS,EAAE;AAFR;AADA,GAHiB;AAUxB,EAAA,IAAI,EAAE;AAAA,WAAO;AACX,MAAA,KAAK,EAAE;AACL,QAAA,GAAG,EAAE,+BAAe,kBAAf,EAAmC,IAAnC,CADA;AAEL,QAAA,KAAK,EAAE,+BAAe,YAAf,EAA6B,IAA7B;AAFF;AADI,KAAP;AAAA,GAVkB;AAiBxB,EAAA,QAAQ,EAAE;AACR,IAAA,SADQ,uBACC;AACP,aAAO,KAAK,GAAL,GAAW,+BAAe,KAAK,GAApB,EAAyB,IAAzB,CAAX,GAA4C,IAAnD;AACD;AAHO,GAjBc;AAuBxB,EAAA,KAAK,EAAE;AACL,IAAA,SAAS,EAAE;AADN,GAvBiB;AA2BxB,EAAA,OA3BwB,qBA2BjB;AACL,SAAK,WAAL;AACA,SAAK,UAAL;AACD,GA9BuB;AAgCxB,EAAA,OAAO,EAAE;AACP,IAAA,UADO,wBACG;AACR,WAAK,KAAL,CAAW,GAAX,CAAe,OAAf,GAAyB,KAAK,KAAL,CAAW,KAAX,CAAiB,OAAjB,GAA2B,IAApD;AACA,WAAK,KAAL,CAAW,GAAX,CAAe,IAAf,GAAsB,KAAK,KAAL,CAAW,KAAX,CAAiB,IAAjB,GAAwB,KAA9C;AACA,WAAK,KAAL,CAAW,GAAX,CAAe,MAAf,GAAwB,KAAK,KAAL,CAAW,KAAX,CAAiB,MAAjB,GAA0B,KAAlD;AACD,KALM;AAMP,IAAA,WANO,yBAMI;AACT,UAAM,GAAG,GAAsB,KAAK,SAAL,IAAkB,KAAK,MAAL,EAAjD;AACA,WAAK,SAAL,CAAe,GAAf,EAAoB,KAAK,KAAL,CAAW,GAA/B;AACA,WAAK,UAAL,CAAgB,GAAhB,EAAqB,KAAK,KAAL,CAAW,GAAhC;AACA,WAAK,SAAL,CAAe,GAAf,EAAoB,KAAK,KAAL,CAAW,KAA/B;AACD,KAXM;AAYP,IAAA,MAZO,oBAYD;AACJ,aAAO,0BAAU,IAAI,IAAJ,EAAV,CAAP;AACD,KAdM;AAeP,IAAA,SAfO,qBAeI,GAfJ,EAe4B,MAf5B,EAeqD;AAC1D,UAAI,GAAG,CAAC,IAAJ,KAAa,MAAM,CAAC,IAAxB,EAA8B;AAC5B,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACA,QAAA,MAAM,CAAC,KAAP,GAAe,GAAG,CAAC,KAAnB;AACA,QAAA,MAAM,CAAC,GAAP,GAAa,GAAG,CAAC,GAAjB;AACA,QAAA,MAAM,CAAC,OAAP,GAAiB,GAAG,CAAC,OAArB;AACA,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACD;AACF,KAvBM;AAwBP,IAAA,UAxBO,sBAwBK,GAxBL,EAwB6B,MAxB7B,EAwBsD;AAC3D,UAAI,GAAG,CAAC,IAAJ,KAAa,MAAM,CAAC,IAAxB,EAA8B;AAC5B,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACA,QAAA,MAAM,CAAC,MAAP,GAAgB,GAAG,CAAC,MAApB;AACA,QAAA,MAAM,CAAC,IAAP,GAAc,GAAG,CAAC,IAAlB;AACD;AACF;AA9BM;AAhCe,CAAX,C","sourcesContent":["import Vue from 'vue'\n\nimport {\n  validateTimestamp,\n  parseTimestamp,\n  parseDate,\n} from '../util/timestamp'\nimport { CalendarTimestamp } from 'types'\n\nexport default Vue.extend({\n  name: 'times',\n\n  props: {\n    now: {\n      type: String,\n      validator: validateTimestamp,\n    },\n  },\n\n  data: () => ({\n    times: {\n      now: parseTimestamp('0000-00-00 00:00', true),\n      today: parseTimestamp('0000-00-00', true),\n    },\n  }),\n\n  computed: {\n    parsedNow (): CalendarTimestamp | null {\n      return this.now ? parseTimestamp(this.now, true) : null\n    },\n  },\n\n  watch: {\n    parsedNow: 'updateTimes',\n  },\n\n  created () {\n    this.updateTimes()\n    this.setPresent()\n  },\n\n  methods: {\n    setPresent (): void {\n      this.times.now.present = this.times.today.present = true\n      this.times.now.past = this.times.today.past = false\n      this.times.now.future = this.times.today.future = false\n    },\n    updateTimes (): void {\n      const now: CalendarTimestamp = this.parsedNow || this.getNow()\n      this.updateDay(now, this.times.now)\n      this.updateTime(now, this.times.now)\n      this.updateDay(now, this.times.today)\n    },\n    getNow (): CalendarTimestamp {\n      return parseDate(new Date())\n    },\n    updateDay (now: CalendarTimestamp, target: CalendarTimestamp): void {\n      if (now.date !== target.date) {\n        target.year = now.year\n        target.month = now.month\n        target.day = now.day\n        target.weekday = now.weekday\n        target.date = now.date\n      }\n    },\n    updateTime (now: CalendarTimestamp, target: CalendarTimestamp): void {\n      if (now.time !== target.time) {\n        target.hour = now.hour\n        target.minute = now.minute\n        target.time = now.time\n      }\n    },\n  },\n})\n"],"sourceRoot":"","file":"times.js"}

node_modules/vuetify/es5/components/VCalendar/modes/column.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.column = void 0;
+
+var _common = require("./common");
+
+var FULL_WIDTH = 100;
+
+var column = function column(events, firstWeekday, overlapThreshold) {
+  var handler = (0, _common.getOverlapGroupHandler)(firstWeekday);
+  return function (day, dayEvents, timed) {
+    var visuals = handler.getVisuals(day, dayEvents, timed);
+
+    if (timed) {
+      visuals.forEach(function (visual) {
+        visual.left = visual.column * FULL_WIDTH / visual.columnCount;
+        visual.width = FULL_WIDTH / visual.columnCount;
+      });
+    }
+
+    return visuals;
+  };
+};
+
+exports.column = column;
+//# sourceMappingURL=column.js.map

node_modules/vuetify/es5/components/VCalendar/modes/column.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/modes/column.ts"],"names":[],"mappings":";;;;;;;AACA;;AAEA,IAAM,UAAU,GAAG,GAAnB;;AAEO,IAAM,MAAM,GAA6B,SAAnC,MAAmC,CAAC,MAAD,EAAS,YAAT,EAAuB,gBAAvB,EAA2C;AACzF,MAAM,OAAO,GAAG,oCAAuB,YAAvB,CAAhB;AAEA,SAAO,UAAC,GAAD,EAAM,SAAN,EAAiB,KAAjB,EAA0B;AAC/B,QAAM,OAAO,GAAG,OAAO,CAAC,UAAR,CAAmB,GAAnB,EAAwB,SAAxB,EAAmC,KAAnC,CAAhB;;AAEA,QAAI,KAAJ,EAAW;AACT,MAAA,OAAO,CAAC,OAAR,CAAgB,UAAA,MAAM,EAAG;AACvB,QAAA,MAAM,CAAC,IAAP,GAAc,MAAM,CAAC,MAAP,GAAgB,UAAhB,GAA6B,MAAM,CAAC,WAAlD;AACA,QAAA,MAAM,CAAC,KAAP,GAAe,UAAU,GAAG,MAAM,CAAC,WAAnC;AACD,OAHD;AAID;;AAED,WAAO,OAAP;AACD,GAXD;AAYD,CAfM","sourcesContent":["import { CalendarEventOverlapMode } from 'types'\nimport { getOverlapGroupHandler } from './common'\n\nconst FULL_WIDTH = 100\n\nexport const column: CalendarEventOverlapMode = (events, firstWeekday, overlapThreshold) => {\n  const handler = getOverlapGroupHandler(firstWeekday)\n\n  return (day, dayEvents, timed) => {\n    const visuals = handler.getVisuals(day, dayEvents, timed)\n\n    if (timed) {\n      visuals.forEach(visual => {\n        visual.left = visual.column * FULL_WIDTH / visual.columnCount\n        visual.width = FULL_WIDTH / visual.columnCount\n      })\n    }\n\n    return visuals\n  }\n}\n"],"sourceRoot":"","file":"column.js"}

node_modules/vuetify/es5/components/VCalendar/modes/common.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisuals = _getVisuals;
+exports.hasOverlap = hasOverlap;
+exports.setColumnCount = setColumnCount;
+exports.getRange = getRange;
+exports.getDayRange = getDayRange;
+exports.getNormalizedRange = getNormalizedRange;
+exports.getOpenGroup = getOpenGroup;
+exports.getOverlapGroupHandler = getOverlapGroupHandler;
+
+var _timestamp = require("../util/timestamp");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var MILLIS_IN_DAY = 86400000;
+
+function _getVisuals(events) {
+  var minStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var visuals = events.map(function (event) {
+    return {
+      event: event,
+      columnCount: 0,
+      column: 0,
+      left: 0,
+      width: 100
+    };
+  });
+  visuals.sort(function (a, b) {
+    return Math.max(minStart, a.event.startTimestampIdentifier) - Math.max(minStart, b.event.startTimestampIdentifier) || b.event.endTimestampIdentifier - a.event.endTimestampIdentifier;
+  });
+  return visuals;
+}
+
+function hasOverlap(s0, e0, s1, e1) {
+  var exclude = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  return exclude ? !(s0 >= e1 || e0 <= s1) : !(s0 > e1 || e0 < s1);
+}
+
+function setColumnCount(groups) {
+  groups.forEach(function (group) {
+    group.visuals.forEach(function (groupVisual) {
+      groupVisual.columnCount = groups.length;
+    });
+  });
+}
+
+function getRange(event) {
+  return [event.startTimestampIdentifier, event.endTimestampIdentifier];
+}
+
+function getDayRange(event) {
+  return [event.startIdentifier, event.endIdentifier];
+}
+
+function getNormalizedRange(event, dayStart) {
+  return [Math.max(dayStart, event.startTimestampIdentifier), Math.min(dayStart + MILLIS_IN_DAY, event.endTimestampIdentifier)];
+}
+
+function getOpenGroup(groups, start, end, timed) {
+  for (var i = 0; i < groups.length; i++) {
+    var group = groups[i];
+    var intersected = false;
+
+    if (hasOverlap(start, end, group.start, group.end, timed)) {
+      for (var k = 0; k < group.visuals.length; k++) {
+        var groupVisual = group.visuals[k];
+
+        var _ref = timed ? getRange(groupVisual.event) : getDayRange(groupVisual.event),
+            _ref2 = _slicedToArray(_ref, 2),
+            groupStart = _ref2[0],
+            groupEnd = _ref2[1];
+
+        if (hasOverlap(start, end, groupStart, groupEnd, timed)) {
+          intersected = true;
+          break;
+        }
+      }
+    }
+
+    if (!intersected) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+function getOverlapGroupHandler(firstWeekday) {
+  var handler = {
+    groups: [],
+    min: -1,
+    max: -1,
+    reset: function reset() {
+      handler.groups = [];
+      handler.min = handler.max = -1;
+    },
+    getVisuals: function getVisuals(day, dayEvents, timed) {
+      if (day.weekday === firstWeekday || timed) {
+        handler.reset();
+      }
+
+      var dayStart = (0, _timestamp.getTimestampIdentifier)(day);
+
+      var visuals = _getVisuals(dayEvents, dayStart);
+
+      visuals.forEach(function (visual) {
+        var _ref3 = timed ? getRange(visual.event) : getDayRange(visual.event),
+            _ref4 = _slicedToArray(_ref3, 2),
+            start = _ref4[0],
+            end = _ref4[1];
+
+        if (handler.groups.length > 0 && !hasOverlap(start, end, handler.min, handler.max, timed)) {
+          setColumnCount(handler.groups);
+          handler.reset();
+        }
+
+        var targetGroup = getOpenGroup(handler.groups, start, end, timed);
+
+        if (targetGroup === -1) {
+          targetGroup = handler.groups.length;
+          handler.groups.push({
+            start: start,
+            end: end,
+            visuals: []
+          });
+        }
+
+        var target = handler.groups[targetGroup];
+        target.visuals.push(visual);
+        target.start = Math.min(target.start, start);
+        target.end = Math.max(target.end, end);
+        visual.column = targetGroup;
+
+        if (handler.min === -1) {
+          handler.min = start;
+          handler.max = end;
+        } else {
+          handler.min = Math.min(handler.min, start);
+          handler.max = Math.max(handler.max, end);
+        }
+      });
+      setColumnCount(handler.groups);
+      return visuals;
+    }
+  };
+  return handler;
+}
+//# sourceMappingURL=common.js.map

node_modules/vuetify/es5/components/VCalendar/modes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CalendarEventOverlapModes = void 0;
+
+var _stack = require("./stack");
+
+var _column = require("./column");
+
+var CalendarEventOverlapModes = {
+  stack: _stack.stack,
+  column: _column.column
+};
+exports.CalendarEventOverlapModes = CalendarEventOverlapModes;
+//# sourceMappingURL=index.js.map