diff --git a/config/webpack.production.config.js b/config/webpack.production.config.js index 93016dc7b..808c5080a 100644 --- a/config/webpack.production.config.js +++ b/config/webpack.production.config.js @@ -1,6 +1,5 @@ const path = require('path') const VueLoaderPlugin = require('vue-loader/lib/plugin') -const UglifyJsPlugin = require('uglifyjs-webpack-plugin') const OptimizeCSSAssetsPlugin = require('optimize-css-assets-webpack-plugin') const config = { @@ -9,11 +8,6 @@ const config = { ], optimization: { minimizer: [ - new UglifyJsPlugin({ - cache: true, - parallel: true, - sourceMap: true - }), new OptimizeCSSAssetsPlugin({}) ] }, diff --git a/dist/.babelrc b/dist/.babelrc old mode 100755 new mode 100644 diff --git a/dist/vue-google-maps.js b/dist/vue-google-maps.js old mode 100755 new mode 100644 index 2da5b6d44..63c4c6fd5 --- a/dist/vue-google-maps.js +++ b/dist/vue-google-maps.js @@ -1 +1,3257 @@ -!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("MarkerClusterer")):"function"==typeof define&&define.amd?define(["MarkerClusterer"],t):"object"==typeof exports?exports.VueGoogleMaps=t(require("MarkerClusterer")):e.VueGoogleMaps=t(e.MarkerClusterer)}(window,function(e){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:r})},n.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n.t=function(e,t){if(1&t&&(e=n(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)n.d(r,o,function(t){return e[t]}.bind(null,o));return r},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=21)}([function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){return function(e,t){if(Array.isArray(e))return e;if(Symbol.iterator in Object(e))return function(e,t){var n=[],r=!0,o=!1,a=void 0;try{for(var i,u=e[Symbol.iterator]();!(r=(i=u.next()).done)&&(n.push(i.value),!t||n.length!==t);r=!0);}catch(e){o=!0,a=e}finally{try{!r&&u.return&&u.return()}finally{if(o)throw a}}return n}(e,t);throw new TypeError("Invalid attempt to destructure non-iterable instance")}}(),o=Object.assign||function(e){for(var t=1;t=0||Object.prototype.hasOwnProperty.call(e,r)&&(n[r]=e[r]);return n}(e,["mappedProps","name","ctr","ctrArgs","events","beforeCreate","afterCreate","props"]),h="$"+n+"Promise",v="$"+n+"Object";return function(e,t){if(!e)throw new Error(t)}(!(m.props instanceof Array),"`props` should be an object, not Array"),o({},"undefined"!=typeof GENERATE_DOC?{$vgmOptions:e}:{},{mixins:[u.default],props:o({},f,c(t)),render:function(){return""},provide:function(){var e=this,n=this.$mapPromise.then(function(n){e.$map=n;var r=o({},e.options,{map:n},(0,i.getPropsValues)(e,t));if(delete r.options,p){var a=p.bind(e)(r);if(a instanceof Promise)return a.then(function(){return{options:r}})}return{options:r}}).then(function(n){var o,u=n.options,c=r();return e[v]=s?new((o=Function.prototype.bind).call.apply(o,[c,null].concat(function(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t=0||Object.prototype.hasOwnProperty.call(e,r)&&(n[r]=e[r]);return n}(u,["placeholder","place","defaultPlace","className","label","selectFirstOnEnter"]);(0,o.bindProps)(e,e.autoCompleter,n),e.autoCompleter.addListener("place_changed",function(){e.$emit("place_changed",e.autoCompleter.getPlace())})})},created:function(){console.warn("The PlaceInput class is deprecated! Please consider using the Autocomplete input instead")},props:u}},function(e,t,n){"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),t.default=(r=n(42)).default||r},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default=function(e,t,n){var r=function(n){(e.$gmapOptions.autobindAllEvents||e.$listeners[n])&&t.addListener(n,function(t){e.$emit(n,t)})},o=!0,a=!1,i=void 0;try{for(var u,s=n[Symbol.iterator]();!(o=(u=s.next()).done);o=!0){r(u.value)}}catch(e){a=!0,i=e}finally{try{!o&&s.return&&s.return()}finally{if(a)throw i}}}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default=function(e,t,n){var r=arguments.length>3&&void 0!==arguments[3]&&arguments[3],o=!1;function a(){o||(o=!0,e.$nextTick(function(){o=!1,n()}))}var i=!0,u=!1,s=void 0;try{for(var c,l=t[Symbol.iterator]();!(i=(c=l.next()).done);i=!0){var p=c.value;e.$watch(p,a,{immediate:r})}}catch(e){u=!0,s=e}finally{try{!i&&l.return&&l.return()}finally{if(u)throw s}}}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={props:["resizeBus"],data:function(){return{_actualResizeBus:null}},created:function(){void 0===this.resizeBus?this.$data._actualResizeBus=this.$gmapDefaultResizeBus:this.$data._actualResizeBus=this.resizeBus},methods:{_resizeCallback:function(){this.resize()},_delayedResizeCallback:function(){var e=this;this.$nextTick(function(){return e._resizeCallback()})}},watch:{resizeBus:function(e){this.$data._actualResizeBus=e},"$data._actualResizeBus":function(e,t){t&&t.$off("resize",this._delayedResizeCallback),e&&e.$on("resize",this._delayedResizeCallback)}},destroyed:function(){this.$data._actualResizeBus&&this.$data._actualResizeBus.$off("resize",this._delayedResizeCallback)}}},function(e,t,n){"use strict";n.d(t,"a",function(){return r}),n.d(t,"b",function(){return o});var r=function(){var e=this.$createElement,t=this._self._c||e;return t("div",[t("div",{ref:"flyaway"},[this._t("default")],2)])},o=[]},function(e,t,n){"use strict";n.d(t,"a",function(){return r}),n.d(t,"b",function(){return o});var r=function(){var e=this.$createElement,t=this._self._c||e;return t("div",{staticClass:"vue-map-container"},[t("div",{ref:"vue-map",staticClass:"vue-map"}),this._v(" "),t("div",{staticClass:"vue-map-hidden"},[this._t("default")],2),this._v(" "),this._t("visible")],2)},o=[]},function(e,t,n){"use strict";n.d(t,"a",function(){return r}),n.d(t,"b",function(){return o});var r=function(){var e=this.$createElement,t=this._self._c||e;return t("div",{staticClass:"vue-street-view-pano-container"},[t("div",{ref:"vue-street-view-pano",staticClass:"vue-street-view-pano"}),this._v(" "),this._t("default")],2)},o=[]},function(e,t,n){"use strict";n.d(t,"a",function(){return r}),n.d(t,"b",function(){return o});var r=function(){var e=this.$createElement,t=this._self._c||e;return t("label",[t("span",{domProps:{textContent:this._s(this.label)}}),this._v(" "),t("input",{ref:"input",class:this.className,attrs:{type:"text",placeholder:this.placeholder}})])},o=[]},function(e,t,n){"use strict";n.d(t,"a",function(){return r}),n.d(t,"b",function(){return o});var r=function(){var e=this.$createElement;return(this._self._c||e)("input",this._g(this._b({ref:"input"},"input",this.$attrs,!1),this.$listeners))},o=[]},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.default={inject:{$mapPromise:{default:"abcdef"}},provide:function(){var e=this;return this.$mapPromise.then(function(t){e.$map=t}),{}}}},function(e,t){e.exports=function(){var e=[];return e.toString=function(){for(var e=[],t=0;t0;if(13===t.which&&!n){var r=document.createEvent("Event");r.keyCode=40,r.which=40,o.apply(e,[r])}o.apply(e,[t])}}t.apply(e,[n,r])}e.addEventListener=n,e.attachEvent=n}},function(e,t,n){"use strict";function r(e,t){for(var n=[],r={},o=0;on.parts.length&&(r.parts.length=n.parts.length)}else{var i=[];for(o=0;o=0||Object.prototype.hasOwnProperty.call(e,r)&&(n[r]=e[r]);return n}(e,["map"])]},render:function(e){return e("div",this.$slots.default)},afterCreate:function(e){var t=function(){var t=e.getMarkers();e.clearMarkers(),e.addMarkers(t)};for(var n in i)i[n].twoWay&&this.$on(n.toLowerCase()+"_changed",t)},updated:function(){this.$clusterObject&&this.$clusterObject.repaint()},beforeDestroy:function(){var e=this;this.$children.forEach(function(t){t.$clusterObject===e.$clusterObject&&(t.$clusterObject=null)}),this.$clusterObject&&this.$clusterObject.clearMarkers()}})},function(t,n){t.exports=e}])}); \ No newline at end of file +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("MarkerClusterer")); + else if(typeof define === 'function' && define.amd) + define(["MarkerClusterer"], factory); + else if(typeof exports === 'object') + exports["VueGoogleMaps"] = factory(require("MarkerClusterer")); + else + root["VueGoogleMaps"] = factory(root["MarkerClusterer"]); +})(window, function(__WEBPACK_EXTERNAL_MODULE__25__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 28); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _utils_bind_events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5); +/* harmony import */ var _utils_bind_props__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1); +/* harmony import */ var _mixins_map_element__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8); +/* harmony import */ var _utils_mapped_props_to_vue_props__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3); + + + + + +/** + * + * @param {Object} options + * @param {Object} options.mappedProps - Definitions of props + * @param {Object} options.mappedProps.PROP.type - Value type + * @param {Boolean} options.mappedProps.PROP.twoWay + * - Whether the prop has a corresponding PROP_changed + * event + * @param {Boolean} options.mappedProps.PROP.noBind + * - If true, do not apply the default bindProps / bindEvents. + * However it will still be added to the list of component props + * @param {Object} options.props - Regular Vue-style props. + * Note: must be in the Object form because it will be + * merged with the `mappedProps` + * + * @param {Object} options.events - Google Maps API events + * that are not bound to a corresponding prop + * @param {String} options.name - e.g. `polyline` + * @param {=> String} options.ctr - constructor, e.g. + * `google.maps.Polyline`. However, since this is not + * generally available during library load, this becomes + * a function instead, e.g. () => google.maps.Polyline + * which will be called only after the API has been loaded + * @param {(MappedProps, OtherVueProps) => Array} options.ctrArgs - + * If the constructor in `ctr` needs to be called with + * arguments other than a single `options` object, e.g. for + * GroundOverlay, we call `new GroundOverlay(url, bounds, options)` + * then pass in a function that returns the argument list as an array + * + * Otherwise, the constructor will be called with an `options` object, + * with property and values merged from: + * + * 1. the `options` property, if any + * 2. a `map` property with the Google Maps + * 3. all the properties passed to the component in `mappedProps` + * @param {Object => Any} options.beforeCreate - + * Hook to modify the options passed to the initializer + * @param {(options.ctr, Object) => Any} options.afterCreate - + * Hook called when + * + */ + +/** + * Custom assert for local validation + **/ +function _assert (v, message) { + if (!v) throw new Error(message) +} + +/* harmony default export */ __webpack_exports__["a"] = (function (options) { + const { + mappedProps, + name, + ctr, + ctrArgs, + events, + beforeCreate, + afterCreate, + props, + ...rest + } = options + + const promiseName = `$${name}Promise` + const instanceName = `$${name}Object` + + _assert(!(rest.props instanceof Array), '`props` should be an object, not Array') + + return { + ...(typeof GENERATE_DOC !== 'undefined' ? { $vgmOptions: options } : {}), + mixins: [_mixins_map_element__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"]], + props: { + ...props, + ...Object(_utils_mapped_props_to_vue_props__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])(mappedProps) + }, + render () { return '' }, + provide () { + const promise = this.$mapPromise.then((map) => { + // Infowindow needs this to be immediately available + this.$map = map + + // Initialize the maps with the given options + const initialOptions = { + ...this.options, + map, + ...Object(_utils_bind_props__WEBPACK_IMPORTED_MODULE_1__[/* getPropsValues */ "b"])(this, mappedProps) + } + // don't use delete keyword in order to create a more predictable code for the engine + let { options, ...finalOptions } = initialOptions // delete the extra options + options = finalOptions + + if (beforeCreate) { + const result = beforeCreate.bind(this)(options) + + if (result instanceof Promise) { + return result.then(() => ({ options })) + } + } + return { options } + }).then(({ options }) => { + const ConstructorObject = ctr() + // https://stackoverflow.com/questions/1606797/use-of-apply-with-new-operator-is-this-possible + this[instanceName] = ctrArgs + ? new (Function.prototype.bind.call( + ConstructorObject, + null, + ...ctrArgs(options, Object(_utils_bind_props__WEBPACK_IMPORTED_MODULE_1__[/* getPropsValues */ "b"])(this, props || {})) + ))() + : new ConstructorObject(options) + + Object(_utils_bind_props__WEBPACK_IMPORTED_MODULE_1__[/* bindProps */ "a"])(this, this[instanceName], mappedProps) + Object(_utils_bind_events__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(this, this[instanceName], events) + + if (afterCreate) { + afterCreate.bind(this)(this[instanceName]) + } + return this[instanceName] + }) + + this[promiseName] = promise + return { [promiseName]: promise } + }, + destroyed () { + // Note: not all Google Maps components support maps + if (this[instanceName] && this[instanceName].setMap) { + this[instanceName].setMap(null) + } + }, + ...rest + } +}); + + +/***/ }), +/* 1 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getPropsValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return bindProps; }); +/* harmony import */ var _watch_primitive_properties__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6); + + +function capitalizeFirstLetter (string) { + return string.charAt(0).toUpperCase() + string.slice(1) +} + +function getPropsValues (vueInst, props) { + return Object.keys(props) + .reduce( + (acc, prop) => { + if (vueInst[prop] !== undefined) { + acc[prop] = vueInst[prop] + } + return acc + }, + {} + ) +} + +/** + * Binds the properties defined in props to the google maps instance. + * If the prop is an Object type, and we wish to track the properties + * of the object (e.g. the lat and lng of a LatLng), then we do a deep + * watch. For deep watch, we also prevent the _changed event from being + * emitted if the data source was external. + */ +function bindProps (vueInst, googleMapsInst, props, options) { + for (const attribute in props) { + const { twoWay, type, trackProperties, noBind } = props[attribute] + + if (noBind) continue + + const setMethodName = 'set' + capitalizeFirstLetter(attribute) + const getMethodName = 'get' + capitalizeFirstLetter(attribute) + const eventName = attribute.toLowerCase() + '_changed' + const initialValue = vueInst[attribute] + + if (typeof googleMapsInst[setMethodName] === 'undefined') { + throw new Error(`${setMethodName} is not a method of (the Maps object corresponding to) ${vueInst.$options._componentTag}`) + } + + // We need to avoid an endless + // propChanged -> event emitted -> propChanged -> event emitted loop + // although this may really be the user's responsibility + if (type !== Object || !trackProperties) { + // Track the object deeply + vueInst.$watch(attribute, () => { + const attributeValue = vueInst[attribute] + + googleMapsInst[setMethodName](attributeValue) + }, { + immediate: typeof initialValue !== 'undefined', + deep: type === Object + }) + } else { + Object(_watch_primitive_properties__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])( + vueInst, + trackProperties.map(prop => `${attribute}.${prop}`), + () => { + googleMapsInst[setMethodName](vueInst[attribute]) + }, + vueInst[attribute] !== undefined + ) + } + + if (twoWay && + (vueInst.$gmapOptions.autobindAllEvents || + vueInst.$listeners[eventName])) { + googleMapsInst.addListener(eventName, (ev) => { // eslint-disable-line no-unused-vars + vueInst.$emit(eventName, googleMapsInst[getMethodName]()) + }) + } + } +} + + +/***/ }), +/* 2 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; }); +/* globals __VUE_SSR_CONTEXT__ */ + +// IMPORTANT: Do NOT use ES2015 features in this file (except for modules). +// This module is a runtime utility for cleaner component module output and will +// be included in the final webpack user bundle. + +function normalizeComponent ( + scriptExports, + render, + staticRenderFns, + functionalTemplate, + injectStyles, + scopeId, + moduleIdentifier, /* server only */ + shadowMode /* vue-cli only */ +) { + // Vue.extend constructor export interop + var options = typeof scriptExports === 'function' + ? scriptExports.options + : scriptExports + + // render functions + if (render) { + options.render = render + options.staticRenderFns = staticRenderFns + options._compiled = true + } + + // functional template + if (functionalTemplate) { + options.functional = true + } + + // scopedId + if (scopeId) { + options._scopeId = 'data-v-' + scopeId + } + + var hook + if (moduleIdentifier) { // server build + hook = function (context) { + // 2.3 injection + context = + context || // cached call + (this.$vnode && this.$vnode.ssrContext) || // stateful + (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional + // 2.2 with runInNewContext: true + if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { + context = __VUE_SSR_CONTEXT__ + } + // inject component styles + if (injectStyles) { + injectStyles.call(this, context) + } + // register component module identifier for async chunk inferrence + if (context && context._registeredComponents) { + context._registeredComponents.add(moduleIdentifier) + } + } + // used by ssr in case component is cached and beforeCreate + // never gets called + options._ssrRegister = hook + } else if (injectStyles) { + hook = shadowMode + ? function () { + injectStyles.call( + this, + (options.functional ? this.parent : this).$root.$options.shadowRoot + ) + } + : injectStyles + } + + if (hook) { + if (options.functional) { + // for template-only hot-reload because in that case the render fn doesn't + // go through the normalizer + options._injectStyles = hook + // register for functional component in vue file + var originalRender = options.render + options.render = function renderWithStyleInjection (h, context) { + hook.call(context) + return originalRender(h, context) + } + } else { + // inject component registration as beforeCreate hook + var existing = options.beforeCreate + options.beforeCreate = existing + ? [].concat(existing, hook) + : [hook] + } + } + + return { + exports: scriptExports, + options: options + } +} + + +/***/ }), +/* 3 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/** + * Strips out the extraneous properties we have in our + * props definitions + * @param {Object} props + */ +/* harmony default export */ __webpack_exports__["a"] = (function (mappedProps) { + return Object.entries(mappedProps) + .map(([key, prop]) => { + const value = {} + + if ('type' in prop) value.type = prop.type + if ('default' in prop) value.default = prop.default + if ('required' in prop) value.required = prop.required + + return [key, value] + }) + .reduce((acc, [key, val]) => { + acc[key] = val + return acc + }, {}) +}); + + +/***/ }), +/* 4 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* +Mixin for objects that are mounted by Google Maps +Javascript API. + +These are objects that are sensitive to element resize +operations so it exposes a property which accepts a bus + +*/ + +/* harmony default export */ __webpack_exports__["a"] = ({ + props: ['resizeBus'], + + data () { + return { + _actualResizeBus: null + } + }, + + created () { + if (typeof this.resizeBus === 'undefined') { + this.$data._actualResizeBus = this.$gmapDefaultResizeBus + } else { + this.$data._actualResizeBus = this.resizeBus + } + }, + + methods: { + _resizeCallback () { + this.resize() + }, + _delayedResizeCallback () { + this.$nextTick(() => this._resizeCallback()) + } + }, + + watch: { + resizeBus (newVal, oldVal) { // eslint-disable-line no-unused-vars + this.$data._actualResizeBus = newVal + }, + '$data._actualResizeBus' (newVal, oldVal) { + if (oldVal) { + oldVal.$off('resize', this._delayedResizeCallback) + } + if (newVal) { + newVal.$on('resize', this._delayedResizeCallback) + } + } + }, + + destroyed () { + if (this.$data._actualResizeBus) { + this.$data._actualResizeBus.$off('resize', this._delayedResizeCallback) + } + } +}); + + +/***/ }), +/* 5 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony default export */ __webpack_exports__["a"] = ((vueInst, googleMapsInst, events) => { + for (const eventName of events) { + if (vueInst.$gmapOptions.autobindAllEvents || + vueInst.$listeners[eventName]) { + googleMapsInst.addListener(eventName, (ev) => { + vueInst.$emit(eventName, ev) + }) + } + } +}); + + +/***/ }), +/* 6 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return watchPrimitiveProperties; }); +/** + * Watch the individual properties of a PoD object, instead of the object + * per se. This is different from a deep watch where both the reference + * and the individual values are watched. + * + * In effect, it throttles the multiple $watch to execute at most once per tick. + */ +function watchPrimitiveProperties (vueInst, propertiesToTrack, handler, immediate = false) { + let isHandled = false + + function requestHandle () { + if (!isHandled) { + isHandled = true + vueInst.$nextTick(() => { + isHandled = false + handler() + }) + } + } + + for (const prop of propertiesToTrack) { + vueInst.$watch(prop, requestHandle, { immediate }) + } +} + + +/***/ }), +/* 7 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ loaded; }); + +// CONCATENATED MODULE: ./src/utils/lazy-value.js +// This piece of code was orignally written by sindresorhus and can be seen here +// https://github.com/sindresorhus/lazy-value/blob/master/index.js + +/* harmony default export */ var lazy_value = ((fn) => { + let called = false + let ret + + return () => { + if (!called) { + called = true + ret = fn() + } + + return ret + } +}); + +// CONCATENATED MODULE: ./src/factories/promise-lazy.js + + +let resolveLoaded +let rejectLoaded +const loaded = new Promise((resolve, reject) => { + resolveLoaded = resolve + rejectLoaded = reject +}) + +/* harmony default export */ var promise_lazy = __webpack_exports__["a"] = (function (loadGmapApi, GmapApi) { + return function promiseLazyCreator (options) { + // Things to do once the API is loaded + function onApiLoaded () { + GmapApi.gmapApi = {} + return window.google + } + + if (options.load) { // If library should load the API + return lazy_value(() => { // Load the + // This will only be evaluated once + if (typeof window === 'undefined') { // server side -- never resolve this promise + return new Promise(() => {}).then(onApiLoaded) + } else { + return new Promise((resolve, reject) => { + try { + window.vueGoogleMapsInit = resolve + loadGmapApi(options.load, options.loadCn) + } catch (err) { + reject(err) + } + }).then(onApiLoaded).then(resolveLoaded).catch(rejectLoaded) + } + }) + } else { // If library should not handle API, provide + // end-users with the global `vueGoogleMapsInit: () => undefined` + // when the Google Maps API has been loaded + const promise = new Promise((resolve) => { + if (typeof window === 'undefined') { + // Do nothing if run from server-side + return + } + window.vueGoogleMapsInit = resolve + }).then(onApiLoaded).then(resolveLoaded).catch(rejectLoaded) + + return lazy_value(() => promise) + } + } +}); + + +/***/ }), +/* 8 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/** + * @class MapElementMixin + * + * Extends components to include the following fields: + * + * @property $map The Google map (valid only after the promise returns) + * + * + * */ +/* harmony default export */ __webpack_exports__["a"] = ({ + inject: { + $mapPromise: { default: 'abcdef' } + }, + + provide () { + // Note: although this mixin is not "providing" anything, + // components' expect the `$map` property to be present on the component. + // In order for that to happen, this mixin must intercept the $mapPromise + // .then(() =>) first before its component does so. + // + // Since a provide() on a mixin is executed before a provide() on the + // component, putting this code in provide() ensures that the $map is + // already set by the time the + // component's provide() is called. + this.$mapPromise.then((map) => { + this.$map = map + }) + + return {} + } +}); + + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + +var api = __webpack_require__(26); + var content = __webpack_require__(34); + + content = content.__esModule ? content.default : content; + + if (typeof content === 'string') { + content = [[module.i, content, '']]; + } + +var options = {}; + +options.insert = "head"; +options.singleton = false; + +var update = api(content, options); + + + +module.exports = content.locals || {}; + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + +var api = __webpack_require__(26); + var content = __webpack_require__(37); + + content = content.__esModule ? content.default : content; + + if (typeof content === 'string') { + content = [[module.i, content, '']]; + } + +var options = {}; + +options.insert = "head"; +options.singleton = false; + +var update = api(content, options); + + + +module.exports = content.locals || {}; + +/***/ }), +/* 11 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return twoWayBindingWrapper; }); +/** + * When you have two-way bindings, but the actual bound value will not equal + * the value you initially passed in, then to avoid an infinite loop you + * need to increment a counter every time you pass in a value, decrement the + * same counter every time the bound value changed, but only bubble up + * the event when the counter is zero. + * +Example: + +Let's say DrawingRecognitionCanvas is a deep-learning backed canvas +that, when given the name of an object (e.g. 'dog'), draws a dog. +But whenever the drawing on it changes, it also sends back its interpretation +of the image by way of the @newObjectRecognized event. + + + + +new TwoWayBindingWrapper((increment, decrement, shouldUpdate) => { + this.$watch('identifiedObject', () => { + // new object passed in + increment() + }) + this.$deepLearningBackend.on('drawingChanged', () => { + recognizeObject(this.$deepLearningBackend) + .then((object) => { + decrement() + if (shouldUpdate()) { + this.$emit('newObjectRecognized', object.name) + } + }) + }) +}) + */ +function twoWayBindingWrapper (fn) { + let counter = 0 + + fn( + () => { counter += 1 }, + () => { counter = Math.max(0, counter - 1) }, + () => counter === 0 + ) +} + + +/***/ }), +/* 12 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +// This piece of code was orignally written by amirnissim and can be seen here +// http://stackoverflow.com/a/11703018/2694653 +// This has been ported to Vanilla.js by GuillaumeLeclerc +/* harmony default export */ __webpack_exports__["a"] = ((input) => { + var _addEventListener = (input.addEventListener) ? input.addEventListener : input.attachEvent + + function addEventListenerWrapper (type, listener) { + // Simulate a 'down arrow' keypress on hitting 'return' when no pac suggestion is selected, + // and then trigger the original listener. + if (type === 'keydown') { + var origListener = listener + listener = function (event) { + var suggestionSelected = document.getElementsByClassName('pac-item-selected').length > 0 + if (event.which === 13 && !suggestionSelected) { + var simulatedEvent = document.createEvent('Event') + simulatedEvent.keyCode = 40 + simulatedEvent.which = 40 + origListener.apply(input, [simulatedEvent]) + } + origListener.apply(input, [event]) + } + } + _addEventListener.apply(input, [type, listener]) + } + + input.addEventListener = addEventListenerWrapper + input.attachEvent = addEventListenerWrapper +}); + + +/***/ }), +/* 13 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/** + * @param apiKey API Key, or object with the URL parameters. For example + * to use Google Maps Premium API, pass + * `{ client: }`. + * You may pass the libraries and/or version (as `v`) parameter into + * this parameter and skip the next two parameters + * @param version Google Maps version + * @param libraries Libraries to load (@see + * https://developers.google.com/maps/documentation/javascript/libraries) + * @param loadCn Boolean. If set to true, the map will be loaded from google maps China + * (@see https://developers.google.com/maps/documentation/javascript/basics#GoogleMapsChina) + * + * Example: + * ``` + * import {load} from 'vue-google-maps' + * + * load() + * + * load({ + * key: , + * }) + * + * load({ + * client: , + * channel: + * }) + * ``` + */ + +/* harmony default export */ __webpack_exports__["a"] = ((() => { + let isApiSetUp = false + + return (options, loadCn) => { + if (typeof document === 'undefined') { + // Do nothing if run from server-side + return + } + + if (!isApiSetUp) { + isApiSetUp = true + + const googleMapScript = document.createElement('SCRIPT') + + // Allow options to be an object. + // This is to support more esoteric means of loading Google Maps, + // such as Google for business + // https://developers.google.com/maps/documentation/javascript/get-api-key#premium-auth + if (typeof options !== 'object') { + throw new Error('options should be an object') + } + + // libraries + if (Object.prototype.isPrototypeOf.call(Array.prototype, options.libraries)) { + options.libraries = options.libraries.join(',') + } + + options.callback = 'vueGoogleMapsInit' + + let baseUrl = 'https://maps.googleapis.com/' + + if (typeof loadCn === 'boolean' && loadCn === true) { + baseUrl = 'https://maps.google.cn/' + } + + const query = Object.keys(options) + .map((key) => encodeURIComponent(key) + '=' + encodeURIComponent(options[key])) + .join('&') + + const url = `${baseUrl}maps/api/js?${query}` + + googleMapScript.setAttribute('src', url) + googleMapScript.setAttribute('async', '') + googleMapScript.setAttribute('defer', '') + document.head.appendChild(googleMapScript) + } else { + throw new Error('You already started the loading of google maps') + } + } +})()); + + +/***/ }), +/* 14 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + url: { + twoWay: false, + type: String + }, + map: { + twoWay: true, + type: Object + } +} + +const events = [ + 'click', + 'rightclick', + 'dblclick', + 'mouseup', + 'mousedown', + 'mouseover', + 'mouseout' +] + +/** + * @class KML Layer + * + * KML Layer class (experimental) + */ +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + mappedProps: props, + events, + name: 'kmlLayer', + ctr: () => google.maps.KmlLayer +})); + + +/***/ }), +/* 15 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + animation: { + twoWay: true, + type: Number + }, + attribution: { + type: Object + }, + clickable: { + type: Boolean, + twoWay: true, + default: true + }, + cursor: { + type: String, + twoWay: true + }, + draggable: { + type: Boolean, + twoWay: true, + default: false + }, + icon: { + twoWay: true + }, + label: { + }, + opacity: { + type: Number, + default: 1 + }, + options: { + type: Object + }, + place: { + type: Object + }, + position: { + type: Object, + twoWay: true + }, + shape: { + type: Object, + twoWay: true + }, + title: { + type: String, + twoWay: true + }, + zIndex: { + type: Number, + twoWay: true + }, + visible: { + twoWay: true, + default: true + } +} + +const events = [ + 'click', + 'rightclick', + 'dblclick', + 'drag', + 'dragstart', + 'dragend', + 'mouseup', + 'mousedown', + 'mouseover', + 'mouseout' +] + +/** + * @class Marker + * + * Marker class with extra support for + * + * - Embedded info windows + * - Clustered markers + * + * Support for clustered markers is for backward-compatability + * reasons. Otherwise we should use a cluster-marker mixin or + * subclass. + */ +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + mappedProps: props, + events, + name: 'marker', + ctr: () => google.maps.Marker, + + inject: { + $clusterPromise: { + default: null + } + }, + + render (h) { + if (!this.$slots.default || this.$slots.default.length === 0) { + return '' + } else if (this.$slots.default.length === 1) { // So that infowindows can have a marker parent + return this.$slots.default[0] + } else { + return h( + 'div', + this.$slots.default + ) + } + }, + + destroyed () { + if (!this.$markerObject) { return } + + if (this.$clusterObject) { + // Repaint will be performed in `updated()` of cluster + this.$clusterObject.removeMarker(this.$markerObject, true) + } else { + this.$markerObject.setMap(null) + } + }, + + beforeCreate (options) { + if (this.$clusterPromise) { + options.map = null + } + + return this.$clusterPromise + }, + + afterCreate (inst) { + if (this.$clusterPromise) { + this.$clusterPromise.then((co) => { + co.addMarker(inst) + this.$clusterObject = co + }) + } + } +})); + + +/***/ }), +/* 16 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + draggable: { + type: Boolean + }, + editable: { + type: Boolean + }, + options: { + twoWay: false, + type: Object + }, + path: { + type: Array, + twoWay: true + } +} + +const events = [ + 'click', + 'dblclick', + 'drag', + 'dragend', + 'dragstart', + 'mousedown', + 'mousemove', + 'mouseout', + 'mouseover', + 'mouseup', + 'rightclick' +] + +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + mappedProps: props, + props: { + deepWatch: { + type: Boolean, + default: false + } + }, + events, + + name: 'polyline', + ctr: () => google.maps.Polyline, + + afterCreate (inst) { + var clearEvents = () => {} + + this.$watch('path', (path) => { + if (path) { + clearEvents() + + this.$polylineObject.setPath(path) + + const mvcPath = this.$polylineObject.getPath() + const eventListeners = [] + + const updatePaths = () => { + this.$emit('path_changed', this.$polylineObject.getPath()) + } + + eventListeners.push([mvcPath, mvcPath.addListener('insert_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('remove_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('set_at', updatePaths)]) + + clearEvents = () => { + eventListeners.map(([obj, listenerHandle]) => // eslint-disable-line no-unused-vars + google.maps.event.removeListener(listenerHandle)) + } + } + }, { + deep: this.deepWatch, + immediate: true + }) + } +})); + + +/***/ }), +/* 17 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + draggable: { + type: Boolean + }, + editable: { + type: Boolean + }, + options: { + type: Object + }, + path: { + type: Array, + twoWay: true, + noBind: true + }, + paths: { + type: Array, + twoWay: true, + noBind: true + } +} + +const events = [ + 'click', + 'dblclick', + 'drag', + 'dragend', + 'dragstart', + 'mousedown', + 'mousemove', + 'mouseout', + 'mouseover', + 'mouseup', + 'rightclick' +] + +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + props: { + deepWatch: { + type: Boolean, + default: false + } + }, + events, + mappedProps: props, + name: 'polygon', + ctr: () => google.maps.Polygon, + + beforeCreate (options) { + if (!options.path) delete options.path + if (!options.paths) delete options.paths + }, + + afterCreate (inst) { + var clearEvents = () => {} + + // Watch paths, on our own, because we do not want to set either when it is + // empty + this.$watch('paths', (paths) => { + if (paths) { + clearEvents() + + inst.setPaths(paths) + + const updatePaths = () => { + this.$emit('paths_changed', inst.getPaths()) + } + const eventListeners = [] + + const mvcArray = inst.getPaths() + for (let i = 0; i < mvcArray.getLength(); i++) { + const mvcPath = mvcArray.getAt(i) + eventListeners.push([mvcPath, mvcPath.addListener('insert_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('remove_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('set_at', updatePaths)]) + } + eventListeners.push([mvcArray, mvcArray.addListener('insert_at', updatePaths)]) + eventListeners.push([mvcArray, mvcArray.addListener('remove_at', updatePaths)]) + eventListeners.push([mvcArray, mvcArray.addListener('set_at', updatePaths)]) + + clearEvents = () => { + eventListeners.map(([obj, listenerHandle]) => // eslint-disable-line no-unused-vars + google.maps.event.removeListener(listenerHandle)) + } + } + }, { + deep: this.deepWatch, + immediate: true + }) + + this.$watch('path', (path) => { + if (path) { + clearEvents() + + inst.setPaths(path) + + const mvcPath = inst.getPath() + const eventListeners = [] + + const updatePaths = () => { + this.$emit('path_changed', inst.getPath()) + } + + eventListeners.push([mvcPath, mvcPath.addListener('insert_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('remove_at', updatePaths)]) + eventListeners.push([mvcPath, mvcPath.addListener('set_at', updatePaths)]) + + clearEvents = () => { + eventListeners.map(([obj, listenerHandle]) => // eslint-disable-line no-unused-vars + google.maps.event.removeListener(listenerHandle)) + } + } + }, { + deep: this.deepWatch, + immediate: true + }) + } +})); + + +/***/ }), +/* 18 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + center: { + type: Object, + twoWay: true, + required: true + }, + radius: { + type: Number, + twoWay: true + }, + draggable: { + type: Boolean, + default: false + }, + editable: { + type: Boolean, + default: false + }, + options: { + type: Object, + twoWay: false + } +} + +const events = [ + 'click', + 'dblclick', + 'drag', + 'dragend', + 'dragstart', + 'mousedown', + 'mousemove', + 'mouseout', + 'mouseover', + 'mouseup', + 'rightclick' +] + +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + mappedProps: props, + name: 'circle', + ctr: () => google.maps.Circle, + events +})); + + +/***/ }), +/* 19 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony import */ var _factories_map_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0); + + +const props = { + bounds: { + type: Object, + twoWay: true + }, + draggable: { + type: Boolean, + default: false + }, + editable: { + type: Boolean, + default: false + }, + options: { + type: Object, + twoWay: false + } +} + +const events = [ + 'click', + 'dblclick', + 'drag', + 'dragend', + 'dragstart', + 'mousedown', + 'mousemove', + 'mouseout', + 'mouseover', + 'mouseup', + 'rightclick' +] + +/* harmony default export */ __webpack_exports__["a"] = (Object(_factories_map_element__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])({ + mappedProps: props, + name: 'rectangle', + ctr: () => google.maps.Rectangle, + events +})); + + +/***/ }), +/* 20 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/components/info-window.vue?vue&type=template&id=1d70e6cc& +var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('div',{ref:"flyaway"},[_vm._t("default")],2)])} +var staticRenderFns = [] + + +// CONCATENATED MODULE: ./src/components/info-window.vue?vue&type=template&id=1d70e6cc& + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib??vue-loader-options!./src/components/info-window.vue?vue&type=script&lang=js& +// +// +// +// +// +// +// +// +// +// +// + +/* harmony default export */ var info_windowvue_type_script_lang_js_ = (((x) => x.default || x)(__webpack_require__(31))); + +// CONCATENATED MODULE: ./src/components/info-window.vue?vue&type=script&lang=js& + /* harmony default export */ var components_info_windowvue_type_script_lang_js_ = (info_windowvue_type_script_lang_js_); +// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +var componentNormalizer = __webpack_require__(2); + +// CONCATENATED MODULE: ./src/components/info-window.vue + + + + + +/* normalize component */ + +var component = Object(componentNormalizer["a" /* default */])( + components_info_windowvue_type_script_lang_js_, + render, + staticRenderFns, + false, + null, + null, + null + +) + +/* harmony default export */ var info_window = __webpack_exports__["a"] = (component.exports); + +/***/ }), +/* 21 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/components/map.vue?vue&type=template&id=43e5bf1b& +var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"vue-map-container"},[_c('div',{ref:"vue-map",staticClass:"vue-map"}),_vm._v(" "),_c('div',{staticClass:"vue-map-hidden"},[_vm._t("default")],2),_vm._v(" "),_vm._t("visible")],2)} +var staticRenderFns = [] + + +// CONCATENATED MODULE: ./src/components/map.vue?vue&type=template&id=43e5bf1b& + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib??vue-loader-options!./src/components/map.vue?vue&type=script&lang=js& +// +// +// +// +// +// +// +// +// +// + +/* harmony default export */ var mapvue_type_script_lang_js_ = (((x) => x.default || x)(__webpack_require__(32))); + +// CONCATENATED MODULE: ./src/components/map.vue?vue&type=script&lang=js& + /* harmony default export */ var components_mapvue_type_script_lang_js_ = (mapvue_type_script_lang_js_); +// EXTERNAL MODULE: ./src/components/map.vue?vue&type=style&index=0&lang=css& +var mapvue_type_style_index_0_lang_css_ = __webpack_require__(33); + +// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +var componentNormalizer = __webpack_require__(2); + +// CONCATENATED MODULE: ./src/components/map.vue + + + + + + +/* normalize component */ + +var component = Object(componentNormalizer["a" /* default */])( + components_mapvue_type_script_lang_js_, + render, + staticRenderFns, + false, + null, + null, + null + +) + +/* harmony default export */ var map = __webpack_exports__["a"] = (component.exports); + +/***/ }), +/* 22 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/components/street-view-panorama.vue?vue&type=template&id=4c5c2aff& +var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"vue-street-view-pano-container"},[_c('div',{ref:"vue-street-view-pano",staticClass:"vue-street-view-pano"}),_vm._v(" "),_vm._t("default")],2)} +var staticRenderFns = [] + + +// CONCATENATED MODULE: ./src/components/street-view-panorama.vue?vue&type=template&id=4c5c2aff& + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib??vue-loader-options!./src/components/street-view-panorama.vue?vue&type=script&lang=js& +// +// +// +// +// +// +// + +/* harmony default export */ var street_view_panoramavue_type_script_lang_js_ = (((x) => x.default || x)(__webpack_require__(35))); + +// CONCATENATED MODULE: ./src/components/street-view-panorama.vue?vue&type=script&lang=js& + /* harmony default export */ var components_street_view_panoramavue_type_script_lang_js_ = (street_view_panoramavue_type_script_lang_js_); +// EXTERNAL MODULE: ./src/components/street-view-panorama.vue?vue&type=style&index=0&lang=css& +var street_view_panoramavue_type_style_index_0_lang_css_ = __webpack_require__(36); + +// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +var componentNormalizer = __webpack_require__(2); + +// CONCATENATED MODULE: ./src/components/street-view-panorama.vue + + + + + + +/* normalize component */ + +var component = Object(componentNormalizer["a" /* default */])( + components_street_view_panoramavue_type_script_lang_js_, + render, + staticRenderFns, + false, + null, + null, + null + +) + +/* harmony default export */ var street_view_panorama = __webpack_exports__["a"] = (component.exports); + +/***/ }), +/* 23 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/components/place-input.vue?vue&type=template&id=221eb736& +var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('label',[_c('span',{domProps:{"textContent":_vm._s(_vm.label)}}),_vm._v(" "),_c('input',{ref:"input",class:_vm.className,attrs:{"type":"text","placeholder":_vm.placeholder}})])} +var staticRenderFns = [] + + +// CONCATENATED MODULE: ./src/components/place-input.vue?vue&type=template&id=221eb736& + +// EXTERNAL MODULE: ./src/utils/bind-props.js +var bind_props = __webpack_require__(1); + +// EXTERNAL MODULE: ./src/utils/simulate-arrow-down.js +var simulate_arrow_down = __webpack_require__(12); + +// CONCATENATED MODULE: ./src/components-implementation/place-input.js?vue&type=script&lang=js& + + + +const props = { + bounds: { + type: Object + }, + defaultPlace: { + type: String, + default: '' + }, + componentRestrictions: { + type: Object, + default: null + }, + types: { + type: Array, + default: function () { + return [] + } + }, + placeholder: { + required: false, + type: String + }, + className: { + required: false, + type: String + }, + label: { + required: false, + type: String, + default: null + }, + selectFirstOnEnter: { + require: false, + type: Boolean, + default: false + } +} + +/* harmony default export */ var place_inputvue_type_script_lang_js_ = ({ + mounted () { + const input = this.$refs.input + + // Allow default place to be set + input.value = this.defaultPlace + this.$watch('defaultPlace', () => { + input.value = this.defaultPlace + }) + + this.$gmapApiPromiseLazy().then(() => { + const options = Object(bind_props["b" /* getPropsValues */])(this, props) + if (this.selectFirstOnEnter) { + Object(simulate_arrow_down["a" /* default */])(this.$refs.input) + } + + if (typeof (google.maps.places.Autocomplete) !== 'function') { + throw new Error('google.maps.places.Autocomplete is undefined. Did you add \'places\' to libraries when loading Google Maps?') + } + + this.autoCompleter = new google.maps.places.Autocomplete(this.$refs.input, options) + const {placeholder, place, defaultPlace, className, label, selectFirstOnEnter, ...rest} = props // eslint-disable-line + Object(bind_props["a" /* bindProps */])(this, this.autoCompleter, rest) + + this.autoCompleter.addListener('place_changed', () => { + this.$emit('place_changed', this.autoCompleter.getPlace()) + }) + }) + }, + created () { + console.warn('The PlaceInput class is deprecated! Please consider using the Autocomplete input instead') // eslint-disable-line no-console + }, + props: props +}); + +// CONCATENATED MODULE: ./src/components-implementation/place-input.js?vue&type=script&lang=js& + /* harmony default export */ var components_implementation_place_inputvue_type_script_lang_js_ = (place_inputvue_type_script_lang_js_); +// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +var componentNormalizer = __webpack_require__(2); + +// CONCATENATED MODULE: ./src/components/place-input.vue + + + + + +/* normalize component */ + +var component = Object(componentNormalizer["a" /* default */])( + components_implementation_place_inputvue_type_script_lang_js_, + render, + staticRenderFns, + false, + null, + null, + null + +) + +/* harmony default export */ var place_input = __webpack_exports__["a"] = (component.exports); + +/***/ }), +/* 24 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/components/autocomplete.vue?vue&type=template&id=fd9210a8& +var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.$scopedSlots['input'])?_c('span',[_vm._t("input",null,{"attrs":_vm.$attrs,"listeners":_vm.$listeners})],2):(!_vm.$scopedSlots['input'])?_c('input',_vm._g(_vm._b({ref:"input"},'input',_vm.$attrs,false),_vm.$listeners)):_vm._e()} +var staticRenderFns = [] + + +// CONCATENATED MODULE: ./src/components/autocomplete.vue?vue&type=template&id=fd9210a8& + +// CONCATENATED MODULE: ./node_modules/vue-loader/lib??vue-loader-options!./src/components/autocomplete.vue?vue&type=script&lang=js& +// +// +// +// +// +// +// + +/* harmony default export */ var autocompletevue_type_script_lang_js_ = (((x) => x.default || x)(__webpack_require__(38))); + +// CONCATENATED MODULE: ./src/components/autocomplete.vue?vue&type=script&lang=js& + /* harmony default export */ var components_autocompletevue_type_script_lang_js_ = (autocompletevue_type_script_lang_js_); +// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js +var componentNormalizer = __webpack_require__(2); + +// CONCATENATED MODULE: ./src/components/autocomplete.vue + + + + + +/* normalize component */ + +var component = Object(componentNormalizer["a" /* default */])( + components_autocompletevue_type_script_lang_js_, + render, + staticRenderFns, + false, + null, + null, + null + +) + +/* harmony default export */ var autocomplete = __webpack_exports__["a"] = (component.exports); + +/***/ }), +/* 25 */ +/***/ (function(module, exports) { + +module.exports = __WEBPACK_EXTERNAL_MODULE__25__; + +/***/ }), +/* 26 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isOldIE = function isOldIE() { + var memo; + return function memorize() { + if (typeof memo === 'undefined') { + // Test for IE <= 9 as proposed by Browserhacks + // @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805 + // Tests for existence of standard globals is to allow style-loader + // to operate correctly into non-standard environments + // @see https://github.com/webpack-contrib/style-loader/issues/177 + memo = Boolean(window && document && document.all && !window.atob); + } + + return memo; + }; +}(); + +var getTarget = function getTarget() { + var memo = {}; + return function memorize(target) { + if (typeof memo[target] === 'undefined') { + var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself + + if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) { + try { + // This will throw an exception if access to iframe is blocked + // due to cross-origin restrictions + styleTarget = styleTarget.contentDocument.head; + } catch (e) { + // istanbul ignore next + styleTarget = null; + } + } + + memo[target] = styleTarget; + } + + return memo[target]; + }; +}(); + +var stylesInDom = []; + +function getIndexByIdentifier(identifier) { + var result = -1; + + for (var i = 0; i < stylesInDom.length; i++) { + if (stylesInDom[i].identifier === identifier) { + result = i; + break; + } + } + + return result; +} + +function modulesToDom(list, options) { + var idCountMap = {}; + var identifiers = []; + + for (var i = 0; i < list.length; i++) { + var item = list[i]; + var id = options.base ? item[0] + options.base : item[0]; + var count = idCountMap[id] || 0; + var identifier = "".concat(id, " ").concat(count); + idCountMap[id] = count + 1; + var index = getIndexByIdentifier(identifier); + var obj = { + css: item[1], + media: item[2], + sourceMap: item[3] + }; + + if (index !== -1) { + stylesInDom[index].references++; + stylesInDom[index].updater(obj); + } else { + stylesInDom.push({ + identifier: identifier, + updater: addStyle(obj, options), + references: 1 + }); + } + + identifiers.push(identifier); + } + + return identifiers; +} + +function insertStyleElement(options) { + var style = document.createElement('style'); + var attributes = options.attributes || {}; + + if (typeof attributes.nonce === 'undefined') { + var nonce = true ? __webpack_require__.nc : undefined; + + if (nonce) { + attributes.nonce = nonce; + } + } + + Object.keys(attributes).forEach(function (key) { + style.setAttribute(key, attributes[key]); + }); + + if (typeof options.insert === 'function') { + options.insert(style); + } else { + var target = getTarget(options.insert || 'head'); + + if (!target) { + throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid."); + } + + target.appendChild(style); + } + + return style; +} + +function removeStyleElement(style) { + // istanbul ignore if + if (style.parentNode === null) { + return false; + } + + style.parentNode.removeChild(style); +} +/* istanbul ignore next */ + + +var replaceText = function replaceText() { + var textStore = []; + return function replace(index, replacement) { + textStore[index] = replacement; + return textStore.filter(Boolean).join('\n'); + }; +}(); + +function applyToSingletonTag(style, index, remove, obj) { + var css = remove ? '' : obj.media ? "@media ".concat(obj.media, " {").concat(obj.css, "}") : obj.css; // For old IE + + /* istanbul ignore if */ + + if (style.styleSheet) { + style.styleSheet.cssText = replaceText(index, css); + } else { + var cssNode = document.createTextNode(css); + var childNodes = style.childNodes; + + if (childNodes[index]) { + style.removeChild(childNodes[index]); + } + + if (childNodes.length) { + style.insertBefore(cssNode, childNodes[index]); + } else { + style.appendChild(cssNode); + } + } +} + +function applyToTag(style, options, obj) { + var css = obj.css; + var media = obj.media; + var sourceMap = obj.sourceMap; + + if (media) { + style.setAttribute('media', media); + } else { + style.removeAttribute('media'); + } + + if (sourceMap && btoa) { + css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */"); + } // For old IE + + /* istanbul ignore if */ + + + if (style.styleSheet) { + style.styleSheet.cssText = css; + } else { + while (style.firstChild) { + style.removeChild(style.firstChild); + } + + style.appendChild(document.createTextNode(css)); + } +} + +var singleton = null; +var singletonCounter = 0; + +function addStyle(obj, options) { + var style; + var update; + var remove; + + if (options.singleton) { + var styleIndex = singletonCounter++; + style = singleton || (singleton = insertStyleElement(options)); + update = applyToSingletonTag.bind(null, style, styleIndex, false); + remove = applyToSingletonTag.bind(null, style, styleIndex, true); + } else { + style = insertStyleElement(options); + update = applyToTag.bind(null, style, options); + + remove = function remove() { + removeStyleElement(style); + }; + } + + update(obj); + return function updateStyle(newObj) { + if (newObj) { + if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) { + return; + } + + update(obj = newObj); + } else { + remove(); + } + }; +} + +module.exports = function (list, options) { + options = options || {}; // Force single-tag solution on IE6-9, which has a hard limit on the # of