diff --git a/.travis.yml b/.travis.yml index 5dd8b92c..b8b9976e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,4 @@ sudo: false language: node_js node_js: - - "iojs" + - 4 diff --git a/dist/react-leaflet.js b/dist/react-leaflet.js new file mode 100644 index 00000000..a89e3edd --- /dev/null +++ b/dist/react-leaflet.js @@ -0,0 +1,5145 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("leaflet"), require("react"), require("react-dom")); + else if(typeof define === 'function' && define.amd) + define(["leaflet", "react", "react-dom"], factory); + else if(typeof exports === 'object') + exports["ReactLeaflet"] = factory(require("leaflet"), require("react"), require("react-dom")); + else + root["ReactLeaflet"] = factory(root["L"], root["React"], root["ReactDOM"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_1__, __WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_101__) { +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] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = 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; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _leaflet = __webpack_require__(1); + + var _leaflet2 = _interopRequireDefault(_leaflet); + + var _types = __webpack_require__(2); + + var _types2 = _interopRequireDefault(_types); + + exports.PropTypes = _types2['default']; + + var _BaseTileLayer2 = __webpack_require__(7); + + var _BaseTileLayer3 = _interopRequireDefault(_BaseTileLayer2); + + exports.BaseTileLayer = _BaseTileLayer3['default']; + + var _CanvasTileLayer2 = __webpack_require__(76); + + var _CanvasTileLayer3 = _interopRequireDefault(_CanvasTileLayer2); + + exports.CanvasTileLayer = _CanvasTileLayer3['default']; + + var _Circle2 = __webpack_require__(77); + + var _Circle3 = _interopRequireDefault(_Circle2); + + exports.Circle = _Circle3['default']; + + var _CircleMarker2 = __webpack_require__(87); + + var _CircleMarker3 = _interopRequireDefault(_CircleMarker2); + + exports.CircleMarker = _CircleMarker3['default']; + + var _FeatureGroup2 = __webpack_require__(88); + + var _FeatureGroup3 = _interopRequireDefault(_FeatureGroup2); + + exports.FeatureGroup = _FeatureGroup3['default']; + + var _GeoJson2 = __webpack_require__(89); + + var _GeoJson3 = _interopRequireDefault(_GeoJson2); + + exports.GeoJson = _GeoJson3['default']; + + var _ImageOverlay2 = __webpack_require__(90); + + var _ImageOverlay3 = _interopRequireDefault(_ImageOverlay2); + + exports.ImageOverlay = _ImageOverlay3['default']; + + var _LayerGroup2 = __webpack_require__(91); + + var _LayerGroup3 = _interopRequireDefault(_LayerGroup2); + + exports.LayerGroup = _LayerGroup3['default']; + + var _Map2 = __webpack_require__(92); + + var _Map3 = _interopRequireDefault(_Map2); + + exports.Map = _Map3['default']; + + var _MapComponent2 = __webpack_require__(33); + + var _MapComponent3 = _interopRequireDefault(_MapComponent2); + + exports.MapComponent = _MapComponent3['default']; + + var _MapLayer2 = __webpack_require__(8); + + var _MapLayer3 = _interopRequireDefault(_MapLayer2); + + exports.MapLayer = _MapLayer3['default']; + + var _Marker2 = __webpack_require__(95); + + var _Marker3 = _interopRequireDefault(_Marker2); + + exports.Marker = _Marker3['default']; + + var _MultiPolygon2 = __webpack_require__(96); + + var _MultiPolygon3 = _interopRequireDefault(_MultiPolygon2); + + exports.MultiPolygon = _MultiPolygon3['default']; + + var _MultiPolyline2 = __webpack_require__(97); + + var _MultiPolyline3 = _interopRequireDefault(_MultiPolyline2); + + exports.MultiPolyline = _MultiPolyline3['default']; + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + exports.Path = _Path3['default']; + + var _Polygon2 = __webpack_require__(98); + + var _Polygon3 = _interopRequireDefault(_Polygon2); + + exports.Polygon = _Polygon3['default']; + + var _Polyline2 = __webpack_require__(99); + + var _Polyline3 = _interopRequireDefault(_Polyline2); + + exports.Polyline = _Polyline3['default']; + + var _Popup2 = __webpack_require__(100); + + var _Popup3 = _interopRequireDefault(_Popup2); + + exports.Popup = _Popup3['default']; + + var _PopupContainer2 = __webpack_require__(86); + + var _PopupContainer3 = _interopRequireDefault(_PopupContainer2); + + exports.PopupContainer = _PopupContainer3['default']; + + var _Rectangle2 = __webpack_require__(102); + + var _Rectangle3 = _interopRequireDefault(_Rectangle2); + + exports.Rectangle = _Rectangle3['default']; + + var _TileLayer2 = __webpack_require__(103); + + var _TileLayer3 = _interopRequireDefault(_TileLayer2); + + exports.TileLayer = _TileLayer3['default']; + + var _WMSTileLayer2 = __webpack_require__(104); + + var _WMSTileLayer3 = _interopRequireDefault(_WMSTileLayer2); + + exports.WMSTileLayer = _WMSTileLayer3['default']; + var setIconDefaultImagePath = function setIconDefaultImagePath(path) { + _leaflet2['default'].Icon.Default.imagePath = path; + }; + + exports.setIconDefaultImagePath = setIconDefaultImagePath; + setIconDefaultImagePath('//cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.5/images'); + +/***/ }, +/* 1 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_1__; + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _bounds2 = __webpack_require__(3); + + var _bounds3 = _interopRequireDefault(_bounds2); + + exports.bounds = _bounds3['default']; + + var _latlng2 = __webpack_require__(6); + + var _latlng3 = _interopRequireDefault(_latlng2); + + exports.latlng = _latlng3['default']; + + var _latlngList2 = __webpack_require__(5); + + var _latlngList3 = _interopRequireDefault(_latlngList2); + + exports.latlngList = _latlngList3['default']; + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _leaflet = __webpack_require__(1); + + var _leaflet2 = _interopRequireDefault(_leaflet); + + var _latlngList = __webpack_require__(5); + + var _latlngList2 = _interopRequireDefault(_latlngList); + + exports['default'] = _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.instanceOf(_leaflet2['default'].LatLngBounds), _latlngList2['default']]); + module.exports = exports['default']; + +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_4__; + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _latlng = __webpack_require__(6); + + var _latlng2 = _interopRequireDefault(_latlng); + + exports['default'] = _react.PropTypes.arrayOf(_latlng2['default']); + module.exports = exports['default']; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _react = __webpack_require__(4); + + exports['default'] = _react.PropTypes.oneOfType([ + // [Number, Number] + _react.PropTypes.arrayOf(_react.PropTypes.number), + // {lat: Number, lng: Number} + _react.PropTypes.shape({ + lat: _react.PropTypes.number, + lng: _react.PropTypes.number + }), + // {lat: Number, lon: Number} + _react.PropTypes.shape({ + lat: _react.PropTypes.number, + lon: _react.PropTypes.number + })]); + module.exports = exports['default']; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _MapLayer2 = __webpack_require__(8); + + var _MapLayer3 = _interopRequireDefault(_MapLayer2); + + var BaseTileLayer = (function (_MapLayer) { + _inherits(BaseTileLayer, _MapLayer); + + function BaseTileLayer() { + _classCallCheck(this, BaseTileLayer); + + _get(Object.getPrototypeOf(BaseTileLayer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(BaseTileLayer, [{ + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + var _props = this.props; + var opacity = _props.opacity; + var zIndex = _props.zIndex; + + if (opacity && opacity !== prevProps.opacity) { + this.leafletElement.setOpacity(opacity); + } + if (zIndex && zIndex !== prevProps.zIndex) { + this.leafletElement.setZIndex(zIndex); + } + } + }, { + key: 'render', + value: function render() { + return null; + } + }], [{ + key: 'propTypes', + value: { + opacity: _react.PropTypes.number, + zIndex: _react.PropTypes.number + }, + enumerable: true + }]); + + return BaseTileLayer; + })(_MapLayer3['default']); + + exports['default'] = BaseTileLayer; + module.exports = exports['default']; + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _lodashObjectAssign = __webpack_require__(9); + + var _lodashObjectAssign2 = _interopRequireDefault(_lodashObjectAssign); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _MapComponent2 = __webpack_require__(33); + + var _MapComponent3 = _interopRequireDefault(_MapComponent2); + + var MapLayer = (function (_MapComponent) { + _inherits(MapLayer, _MapComponent); + + function MapLayer() { + _classCallCheck(this, MapLayer); + + _get(Object.getPrototypeOf(MapLayer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(MapLayer, [{ + key: 'componentDidMount', + value: function componentDidMount() { + _get(Object.getPrototypeOf(MapLayer.prototype), 'componentDidMount', this).call(this); + (this.props.layerGroup || this.props.map).addLayer(this.leafletElement); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + _get(Object.getPrototypeOf(MapLayer.prototype), 'componentWillUnmount', this).call(this); + (this.props.layerGroup || this.props.map).removeLayer(this.leafletElement); + } + }, { + key: 'getClonedChildrenWithMap', + value: function getClonedChildrenWithMap(extra) { + var _props = this.props; + var children = _props.children; + var map = _props.map; + + var props = (0, _lodashObjectAssign2['default'])({ map: map }, extra); + + return _react2['default'].Children.map(children, function (child) { + return child ? _react2['default'].cloneElement(child, props) : null; + }); + } + }]); + + return MapLayer; + })(_MapComponent3['default']); + + exports['default'] = MapLayer; + module.exports = exports['default']; + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + var assignWith = __webpack_require__(10), + baseAssign = __webpack_require__(26), + createAssigner = __webpack_require__(28); + + /** + * Assigns own enumerable properties of source object(s) to the destination + * object. Subsequent sources overwrite property assignments of previous sources. + * If `customizer` is provided it's invoked to produce the assigned values. + * The `customizer` is bound to `thisArg` and invoked with five arguments: + * (objectValue, sourceValue, key, object, source). + * + * **Note:** This method mutates `object` and is based on + * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign). + * + * @static + * @memberOf _ + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @param {*} [thisArg] The `this` binding of `customizer`. + * @returns {Object} Returns `object`. + * @example + * + * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' }); + * // => { 'user': 'fred', 'age': 40 } + * + * // using a customizer callback + * var defaults = _.partialRight(_.assign, function(value, other) { + * return _.isUndefined(value) ? other : value; + * }); + * + * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' }); + * // => { 'user': 'barney', 'age': 36 } + */ + var assign = createAssigner(function(object, source, customizer) { + return customizer + ? assignWith(object, source, customizer) + : baseAssign(object, source); + }); + + module.exports = assign; + + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(11); + + /** + * A specialized version of `_.assign` for customizing assigned values without + * support for argument juggling, multiple sources, and `this` binding `customizer` + * functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + */ + function assignWith(object, source, customizer) { + var index = -1, + props = keys(source), + length = props.length; + + while (++index < length) { + var key = props[index], + value = object[key], + result = customizer(value, source[key], key, object, source); + + if ((result === result ? (result !== value) : (value === value)) || + (value === undefined && !(key in object))) { + object[key] = result; + } + } + return object; + } + + module.exports = assignWith; + + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(12), + isArrayLike = __webpack_require__(17), + isObject = __webpack_require__(15), + shimKeys = __webpack_require__(21); + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeKeys = getNative(Object, 'keys'); + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) + * for more details. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + var keys = !nativeKeys ? shimKeys : function(object) { + var Ctor = object == null ? undefined : object.constructor; + if ((typeof Ctor == 'function' && Ctor.prototype === object) || + (typeof object != 'function' && isArrayLike(object))) { + return shimKeys(object); + } + return isObject(object) ? nativeKeys(object) : []; + }; + + module.exports = keys; + + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + var isNative = __webpack_require__(13); + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = object == null ? undefined : object[key]; + return isNative(value) ? value : undefined; + } + + module.exports = getNative; + + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + var isFunction = __webpack_require__(14), + isObjectLike = __webpack_require__(16); + + /** Used to detect host constructors (Safari > 5). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to resolve the decompiled source of functions. */ + var fnToString = Function.prototype.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** + * Checks if `value` is a native function. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */ + function isNative(value) { + if (value == null) { + return false; + } + if (isFunction(value)) { + return reIsNative.test(fnToString.call(value)); + } + return isObjectLike(value) && reIsHostCtor.test(value); + } + + module.exports = isNative; + + +/***/ }, +/* 14 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(15); + + /** `Object#toString` result references. */ + var funcTag = '[object Function]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in older versions of Chrome and Safari which return 'function' for regexes + // and Safari 8 which returns 'object' for typed array constructors. + return isObject(value) && objToString.call(value) == funcTag; + } + + module.exports = isFunction; + + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. + * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(1); + * // => false + */ + function isObject(value) { + // Avoid a V8 JIT bug in Chrome 19-20. + // See https://code.google.com/p/v8/issues/detail?id=2291 for more details. + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + module.exports = isObject; + + +/***/ }, +/* 16 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is object-like. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + */ + function isObjectLike(value) { + return !!value && typeof value == 'object'; + } + + module.exports = isObjectLike; + + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(18), + isLength = __webpack_require__(20); + + /** + * Checks if `value` is array-like. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + */ + function isArrayLike(value) { + return value != null && isLength(getLength(value)); + } + + module.exports = isArrayLike; + + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(19); + + /** + * Gets the "length" property value of `object`. + * + * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) + * that affects Safari on at least iOS 8.1-8.3 ARM64. + * + * @private + * @param {Object} object The object to query. + * @returns {*} Returns the "length" value. + */ + var getLength = baseProperty('length'); + + module.exports = getLength; + + +/***/ }, +/* 19 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new function. + */ + function baseProperty(key) { + return function(object) { + return object == null ? undefined : object[key]; + }; + } + + module.exports = baseProperty; + + +/***/ }, +/* 20 */ +/***/ function(module, exports) { + + /** + * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) + * of an array-like value. + */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + */ + function isLength(value) { + return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + module.exports = isLength; + + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + var isArguments = __webpack_require__(22), + isArray = __webpack_require__(23), + isIndex = __webpack_require__(24), + isLength = __webpack_require__(20), + keysIn = __webpack_require__(25); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * A fallback implementation of `Object.keys` which creates an array of the + * own enumerable property names of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function shimKeys(object) { + var props = keysIn(object), + propsLength = props.length, + length = propsLength && object.length; + + var allowIndexes = !!length && isLength(length) && + (isArray(object) || isArguments(object)); + + var index = -1, + result = []; + + while (++index < propsLength) { + var key = props[index]; + if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) { + result.push(key); + } + } + return result; + } + + module.exports = shimKeys; + + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLike = __webpack_require__(17), + isObjectLike = __webpack_require__(16); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Native method references. */ + var propertyIsEnumerable = objectProto.propertyIsEnumerable; + + /** + * Checks if `value` is classified as an `arguments` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments(value) { + return isObjectLike(value) && isArrayLike(value) && + hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee'); + } + + module.exports = isArguments; + + +/***/ }, +/* 23 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(12), + isLength = __webpack_require__(20), + isObjectLike = __webpack_require__(16); + + /** `Object#toString` result references. */ + var arrayTag = '[object Array]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeIsArray = getNative(Array, 'isArray'); + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(function() { return arguments; }()); + * // => false + */ + var isArray = nativeIsArray || function(value) { + return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag; + }; + + module.exports = isArray; + + +/***/ }, +/* 24 */ +/***/ function(module, exports) { + + /** Used to detect unsigned integer values. */ + var reIsUint = /^\d+$/; + + /** + * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) + * of an array-like value. + */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1; + length = length == null ? MAX_SAFE_INTEGER : length; + return value > -1 && value % 1 == 0 && value < length; + } + + module.exports = isIndex; + + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + var isArguments = __webpack_require__(22), + isArray = __webpack_require__(23), + isIndex = __webpack_require__(24), + isLength = __webpack_require__(20), + isObject = __webpack_require__(15); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn(object) { + if (object == null) { + return []; + } + if (!isObject(object)) { + object = Object(object); + } + var length = object.length; + length = (length && isLength(length) && + (isArray(object) || isArguments(object)) && length) || 0; + + var Ctor = object.constructor, + index = -1, + isProto = typeof Ctor == 'function' && Ctor.prototype === object, + result = Array(length), + skipIndexes = length > 0; + + while (++index < length) { + result[index] = (index + ''); + } + for (var key in object) { + if (!(skipIndexes && isIndex(key, length)) && + !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + return result; + } + + module.exports = keysIn; + + +/***/ }, +/* 26 */ +/***/ function(module, exports, __webpack_require__) { + + var baseCopy = __webpack_require__(27), + keys = __webpack_require__(11); + + /** + * The base implementation of `_.assign` without support for argument juggling, + * multiple sources, and `customizer` functions. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @returns {Object} Returns `object`. + */ + function baseAssign(object, source) { + return source == null + ? object + : baseCopy(source, keys(source), object); + } + + module.exports = baseAssign; + + +/***/ }, +/* 27 */ +/***/ function(module, exports) { + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property names to copy. + * @param {Object} [object={}] The object to copy properties to. + * @returns {Object} Returns `object`. + */ + function baseCopy(source, props, object) { + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + object[key] = source[key]; + } + return object; + } + + module.exports = baseCopy; + + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + var bindCallback = __webpack_require__(29), + isIterateeCall = __webpack_require__(31), + restParam = __webpack_require__(32); + + /** + * Creates a `_.assign`, `_.defaults`, or `_.merge` function. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ + function createAssigner(assigner) { + return restParam(function(object, sources) { + var index = -1, + length = object == null ? 0 : sources.length, + customizer = length > 2 ? sources[length - 2] : undefined, + guard = length > 2 ? sources[2] : undefined, + thisArg = length > 1 ? sources[length - 1] : undefined; + + if (typeof customizer == 'function') { + customizer = bindCallback(customizer, thisArg, 5); + length -= 2; + } else { + customizer = typeof thisArg == 'function' ? thisArg : undefined; + length -= (customizer ? 1 : 0); + } + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, customizer); + } + } + return object; + }); + } + + module.exports = createAssigner; + + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + var identity = __webpack_require__(30); + + /** + * A specialized version of `baseCallback` which only supports `this` binding + * and specifying the number of arguments to provide to `func`. + * + * @private + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {number} [argCount] The number of arguments to provide to `func`. + * @returns {Function} Returns the callback. + */ + function bindCallback(func, thisArg, argCount) { + if (typeof func != 'function') { + return identity; + } + if (thisArg === undefined) { + return func; + } + switch (argCount) { + case 1: return function(value) { + return func.call(thisArg, value); + }; + case 3: return function(value, index, collection) { + return func.call(thisArg, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(thisArg, accumulator, value, index, collection); + }; + case 5: return function(value, other, key, object, source) { + return func.call(thisArg, value, other, key, object, source); + }; + } + return function() { + return func.apply(thisArg, arguments); + }; + } + + module.exports = bindCallback; + + +/***/ }, +/* 30 */ +/***/ function(module, exports) { + + /** + * This method returns the first argument provided to it. + * + * @static + * @memberOf _ + * @category Utility + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'user': 'fred' }; + * + * _.identity(object) === object; + * // => true + */ + function identity(value) { + return value; + } + + module.exports = identity; + + +/***/ }, +/* 31 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLike = __webpack_require__(17), + isIndex = __webpack_require__(24), + isObject = __webpack_require__(15); + + /** + * Checks if the provided arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`. + */ + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object)) { + var other = object[index]; + return value === value ? (value === other) : (other !== other); + } + return false; + } + + module.exports = isIterateeCall; + + +/***/ }, +/* 32 */ +/***/ function(module, exports) { + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max; + + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as an array. + * + * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters). + * + * @static + * @memberOf _ + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.restParam(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + function restParam(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + rest = Array(length); + + while (++index < length) { + rest[index] = args[start + index]; + } + switch (start) { + case 0: return func.call(this, rest); + case 1: return func.call(this, args[0], rest); + case 2: return func.call(this, args[0], args[1], rest); + } + var otherArgs = Array(start + 1); + index = -1; + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = rest; + return func.apply(this, otherArgs); + }; + } + + module.exports = restParam; + + +/***/ }, +/* 33 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x3, _x4, _x5) { var _again = true; _function: while (_again) { var object = _x3, property = _x4, receiver = _x5; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x3 = parent; _x4 = property; _x5 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _lodashLangClone = __webpack_require__(34); + + var _lodashLangClone2 = _interopRequireDefault(_lodashLangClone); + + var _lodashCollectionForEach = __webpack_require__(46); + + var _lodashCollectionForEach2 = _interopRequireDefault(_lodashCollectionForEach); + + var _lodashCollectionReduce = __webpack_require__(50); + + var _lodashCollectionReduce2 = _interopRequireDefault(_lodashCollectionReduce); + + var _lodashObjectKeys = __webpack_require__(11); + + var _lodashObjectKeys2 = _interopRequireDefault(_lodashObjectKeys); + + var _react = __webpack_require__(4); + + var EVENTS_RE = /on(?:Leaflet)?(.+)/i; + + var MapComponent = (function (_Component) { + _inherits(MapComponent, _Component); + + function MapComponent() { + _classCallCheck(this, MapComponent); + + _get(Object.getPrototypeOf(MapComponent.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(MapComponent, [{ + key: 'getLeafletElement', + value: function getLeafletElement() { + return this.leafletElement; + } + }, { + key: 'extractLeafletEvents', + value: function extractLeafletEvents(props) { + return (0, _lodashCollectionReduce2['default'])((0, _lodashObjectKeys2['default'])(props), function (res, ev) { + if (EVENTS_RE.test(ev)) { + var key = ev.replace(EVENTS_RE, function (match, p) { + return p.toLowerCase(); + }); + res[key] = props[ev]; + } + return res; + }, {}); + } + }, { + key: 'bindLeafletEvents', + value: function bindLeafletEvents() { + var next = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + var prev = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var el = this.leafletElement; + if (!el) return; + + var diff = (0, _lodashLangClone2['default'])(prev); + (0, _lodashCollectionForEach2['default'])(prev, function (cb, ev) { + if (!next[ev] || cb !== next[ev]) { + delete diff[ev]; + el.off(ev, cb); + } + }); + + (0, _lodashCollectionForEach2['default'])(next, function (cb, ev) { + if (!prev[ev] || cb !== prev[ev]) { + diff[ev] = cb; + el.on(ev, cb); + } + }); + + return diff; + } + }, { + key: 'fireLeafletEvent', + value: function fireLeafletEvent(type, data) { + var el = this.leafletElement; + if (el) el.fire(type, data); + } + }, { + key: 'componentWillMount', + value: function componentWillMount() { + this._leafletEvents = this.extractLeafletEvents(this.props); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + this.bindLeafletEvents(this._leafletEvents); + } + }, { + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + var next = this.extractLeafletEvents(nextProps); + this._leafletEvents = this.bindLeafletEvents(next, this._leafletEvents); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + var el = this.leafletElement; + if (!el) return; + + (0, _lodashCollectionForEach2['default'])(this._leafletEvents, function (cb, ev) { + el.off(ev, cb); + }); + } + }]); + + return MapComponent; + })(_react.Component); + + exports['default'] = MapComponent; + module.exports = exports['default']; + +/***/ }, +/* 34 */ +/***/ function(module, exports, __webpack_require__) { + + var baseClone = __webpack_require__(35), + bindCallback = __webpack_require__(29), + isIterateeCall = __webpack_require__(31); + + /** + * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned, + * otherwise they are assigned by reference. If `customizer` is provided it's + * invoked to produce the cloned values. If `customizer` returns `undefined` + * cloning is handled by the method instead. The `customizer` is bound to + * `thisArg` and invoked with up to three argument; (value [, index|key, object]). + * + * **Note:** This method is loosely based on the + * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm). + * The enumerable properties of `arguments` objects and objects created by + * constructors other than `Object` are cloned to plain `Object` objects. An + * empty object is returned for uncloneable values such as functions, DOM nodes, + * Maps, Sets, and WeakMaps. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @param {Function} [customizer] The function to customize cloning values. + * @param {*} [thisArg] The `this` binding of `customizer`. + * @returns {*} Returns the cloned value. + * @example + * + * var users = [ + * { 'user': 'barney' }, + * { 'user': 'fred' } + * ]; + * + * var shallow = _.clone(users); + * shallow[0] === users[0]; + * // => true + * + * var deep = _.clone(users, true); + * deep[0] === users[0]; + * // => false + * + * // using a customizer callback + * var el = _.clone(document.body, function(value) { + * if (_.isElement(value)) { + * return value.cloneNode(false); + * } + * }); + * + * el === document.body + * // => false + * el.nodeName + * // => BODY + * el.childNodes.length; + * // => 0 + */ + function clone(value, isDeep, customizer, thisArg) { + if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) { + isDeep = false; + } + else if (typeof isDeep == 'function') { + thisArg = customizer; + customizer = isDeep; + isDeep = false; + } + return typeof customizer == 'function' + ? baseClone(value, isDeep, bindCallback(customizer, thisArg, 3)) + : baseClone(value, isDeep); + } + + module.exports = clone; + + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayCopy = __webpack_require__(36), + arrayEach = __webpack_require__(37), + baseAssign = __webpack_require__(26), + baseForOwn = __webpack_require__(38), + initCloneArray = __webpack_require__(42), + initCloneByTag = __webpack_require__(43), + initCloneObject = __webpack_require__(45), + isArray = __webpack_require__(23), + isObject = __webpack_require__(15); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + var arrayBufferTag = '[object ArrayBuffer]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to identify `toStringTag` values supported by `_.clone`. */ + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = + cloneableTags[arrayBufferTag] = cloneableTags[boolTag] = + cloneableTags[dateTag] = cloneableTags[float32Tag] = + cloneableTags[float64Tag] = cloneableTags[int8Tag] = + cloneableTags[int16Tag] = cloneableTags[int32Tag] = + cloneableTags[numberTag] = cloneableTags[objectTag] = + cloneableTags[regexpTag] = cloneableTags[stringTag] = + cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = + cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = + cloneableTags[mapTag] = cloneableTags[setTag] = + cloneableTags[weakMapTag] = false; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * The base implementation of `_.clone` without support for argument juggling + * and `this` binding `customizer` functions. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @param {Function} [customizer] The function to customize cloning values. + * @param {string} [key] The key of `value`. + * @param {Object} [object] The object `value` belongs to. + * @param {Array} [stackA=[]] Tracks traversed source objects. + * @param {Array} [stackB=[]] Associates clones with source counterparts. + * @returns {*} Returns the cloned value. + */ + function baseClone(value, isDeep, customizer, key, object, stackA, stackB) { + var result; + if (customizer) { + result = object ? customizer(value, key, object) : customizer(value); + } + if (result !== undefined) { + return result; + } + if (!isObject(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result = initCloneArray(value); + if (!isDeep) { + return arrayCopy(value, result); + } + } else { + var tag = objToString.call(value), + isFunc = tag == funcTag; + + if (tag == objectTag || tag == argsTag || (isFunc && !object)) { + result = initCloneObject(isFunc ? {} : value); + if (!isDeep) { + return baseAssign(result, value); + } + } else { + return cloneableTags[tag] + ? initCloneByTag(value, tag, isDeep) + : (object ? value : {}); + } + } + // Check for circular references and return its corresponding clone. + stackA || (stackA = []); + stackB || (stackB = []); + + var length = stackA.length; + while (length--) { + if (stackA[length] == value) { + return stackB[length]; + } + } + // Add the source value to the stack of traversed objects and associate it with its clone. + stackA.push(value); + stackB.push(result); + + // Recursively populate clone (susceptible to call stack limits). + (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) { + result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB); + }); + return result; + } + + module.exports = baseClone; + + +/***/ }, +/* 36 */ +/***/ function(module, exports) { + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function arrayCopy(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + module.exports = arrayCopy; + + +/***/ }, +/* 37 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.forEach` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array.length; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + module.exports = arrayEach; + + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(39), + keys = __webpack_require__(11); + + /** + * The base implementation of `_.forOwn` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwn(object, iteratee) { + return baseFor(object, iteratee, keys); + } + + module.exports = baseForOwn; + + +/***/ }, +/* 39 */ +/***/ function(module, exports, __webpack_require__) { + + var createBaseFor = __webpack_require__(40); + + /** + * The base implementation of `baseForIn` and `baseForOwn` which iterates + * over `object` properties returned by `keysFunc` invoking `iteratee` for + * each property. Iteratee functions may exit iteration early by explicitly + * returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + module.exports = baseFor; + + +/***/ }, +/* 40 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(41); + + /** + * Creates a base function for `_.forIn` or `_.forInRight`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var iterable = toObject(object), + props = keysFunc(object), + length = props.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length)) { + var key = props[index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + module.exports = createBaseFor; + + +/***/ }, +/* 41 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(15); + + /** + * Converts `value` to an object if it's not one. + * + * @private + * @param {*} value The value to process. + * @returns {Object} Returns the object. + */ + function toObject(value) { + return isObject(value) ? value : Object(value); + } + + module.exports = toObject; + + +/***/ }, +/* 42 */ +/***/ function(module, exports) { + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Initializes an array clone. + * + * @private + * @param {Array} array The array to clone. + * @returns {Array} Returns the initialized clone. + */ + function initCloneArray(array) { + var length = array.length, + result = new array.constructor(length); + + // Add array properties assigned by `RegExp#exec`. + if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { + result.index = array.index; + result.input = array.input; + } + return result; + } + + module.exports = initCloneArray; + + +/***/ }, +/* 43 */ +/***/ function(module, exports, __webpack_require__) { + + var bufferClone = __webpack_require__(44); + + /** `Object#toString` result references. */ + var boolTag = '[object Boolean]', + dateTag = '[object Date]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + stringTag = '[object String]'; + + var arrayBufferTag = '[object ArrayBuffer]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to match `RegExp` flags from their coerced string values. */ + var reFlags = /\w*$/; + + /** + * Initializes an object clone based on its `toStringTag`. + * + * **Note:** This function only supports cloning values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to clone. + * @param {string} tag The `toStringTag` of the object to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return bufferClone(object); + + case boolTag: + case dateTag: + return new Ctor(+object); + + case float32Tag: case float64Tag: + case int8Tag: case int16Tag: case int32Tag: + case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: + var buffer = object.buffer; + return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length); + + case numberTag: + case stringTag: + return new Ctor(object); + + case regexpTag: + var result = new Ctor(object.source, reFlags.exec(object)); + result.lastIndex = object.lastIndex; + } + return result; + } + + module.exports = initCloneByTag; + + +/***/ }, +/* 44 */ +/***/ function(module, exports) { + + /* WEBPACK VAR INJECTION */(function(global) {/** Native method references. */ + var ArrayBuffer = global.ArrayBuffer, + Uint8Array = global.Uint8Array; + + /** + * Creates a clone of the given array buffer. + * + * @private + * @param {ArrayBuffer} buffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function bufferClone(buffer) { + var result = new ArrayBuffer(buffer.byteLength), + view = new Uint8Array(result); + + view.set(new Uint8Array(buffer)); + return result; + } + + module.exports = bufferClone; + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 45 */ +/***/ function(module, exports) { + + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneObject(object) { + var Ctor = object.constructor; + if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) { + Ctor = Object; + } + return new Ctor; + } + + module.exports = initCloneObject; + + +/***/ }, +/* 46 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayEach = __webpack_require__(37), + baseEach = __webpack_require__(47), + createForEach = __webpack_require__(49); + + /** + * Iterates over elements of `collection` invoking `iteratee` for each element. + * The `iteratee` is bound to `thisArg` and invoked with three arguments: + * (value, index|key, collection). Iteratee functions may exit iteration early + * by explicitly returning `false`. + * + * **Note:** As with other "Collections" methods, objects with a "length" property + * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn` + * may be used for object iteration. + * + * @static + * @memberOf _ + * @alias each + * @category Collection + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [thisArg] The `this` binding of `iteratee`. + * @returns {Array|Object|string} Returns `collection`. + * @example + * + * _([1, 2]).forEach(function(n) { + * console.log(n); + * }).value(); + * // => logs each value from left to right and returns the array + * + * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) { + * console.log(n, key); + * }); + * // => logs each value-key pair and returns the object (iteration order is not guaranteed) + */ + var forEach = createForEach(arrayEach, baseEach); + + module.exports = forEach; + + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForOwn = __webpack_require__(38), + createBaseEach = __webpack_require__(48); + + /** + * The base implementation of `_.forEach` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object|string} Returns `collection`. + */ + var baseEach = createBaseEach(baseForOwn); + + module.exports = baseEach; + + +/***/ }, +/* 48 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(18), + isLength = __webpack_require__(20), + toObject = __webpack_require__(41); + + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + var length = collection ? getLength(collection) : 0; + if (!isLength(length)) { + return eachFunc(collection, iteratee); + } + var index = fromRight ? length : -1, + iterable = toObject(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + + module.exports = createBaseEach; + + +/***/ }, +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + + var bindCallback = __webpack_require__(29), + isArray = __webpack_require__(23); + + /** + * Creates a function for `_.forEach` or `_.forEachRight`. + * + * @private + * @param {Function} arrayFunc The function to iterate over an array. + * @param {Function} eachFunc The function to iterate over a collection. + * @returns {Function} Returns the new each function. + */ + function createForEach(arrayFunc, eachFunc) { + return function(collection, iteratee, thisArg) { + return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection)) + ? arrayFunc(collection, iteratee) + : eachFunc(collection, bindCallback(iteratee, thisArg, 3)); + }; + } + + module.exports = createForEach; + + +/***/ }, +/* 50 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayReduce = __webpack_require__(51), + baseEach = __webpack_require__(47), + createReduce = __webpack_require__(52); + + /** + * Reduces `collection` to a value which is the accumulated result of running + * each element in `collection` through `iteratee`, where each successive + * invocation is supplied the return value of the previous. If `accumulator` + * is not provided the first element of `collection` is used as the initial + * value. The `iteratee` is bound to `thisArg` and invoked with four arguments: + * (accumulator, value, index|key, collection). + * + * Many lodash methods are guarded to work as iteratees for methods like + * `_.reduce`, `_.reduceRight`, and `_.transform`. + * + * The guarded methods are: + * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `sortByAll`, + * and `sortByOrder` + * + * @static + * @memberOf _ + * @alias foldl, inject + * @category Collection + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} [iteratee=_.identity] The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {*} [thisArg] The `this` binding of `iteratee`. + * @returns {*} Returns the accumulated value. + * @example + * + * _.reduce([1, 2], function(total, n) { + * return total + n; + * }); + * // => 3 + * + * _.reduce({ 'a': 1, 'b': 2 }, function(result, n, key) { + * result[key] = n * 3; + * return result; + * }, {}); + * // => { 'a': 3, 'b': 6 } (iteration order is not guaranteed) + */ + var reduce = createReduce(arrayReduce, baseEach); + + module.exports = reduce; + + +/***/ }, +/* 51 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.reduce` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initFromArray] Specify using the first element of `array` + * as the initial value. + * @returns {*} Returns the accumulated value. + */ + function arrayReduce(array, iteratee, accumulator, initFromArray) { + var index = -1, + length = array.length; + + if (initFromArray && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + + module.exports = arrayReduce; + + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + var baseCallback = __webpack_require__(53), + baseReduce = __webpack_require__(75), + isArray = __webpack_require__(23); + + /** + * Creates a function for `_.reduce` or `_.reduceRight`. + * + * @private + * @param {Function} arrayFunc The function to iterate over an array. + * @param {Function} eachFunc The function to iterate over a collection. + * @returns {Function} Returns the new each function. + */ + function createReduce(arrayFunc, eachFunc) { + return function(collection, iteratee, accumulator, thisArg) { + var initFromArray = arguments.length < 3; + return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection)) + ? arrayFunc(collection, iteratee, accumulator, initFromArray) + : baseReduce(collection, baseCallback(iteratee, thisArg, 4), accumulator, initFromArray, eachFunc); + }; + } + + module.exports = createReduce; + + +/***/ }, +/* 53 */ +/***/ function(module, exports, __webpack_require__) { + + var baseMatches = __webpack_require__(54), + baseMatchesProperty = __webpack_require__(66), + bindCallback = __webpack_require__(29), + identity = __webpack_require__(30), + property = __webpack_require__(73); + + /** + * The base implementation of `_.callback` which supports specifying the + * number of arguments to provide to `func`. + * + * @private + * @param {*} [func=_.identity] The value to convert to a callback. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {number} [argCount] The number of arguments to provide to `func`. + * @returns {Function} Returns the callback. + */ + function baseCallback(func, thisArg, argCount) { + var type = typeof func; + if (type == 'function') { + return thisArg === undefined + ? func + : bindCallback(func, thisArg, argCount); + } + if (func == null) { + return identity; + } + if (type == 'object') { + return baseMatches(func); + } + return thisArg === undefined + ? property(func) + : baseMatchesProperty(func, thisArg); + } + + module.exports = baseCallback; + + +/***/ }, +/* 54 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsMatch = __webpack_require__(55), + getMatchData = __webpack_require__(63), + toObject = __webpack_require__(41); + + /** + * The base implementation of `_.matches` which does not clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new function. + */ + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + var key = matchData[0][0], + value = matchData[0][1]; + + return function(object) { + if (object == null) { + return false; + } + return object[key] === value && (value !== undefined || (key in toObject(object))); + }; + } + return function(object) { + return baseIsMatch(object, matchData); + }; + } + + module.exports = baseMatches; + + +/***/ }, +/* 55 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqual = __webpack_require__(56), + toObject = __webpack_require__(41); + + /** + * The base implementation of `_.isMatch` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} matchData The propery names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparing objects. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ + function baseIsMatch(object, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + object = toObject(object); + while (index--) { + var data = matchData[index]; + if ((noCustomizer && data[2]) + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined && !(key in object)) { + return false; + } + } else { + var result = customizer ? customizer(objValue, srcValue, key) : undefined; + if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) { + return false; + } + } + } + return true; + } + + module.exports = baseIsMatch; + + +/***/ }, +/* 56 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqualDeep = __webpack_require__(57), + isObject = __webpack_require__(15), + isObjectLike = __webpack_require__(16); + + /** + * The base implementation of `_.isEqual` without support for `this` binding + * `customizer` functions. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparing values. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB); + } + + module.exports = baseIsEqual; + + +/***/ }, +/* 57 */ +/***/ function(module, exports, __webpack_require__) { + + var equalArrays = __webpack_require__(58), + equalByTag = __webpack_require__(60), + equalObjects = __webpack_require__(61), + isArray = __webpack_require__(23), + isTypedArray = __webpack_require__(62); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + objectTag = '[object Object]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing objects. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA=[]] Tracks traversed `value` objects. + * @param {Array} [stackB=[]] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = arrayTag, + othTag = arrayTag; + + if (!objIsArr) { + objTag = objToString.call(object); + if (objTag == argsTag) { + objTag = objectTag; + } else if (objTag != objectTag) { + objIsArr = isTypedArray(object); + } + } + if (!othIsArr) { + othTag = objToString.call(other); + if (othTag == argsTag) { + othTag = objectTag; + } else if (othTag != objectTag) { + othIsArr = isTypedArray(other); + } + } + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && !(objIsArr || objIsObj)) { + return equalByTag(object, other, objTag); + } + if (!isLoose) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB); + } + } + if (!isSameTag) { + return false; + } + // Assume cyclic values are equal. + // For more information on detecting circular references see https://es5.github.io/#JO. + stackA || (stackA = []); + stackB || (stackB = []); + + var length = stackA.length; + while (length--) { + if (stackA[length] == object) { + return stackB[length] == other; + } + } + // Add `object` and `other` to the stack of traversed objects. + stackA.push(object); + stackB.push(other); + + var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB); + + stackA.pop(); + stackB.pop(); + + return result; + } + + module.exports = baseIsEqualDeep; + + +/***/ }, +/* 58 */ +/***/ function(module, exports, __webpack_require__) { + + var arraySome = __webpack_require__(59); + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing arrays. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) { + var index = -1, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isLoose && othLength > arrLength)) { + return false; + } + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index], + result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined; + + if (result !== undefined) { + if (result) { + continue; + } + return false; + } + // Recursively compare arrays (susceptible to call stack limits). + if (isLoose) { + if (!arraySome(other, function(othValue) { + return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB); + })) { + return false; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) { + return false; + } + } + return true; + } + + module.exports = equalArrays; + + +/***/ }, +/* 59 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.some` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function arraySome(array, predicate) { + var index = -1, + length = array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + + module.exports = arraySome; + + +/***/ }, +/* 60 */ +/***/ function(module, exports) { + + /** `Object#toString` result references. */ + var boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + stringTag = '[object String]'; + + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalByTag(object, other, tag) { + switch (tag) { + case boolTag: + case dateTag: + // Coerce dates and booleans to numbers, dates to milliseconds and booleans + // to `1` or `0` treating invalid dates coerced to `NaN` as not equal. + return +object == +other; + + case errorTag: + return object.name == other.name && object.message == other.message; + + case numberTag: + // Treat `NaN` vs. `NaN` as equal. + return (object != +object) + ? other != +other + : object == +other; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings primitives and string + // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details. + return object == (other + ''); + } + return false; + } + + module.exports = equalByTag; + + +/***/ }, +/* 61 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(11); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing values. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) { + var objProps = keys(object), + objLength = objProps.length, + othProps = keys(other), + othLength = othProps.length; + + if (objLength != othLength && !isLoose) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + var skipCtor = isLoose; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key], + result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined; + + // Recursively compare objects (susceptible to call stack limits). + if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) { + return false; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (!skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + return false; + } + } + return true; + } + + module.exports = equalObjects; + + +/***/ }, +/* 62 */ +/***/ function(module, exports, __webpack_require__) { + + var isLength = __webpack_require__(20), + isObjectLike = __webpack_require__(16); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + var arrayBufferTag = '[object ArrayBuffer]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = + typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = + typedArrayTags[dateTag] = typedArrayTags[errorTag] = + typedArrayTags[funcTag] = typedArrayTags[mapTag] = + typedArrayTags[numberTag] = typedArrayTags[objectTag] = + typedArrayTags[regexpTag] = typedArrayTags[setTag] = + typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + function isTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)]; + } + + module.exports = isTypedArray; + + +/***/ }, +/* 63 */ +/***/ function(module, exports, __webpack_require__) { + + var isStrictComparable = __webpack_require__(64), + pairs = __webpack_require__(65); + + /** + * Gets the propery names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ + function getMatchData(object) { + var result = pairs(object), + length = result.length; + + while (length--) { + result[length][2] = isStrictComparable(result[length][1]); + } + return result; + } + + module.exports = getMatchData; + + +/***/ }, +/* 64 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(15); + + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + function isStrictComparable(value) { + return value === value && !isObject(value); + } + + module.exports = isStrictComparable; + + +/***/ }, +/* 65 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(11), + toObject = __webpack_require__(41); + + /** + * Creates a two dimensional array of the key-value pairs for `object`, + * e.g. `[[key1, value1], [key2, value2]]`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the new array of key-value pairs. + * @example + * + * _.pairs({ 'barney': 36, 'fred': 40 }); + * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed) + */ + function pairs(object) { + object = toObject(object); + + var index = -1, + props = keys(object), + length = props.length, + result = Array(length); + + while (++index < length) { + var key = props[index]; + result[index] = [key, object[key]]; + } + return result; + } + + module.exports = pairs; + + +/***/ }, +/* 66 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(67), + baseIsEqual = __webpack_require__(56), + baseSlice = __webpack_require__(68), + isArray = __webpack_require__(23), + isKey = __webpack_require__(69), + isStrictComparable = __webpack_require__(64), + last = __webpack_require__(70), + toObject = __webpack_require__(41), + toPath = __webpack_require__(71); + + /** + * The base implementation of `_.matchesProperty` which does not clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to compare. + * @returns {Function} Returns the new function. + */ + function baseMatchesProperty(path, srcValue) { + var isArr = isArray(path), + isCommon = isKey(path) && isStrictComparable(srcValue), + pathKey = (path + ''); + + path = toPath(path); + return function(object) { + if (object == null) { + return false; + } + var key = pathKey; + object = toObject(object); + if ((isArr || !isCommon) && !(key in object)) { + object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); + if (object == null) { + return false; + } + key = last(path); + object = toObject(object); + } + return object[key] === srcValue + ? (srcValue !== undefined || (key in object)) + : baseIsEqual(srcValue, object[key], undefined, true); + }; + } + + module.exports = baseMatchesProperty; + + +/***/ }, +/* 67 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(41); + + /** + * The base implementation of `get` without support for string paths + * and default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path of the property to get. + * @param {string} [pathKey] The key representation of path. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path, pathKey) { + if (object == null) { + return; + } + if (pathKey !== undefined && pathKey in toObject(object)) { + path = [pathKey]; + } + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[path[index++]]; + } + return (index && index == length) ? object : undefined; + } + + module.exports = baseGet; + + +/***/ }, +/* 68 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + start = start == null ? 0 : (+start || 0); + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = (end === undefined || end > length) ? length : (+end || 0); + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + module.exports = baseSlice; + + +/***/ }, +/* 69 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(23), + toObject = __webpack_require__(41); + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + var type = typeof value; + if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') { + return true; + } + if (isArray(value)) { + return false; + } + var result = !reIsDeepProp.test(value); + return result || (object != null && value in toObject(object)); + } + + module.exports = isKey; + + +/***/ }, +/* 70 */ +/***/ function(module, exports) { + + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + function last(array) { + var length = array ? array.length : 0; + return length ? array[length - 1] : undefined; + } + + module.exports = last; + + +/***/ }, +/* 71 */ +/***/ function(module, exports, __webpack_require__) { + + var baseToString = __webpack_require__(72), + isArray = __webpack_require__(23); + + /** Used to match property names within property paths. */ + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * Converts `value` to property path array if it's not one. + * + * @private + * @param {*} value The value to process. + * @returns {Array} Returns the property path array. + */ + function toPath(value) { + if (isArray(value)) { + return value; + } + var result = []; + baseToString(value).replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + } + + module.exports = toPath; + + +/***/ }, +/* 72 */ +/***/ function(module, exports) { + + /** + * Converts `value` to a string if it's not one. An empty string is returned + * for `null` or `undefined` values. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + return value == null ? '' : (value + ''); + } + + module.exports = baseToString; + + +/***/ }, +/* 73 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(19), + basePropertyDeep = __webpack_require__(74), + isKey = __webpack_require__(69); + + /** + * Creates a function that returns the property value at `path` on a + * given object. + * + * @static + * @memberOf _ + * @category Utility + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new function. + * @example + * + * var objects = [ + * { 'a': { 'b': { 'c': 2 } } }, + * { 'a': { 'b': { 'c': 1 } } } + * ]; + * + * _.map(objects, _.property('a.b.c')); + * // => [2, 1] + * + * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c'); + * // => [1, 2] + */ + function property(path) { + return isKey(path) ? baseProperty(path) : basePropertyDeep(path); + } + + module.exports = property; + + +/***/ }, +/* 74 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(67), + toPath = __webpack_require__(71); + + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new function. + */ + function basePropertyDeep(path) { + var pathKey = (path + ''); + path = toPath(path); + return function(object) { + return baseGet(object, path, pathKey); + }; + } + + module.exports = basePropertyDeep; + + +/***/ }, +/* 75 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.reduce` and `_.reduceRight` without support + * for callback shorthands and `this` binding, which iterates over `collection` + * using the provided `eachFunc`. + * + * @private + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} accumulator The initial value. + * @param {boolean} initFromCollection Specify using the first or last element + * of `collection` as the initial value. + * @param {Function} eachFunc The function to iterate over `collection`. + * @returns {*} Returns the accumulated value. + */ + function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) { + eachFunc(collection, function(value, index, collection) { + accumulator = initFromCollection + ? (initFromCollection = false, value) + : iteratee(accumulator, value, index, collection); + }); + return accumulator; + } + + module.exports = baseReduce; + + +/***/ }, +/* 76 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _leaflet = __webpack_require__(1); + + var _BaseTileLayer2 = __webpack_require__(7); + + var _BaseTileLayer3 = _interopRequireDefault(_BaseTileLayer2); + + var CanvasTileLayer = (function (_BaseTileLayer) { + _inherits(CanvasTileLayer, _BaseTileLayer); + + function CanvasTileLayer() { + _classCallCheck(this, CanvasTileLayer); + + _get(Object.getPrototypeOf(CanvasTileLayer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(CanvasTileLayer, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(CanvasTileLayer.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['map']); + + this.leafletElement = _leaflet.tileLayer.canvas(props); + } + }]); + + return CanvasTileLayer; + })(_BaseTileLayer3['default']); + + exports['default'] = CanvasTileLayer; + module.exports = exports['default']; + +/***/ }, +/* 77 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlng = __webpack_require__(6); + + var _typesLatlng2 = _interopRequireDefault(_typesLatlng); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var Circle = (function (_Path) { + _inherits(Circle, _Path); + + function Circle() { + _classCallCheck(this, Circle); + + _get(Object.getPrototypeOf(Circle.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Circle, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Circle.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var center = _props.center; + var map = _props.map; + var radius = _props.radius; + + var props = _objectWithoutProperties(_props, ['center', 'map', 'radius']); + + this.leafletElement = (0, _leaflet.circle)(center, radius, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.center !== prevProps.center) { + this.leafletElement.setLatLng(this.props.center); + } + if (this.props.radius !== prevProps.radius) { + this.leafletElement.setRadius(this.props.radius); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + center: _typesLatlng2['default'].isRequired, + radius: _react.PropTypes.number.isRequired + }, + enumerable: true + }]); + + return Circle; + })(_Path3['default']); + + exports['default'] = Circle; + module.exports = exports['default']; + +/***/ }, +/* 78 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _lodashLangIsEqual = __webpack_require__(79); + + var _lodashLangIsEqual2 = _interopRequireDefault(_lodashLangIsEqual); + + var _lodashObjectPick = __webpack_require__(80); + + var _lodashObjectPick2 = _interopRequireDefault(_lodashObjectPick); + + var _PopupContainer2 = __webpack_require__(86); + + var _PopupContainer3 = _interopRequireDefault(_PopupContainer2); + + var OPTIONS = ['stroke', 'color', 'weight', 'opacity', 'fill', 'fillColor', 'fillOpacity', 'fillRule', 'dashArray', 'lineCap', 'lineJoin', 'clickable', 'pointerEvents', 'className']; + + var Path = (function (_PopupContainer) { + _inherits(Path, _PopupContainer); + + function Path() { + _classCallCheck(this, Path); + + _get(Object.getPrototypeOf(Path.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Path, [{ + key: 'getPathOptions', + value: function getPathOptions(props) { + return (0, _lodashObjectPick2['default'])(props, OPTIONS); + } + }, { + key: 'setStyle', + value: function setStyle() { + var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + + this.leafletElement.setStyle(options); + } + }, { + key: 'setStyleIfChanged', + value: function setStyleIfChanged(fromProps, toProps) { + var nextStyle = this.getPathOptions(toProps); + if (!(0, _lodashLangIsEqual2['default'])(nextStyle, this.getPathOptions(fromProps))) { + this.setStyle(nextStyle); + } + } + }]); + + return Path; + })(_PopupContainer3['default']); + + exports['default'] = Path; + module.exports = exports['default']; + +/***/ }, +/* 79 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqual = __webpack_require__(56), + bindCallback = __webpack_require__(29); + + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. If `customizer` is provided it's invoked to compare values. + * If `customizer` returns `undefined` comparisons are handled by the method + * instead. The `customizer` is bound to `thisArg` and invoked with up to + * three arguments: (value, other [, index|key]). + * + * **Note:** This method supports comparing arrays, booleans, `Date` objects, + * numbers, `Object` objects, regexes, and strings. Objects are compared by + * their own, not inherited, enumerable properties. Functions and DOM nodes + * are **not** supported. Provide a customizer function to extend support + * for comparing other values. + * + * @static + * @memberOf _ + * @alias eq + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize value comparisons. + * @param {*} [thisArg] The `this` binding of `customizer`. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * object == other; + * // => false + * + * _.isEqual(object, other); + * // => true + * + * // using a customizer callback + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqual(array, other, function(value, other) { + * if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) { + * return true; + * } + * }); + * // => true + */ + function isEqual(value, other, customizer, thisArg) { + customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined; + var result = customizer ? customizer(value, other) : undefined; + return result === undefined ? baseIsEqual(value, other, customizer) : !!result; + } + + module.exports = isEqual; + + +/***/ }, +/* 80 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFlatten = __webpack_require__(81), + bindCallback = __webpack_require__(29), + pickByArray = __webpack_require__(83), + pickByCallback = __webpack_require__(84), + restParam = __webpack_require__(32); + + /** + * Creates an object composed of the picked `object` properties. Property + * names may be specified as individual arguments or as arrays of property + * names. If `predicate` is provided it's invoked for each property of `object` + * picking the properties `predicate` returns truthy for. The predicate is + * bound to `thisArg` and invoked with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {Function|...(string|string[])} [predicate] The function invoked per + * iteration or property names to pick, specified as individual property + * names or arrays of property names. + * @param {*} [thisArg] The `this` binding of `predicate`. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'user': 'fred', 'age': 40 }; + * + * _.pick(object, 'user'); + * // => { 'user': 'fred' } + * + * _.pick(object, _.isString); + * // => { 'user': 'fred' } + */ + var pick = restParam(function(object, props) { + if (object == null) { + return {}; + } + return typeof props[0] == 'function' + ? pickByCallback(object, bindCallback(props[0], props[1], 3)) + : pickByArray(object, baseFlatten(props)); + }); + + module.exports = pick; + + +/***/ }, +/* 81 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayPush = __webpack_require__(82), + isArguments = __webpack_require__(22), + isArray = __webpack_require__(23), + isArrayLike = __webpack_require__(17), + isObjectLike = __webpack_require__(16); + + /** + * The base implementation of `_.flatten` with added support for restricting + * flattening and specifying the start index. + * + * @private + * @param {Array} array The array to flatten. + * @param {boolean} [isDeep] Specify a deep flatten. + * @param {boolean} [isStrict] Restrict flattening to arrays-like objects. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + function baseFlatten(array, isDeep, isStrict, result) { + result || (result = []); + + var index = -1, + length = array.length; + + while (++index < length) { + var value = array[index]; + if (isObjectLike(value) && isArrayLike(value) && + (isStrict || isArray(value) || isArguments(value))) { + if (isDeep) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, isDeep, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + + module.exports = baseFlatten; + + +/***/ }, +/* 82 */ +/***/ function(module, exports) { + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + module.exports = arrayPush; + + +/***/ }, +/* 83 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(41); + + /** + * A specialized version of `_.pick` which picks `object` properties specified + * by `props`. + * + * @private + * @param {Object} object The source object. + * @param {string[]} props The property names to pick. + * @returns {Object} Returns the new object. + */ + function pickByArray(object, props) { + object = toObject(object); + + var index = -1, + length = props.length, + result = {}; + + while (++index < length) { + var key = props[index]; + if (key in object) { + result[key] = object[key]; + } + } + return result; + } + + module.exports = pickByArray; + + +/***/ }, +/* 84 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForIn = __webpack_require__(85); + + /** + * A specialized version of `_.pick` which picks `object` properties `predicate` + * returns truthy for. + * + * @private + * @param {Object} object The source object. + * @param {Function} predicate The function invoked per iteration. + * @returns {Object} Returns the new object. + */ + function pickByCallback(object, predicate) { + var result = {}; + baseForIn(object, function(value, key, object) { + if (predicate(value, key, object)) { + result[key] = value; + } + }); + return result; + } + + module.exports = pickByCallback; + + +/***/ }, +/* 85 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(39), + keysIn = __webpack_require__(25); + + /** + * The base implementation of `_.forIn` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForIn(object, iteratee) { + return baseFor(object, iteratee, keysIn); + } + + module.exports = baseForIn; + + +/***/ }, +/* 86 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _MapLayer2 = __webpack_require__(8); + + var _MapLayer3 = _interopRequireDefault(_MapLayer2); + + var PopupContainer = (function (_MapLayer) { + _inherits(PopupContainer, _MapLayer); + + function PopupContainer() { + _classCallCheck(this, PopupContainer); + + _get(Object.getPrototypeOf(PopupContainer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(PopupContainer, [{ + key: 'render', + value: function render() { + var children = this.getClonedChildrenWithMap({ + popupContainer: this.leafletElement + }); + return _react2['default'].createElement( + 'div', + { style: { display: 'none' } }, + children + ); + } + }]); + + return PopupContainer; + })(_MapLayer3['default']); + + exports['default'] = PopupContainer; + module.exports = exports['default']; + +/***/ }, +/* 87 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlng = __webpack_require__(6); + + var _typesLatlng2 = _interopRequireDefault(_typesLatlng); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var CircleMarker = (function (_Path) { + _inherits(CircleMarker, _Path); + + function CircleMarker() { + _classCallCheck(this, CircleMarker); + + _get(Object.getPrototypeOf(CircleMarker.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(CircleMarker, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(CircleMarker.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var center = _props.center; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['center', 'map']); + + this.leafletElement = (0, _leaflet.circleMarker)(center, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.center !== prevProps.center) { + this.leafletElement.setLatLng(this.props.center); + } + if (this.props.radius !== prevProps.radius) { + this.leafletElement.setRadius(this.props.radius); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + center: _typesLatlng2['default'].isRequired, + radius: _react.PropTypes.number + }, + enumerable: true + }]); + + return CircleMarker; + })(_Path3['default']); + + exports['default'] = CircleMarker; + module.exports = exports['default']; + +/***/ }, +/* 88 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var FeatureGroup = (function (_Path) { + _inherits(FeatureGroup, _Path); + + function FeatureGroup() { + _classCallCheck(this, FeatureGroup); + + _get(Object.getPrototypeOf(FeatureGroup.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(FeatureGroup, [{ + key: 'componentWillMount', + value: function componentWillMount() { + var _props = this.props; + var layers = _props.layers; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['layers', 'map']); + + this.leafletElement = (0, _leaflet.featureGroup)(layers); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + layers: _react.PropTypes.array.isRequired + }, + enumerable: true + }]); + + return FeatureGroup; + })(_Path3['default']); + + exports['default'] = FeatureGroup; + module.exports = exports['default']; + +/***/ }, +/* 89 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var GeoJson = (function (_Path) { + _inherits(GeoJson, _Path); + + function GeoJson() { + _classCallCheck(this, GeoJson); + + _get(Object.getPrototypeOf(GeoJson.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(GeoJson, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(GeoJson.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var data = _props.data; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['data', 'map']); + + this.leafletElement = (0, _leaflet.geoJson)(data, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + data: _react.PropTypes.object.isRequired + }, + enumerable: true + }]); + + return GeoJson; + })(_Path3['default']); + + exports['default'] = GeoJson; + module.exports = exports['default']; + +/***/ }, +/* 90 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesBounds = __webpack_require__(3); + + var _typesBounds2 = _interopRequireDefault(_typesBounds); + + var _MapLayer2 = __webpack_require__(8); + + var _MapLayer3 = _interopRequireDefault(_MapLayer2); + + var ImageOverlay = (function (_MapLayer) { + _inherits(ImageOverlay, _MapLayer); + + function ImageOverlay() { + _classCallCheck(this, ImageOverlay); + + _get(Object.getPrototypeOf(ImageOverlay.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(ImageOverlay, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(ImageOverlay.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var bounds = _props.bounds; + var map = _props.map; + var url = _props.url; + + var props = _objectWithoutProperties(_props, ['bounds', 'map', 'url']); + + this.leafletElement = (0, _leaflet.imageOverlay)(url, bounds, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.url !== prevProps.url) { + this.leafletElement.setUrl(this.props.url); + } + if (this.props.opacity !== prevProps.opacity) { + this.leafletElement.setOpacity(this.props.opacity); + } + } + }, { + key: 'render', + value: function render() { + return null; + } + }], [{ + key: 'propTypes', + value: { + attribution: _react.PropTypes.string, + bounds: _typesBounds2['default'].isRequired, + map: _react.PropTypes.instanceOf(_leaflet.Map), + opacity: _react.PropTypes.number, + url: _react.PropTypes.string.isRequired + }, + enumerable: true + }]); + + return ImageOverlay; + })(_MapLayer3['default']); + + exports['default'] = ImageOverlay; + module.exports = exports['default']; + +/***/ }, +/* 91 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _leaflet = __webpack_require__(1); + + var _MapLayer2 = __webpack_require__(8); + + var _MapLayer3 = _interopRequireDefault(_MapLayer2); + + var LayerGroup = (function (_MapLayer) { + _inherits(LayerGroup, _MapLayer); + + function LayerGroup() { + _classCallCheck(this, LayerGroup); + + _get(Object.getPrototypeOf(LayerGroup.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(LayerGroup, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(LayerGroup.prototype), 'componentWillMount', this).call(this); + this.leafletElement = (0, _leaflet.layerGroup)(); + } + }, { + key: 'render', + value: function render() { + var _this = this; + + var children = _react2['default'].Children.map(this.props.children, function (child) { + return child ? _react2['default'].cloneElement(child, { + layerGroup: _this.leafletElement, + map: _this.props.map + }) : null; + }); + + return _react2['default'].createElement( + 'div', + { style: { display: 'none' } }, + children + ); + } + }], [{ + key: 'propTypes', + value: { + children: _react.PropTypes.oneOfType([_react.PropTypes.arrayOf(_react.PropTypes.node), _react.PropTypes.node]), + map: _react.PropTypes.instanceOf(_leaflet.Map) + }, + enumerable: true + }]); + + return LayerGroup; + })(_MapLayer3['default']); + + exports['default'] = LayerGroup; + module.exports = exports['default']; + +/***/ }, +/* 92 */ +/***/ function(module, exports, __webpack_require__) { + + /* eslint-disable react/no-did-mount-set-state */ + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _lodashLangIsArray = __webpack_require__(23); + + var _lodashLangIsArray2 = _interopRequireDefault(_lodashLangIsArray); + + var _lodashLangIsUndefined = __webpack_require__(93); + + var _lodashLangIsUndefined2 = _interopRequireDefault(_lodashLangIsUndefined); + + var _lodashUtilityUniqueId = __webpack_require__(94); + + var _lodashUtilityUniqueId2 = _interopRequireDefault(_lodashUtilityUniqueId); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _leaflet = __webpack_require__(1); + + var _leaflet2 = _interopRequireDefault(_leaflet); + + var _typesBounds = __webpack_require__(3); + + var _typesBounds2 = _interopRequireDefault(_typesBounds); + + var _typesLatlng = __webpack_require__(6); + + var _typesLatlng2 = _interopRequireDefault(_typesLatlng); + + var _MapComponent2 = __webpack_require__(33); + + var _MapComponent3 = _interopRequireDefault(_MapComponent2); + + var normalizeCenter = function normalizeCenter(pos) { + return (0, _lodashLangIsArray2['default'])(pos) ? pos : [pos.lat, pos.lng || pos.lon]; + }; + + var Map = (function (_MapComponent) { + _inherits(Map, _MapComponent); + + _createClass(Map, null, [{ + key: 'propTypes', + value: { + bounds: _typesBounds2['default'], + center: _typesLatlng2['default'], + children: _react.PropTypes.oneOfType([_react.PropTypes.arrayOf(_react.PropTypes.node), _react.PropTypes.node]), + className: _react.PropTypes.string, + id: _react.PropTypes.string, + maxBounds: _typesBounds2['default'], + maxZoom: _react.PropTypes.number, + minZoom: _react.PropTypes.number, + style: _react.PropTypes.object, + zoom: _react.PropTypes.number + }, + enumerable: true + }]); + + function Map(props) { + _classCallCheck(this, Map); + + _get(Object.getPrototypeOf(Map.prototype), 'constructor', this).call(this, props); + this.state = { + id: props.id || (0, _lodashUtilityUniqueId2['default'])('map') + }; + } + + _createClass(Map, [{ + key: 'componentDidMount', + value: function componentDidMount() { + this.leafletElement = _leaflet2['default'].map(this.state.id, this.props); + _get(Object.getPrototypeOf(Map.prototype), 'componentDidMount', this).call(this); + this.setState({ map: this.leafletElement }); + if (!(0, _lodashLangIsUndefined2['default'])(this.props.bounds)) { + this.leafletElement.fitBounds(this.props.bounds); + } + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + var _props = this.props; + var bounds = _props.bounds; + var center = _props.center; + var maxBounds = _props.maxBounds; + var zoom = _props.zoom; + + if (center && this.shouldUpdateCenter(center, prevProps.center)) { + this.leafletElement.setView(center, zoom, { animate: false }); + } else if (zoom && zoom !== prevProps.zoom) { + this.leafletElement.setZoom(zoom); + } + if (maxBounds && this.shouldUpdateBounds(maxBounds, prevProps.maxBounds)) { + this.leafletElement.setMaxBounds(maxBounds); + } + if (bounds && this.shouldUpdateBounds(bounds, prevProps.bounds)) { + this.leafletElement.fitBounds(bounds); + } + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + _get(Object.getPrototypeOf(Map.prototype), 'componentWillUnmount', this).call(this); + this.leafletElement.remove(); + } + }, { + key: 'shouldUpdateCenter', + value: function shouldUpdateCenter(next, prev) { + if (!prev) return true; + next = normalizeCenter(next); + prev = normalizeCenter(prev); + return next[0] !== prev[0] || next[1] !== prev[1]; + } + }, { + key: 'shouldUpdateBounds', + value: function shouldUpdateBounds(next, prev) { + if (!prev) return true; + next = _leaflet2['default'].latLngBounds(next); + prev = _leaflet2['default'].latLngBounds(prev); + return !next.equals(prev); + } + }, { + key: 'render', + value: function render() { + var map = this.leafletElement; + var children = map ? _react2['default'].Children.map(this.props.children, function (child) { + return child ? _react2['default'].cloneElement(child, { map: map }) : null; + }) : null; + + return _react2['default'].createElement( + 'div', + { + className: this.props.className, + id: this.state.id, + style: this.props.style }, + children + ); + } + }]); + + return Map; + })(_MapComponent3['default']); + + exports['default'] = Map; + module.exports = exports['default']; + +/***/ }, +/* 93 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is `undefined`. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. + * @example + * + * _.isUndefined(void 0); + * // => true + * + * _.isUndefined(null); + * // => false + */ + function isUndefined(value) { + return value === undefined; + } + + module.exports = isUndefined; + + +/***/ }, +/* 94 */ +/***/ function(module, exports, __webpack_require__) { + + var baseToString = __webpack_require__(72); + + /** Used to generate unique IDs. */ + var idCounter = 0; + + /** + * Generates a unique ID. If `prefix` is provided the ID is appended to it. + * + * @static + * @memberOf _ + * @category Utility + * @param {string} [prefix] The value to prefix the ID with. + * @returns {string} Returns the unique ID. + * @example + * + * _.uniqueId('contact_'); + * // => 'contact_104' + * + * _.uniqueId(); + * // => '105' + */ + function uniqueId(prefix) { + var id = ++idCounter; + return baseToString(prefix) + id; + } + + module.exports = uniqueId; + + +/***/ }, +/* 95 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlng = __webpack_require__(6); + + var _typesLatlng2 = _interopRequireDefault(_typesLatlng); + + var _PopupContainer2 = __webpack_require__(86); + + var _PopupContainer3 = _interopRequireDefault(_PopupContainer2); + + var Marker = (function (_PopupContainer) { + _inherits(Marker, _PopupContainer); + + function Marker() { + _classCallCheck(this, Marker); + + _get(Object.getPrototypeOf(Marker.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Marker, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Marker.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var position = _props.position; + + var props = _objectWithoutProperties(_props, ['map', 'position']); + + this.leafletElement = (0, _leaflet.marker)(position, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.position !== prevProps.position) { + this.leafletElement.setLatLng(this.props.position); + } + if (this.props.icon !== prevProps.icon) { + this.leafletElement.setIcon(this.props.icon); + } + if (this.props.zIndexOffset !== prevProps.zIndexOffset) { + this.leafletElement.setZIndexOffset(this.props.zIndexOffset); + } + if (this.props.opacity !== prevProps.opacity) { + this.leafletElement.setOpacity(this.props.opacity); + } + } + }], [{ + key: 'propTypes', + value: { + icon: _react.PropTypes.instanceOf(_leaflet.Icon), + opacity: _react.PropTypes.number, + position: _typesLatlng2['default'].isRequired, + zIndexOffset: _react.PropTypes.number + }, + enumerable: true + }]); + + return Marker; + })(_PopupContainer3['default']); + + exports['default'] = Marker; + module.exports = exports['default']; + +/***/ }, +/* 96 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlngList = __webpack_require__(5); + + var _typesLatlngList2 = _interopRequireDefault(_typesLatlngList); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var MultiPolygon = (function (_Path) { + _inherits(MultiPolygon, _Path); + + function MultiPolygon() { + _classCallCheck(this, MultiPolygon); + + _get(Object.getPrototypeOf(MultiPolygon.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(MultiPolygon, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(MultiPolygon.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var polygons = _props.polygons; + + var props = _objectWithoutProperties(_props, ['map', 'polygons']); + + this.leafletElement = (0, _leaflet.multiPolygon)(polygons, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.polygons !== prevProps.polygons) { + this.leafletElement.setLatLngs(this.props.polygons); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + polygons: _react.PropTypes.arrayOf(_typesLatlngList2['default']).isRequired + }, + enumerable: true + }]); + + return MultiPolygon; + })(_Path3['default']); + + exports['default'] = MultiPolygon; + module.exports = exports['default']; + +/***/ }, +/* 97 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlngList = __webpack_require__(5); + + var _typesLatlngList2 = _interopRequireDefault(_typesLatlngList); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var MultiPolyline = (function (_Path) { + _inherits(MultiPolyline, _Path); + + function MultiPolyline() { + _classCallCheck(this, MultiPolyline); + + _get(Object.getPrototypeOf(MultiPolyline.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(MultiPolyline, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(MultiPolyline.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var polylines = _props.polylines; + + var props = _objectWithoutProperties(_props, ['map', 'polylines']); + + this.leafletElement = (0, _leaflet.multiPolyline)(polylines, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.polylines !== prevProps.polylines) { + this.leafletElement.setLatLngs(this.props.polylines); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + polylines: _react.PropTypes.arrayOf(_typesLatlngList2['default']).isRequired + }, + enumerable: true + }]); + + return MultiPolyline; + })(_Path3['default']); + + exports['default'] = MultiPolyline; + module.exports = exports['default']; + +/***/ }, +/* 98 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _typesLatlngList = __webpack_require__(5); + + var _typesLatlngList2 = _interopRequireDefault(_typesLatlngList); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var Polygon = (function (_Path) { + _inherits(Polygon, _Path); + + function Polygon() { + _classCallCheck(this, Polygon); + + _get(Object.getPrototypeOf(Polygon.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Polygon, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Polygon.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var positions = _props.positions; + + var props = _objectWithoutProperties(_props, ['map', 'positions']); + + this.leafletElement = (0, _leaflet.polygon)(positions, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.positions !== prevProps.positions) { + this.leafletElement.setLatLngs(this.props.positions); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + positions: _react.PropTypes.oneOfType([_typesLatlngList2['default'], _react.PropTypes.arrayOf(_typesLatlngList2['default'])]).isRequired + }, + enumerable: true + }]); + + return Polygon; + })(_Path3['default']); + + exports['default'] = Polygon; + module.exports = exports['default']; + +/***/ }, +/* 99 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _leaflet = __webpack_require__(1); + + var _typesLatlngList = __webpack_require__(5); + + var _typesLatlngList2 = _interopRequireDefault(_typesLatlngList); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var Polyline = (function (_Path) { + _inherits(Polyline, _Path); + + function Polyline() { + _classCallCheck(this, Polyline); + + _get(Object.getPrototypeOf(Polyline.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Polyline, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Polyline.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var positions = _props.positions; + + var props = _objectWithoutProperties(_props, ['map', 'positions']); + + this.leafletElement = (0, _leaflet.polyline)(positions, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.positions !== prevProps.positions) { + this.leafletElement.setLatLngs(this.props.positions); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + positions: _typesLatlngList2['default'].isRequired + }, + enumerable: true + }]); + + return Polyline; + })(_Path3['default']); + + exports['default'] = Polyline; + module.exports = exports['default']; + +/***/ }, +/* 100 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _reactDom = __webpack_require__(101); + + var _leaflet = __webpack_require__(1); + + var _typesLatlng = __webpack_require__(6); + + var _typesLatlng2 = _interopRequireDefault(_typesLatlng); + + var _MapComponent2 = __webpack_require__(33); + + var _MapComponent3 = _interopRequireDefault(_MapComponent2); + + var Popup = (function (_MapComponent) { + _inherits(Popup, _MapComponent); + + function Popup() { + _classCallCheck(this, Popup); + + _get(Object.getPrototypeOf(Popup.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Popup, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Popup.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var children = _props.children; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['children', 'map']); + + this.leafletElement = (0, _leaflet.popup)(props); + this.leafletElement.on('open', this.renderPopupContent.bind(this)); + this.leafletElement.on('close', this.removePopupContent.bind(this)); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + var _props2 = this.props; + var map = _props2.map; + var popupContainer = _props2.popupContainer; + var position = _props2.position; + + var el = this.leafletElement; + + if (popupContainer) { + // Attach to container component + popupContainer.bindPopup(el); + } else { + // Attach to a Map + if (position) { + el.setLatLng(position); + } + el.openOn(map); + } + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + var position = this.props.position; + + if (position !== prevProps.position) { + this.leafletElement.setLatLng(position); + } + + if (this.leafletElement._isOpen) { + this.renderPopupContent(); + } + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + _get(Object.getPrototypeOf(Popup.prototype), 'componentWillUnmount', this).call(this); + this.removePopupContent(); + this.props.map.removeLayer(this.leafletElement); + } + }, { + key: 'renderPopupContent', + value: function renderPopupContent() { + if (this.props.children) { + (0, _reactDom.render)(_react.Children.only(this.props.children), this.leafletElement._contentNode); + + this.leafletElement._updateLayout(); + this.leafletElement._updatePosition(); + this.leafletElement._adjustPan(); + } else { + this.removePopupContent(); + } + } + }, { + key: 'removePopupContent', + value: function removePopupContent() { + if (this.leafletElement._contentNode) { + (0, _reactDom.unmountComponentAtNode)(this.leafletElement._contentNode); + } + } + }, { + key: 'render', + value: function render() { + return null; + } + }], [{ + key: 'propTypes', + value: { + children: _react.PropTypes.node, + map: _react.PropTypes.instanceOf(_leaflet.Map), + popupContainer: _react.PropTypes.object, + position: _typesLatlng2['default'] + }, + enumerable: true + }]); + + return Popup; + })(_MapComponent3['default']); + + exports['default'] = Popup; + module.exports = exports['default']; + +/***/ }, +/* 101 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_101__; + +/***/ }, +/* 102 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _leaflet = __webpack_require__(1); + + var _typesBounds = __webpack_require__(3); + + var _typesBounds2 = _interopRequireDefault(_typesBounds); + + var _Path2 = __webpack_require__(78); + + var _Path3 = _interopRequireDefault(_Path2); + + var Rectangle = (function (_Path) { + _inherits(Rectangle, _Path); + + function Rectangle() { + _classCallCheck(this, Rectangle); + + _get(Object.getPrototypeOf(Rectangle.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(Rectangle, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(Rectangle.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var bounds = _props.bounds; + var map = _props.map; + + var props = _objectWithoutProperties(_props, ['bounds', 'map']); + + this.leafletElement = (0, _leaflet.rectangle)(bounds, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + if (this.props.bounds !== prevProps.bounds) { + this.leafletElement.setBounds(this.props.bounds); + } + this.setStyleIfChanged(prevProps, this.props); + } + }], [{ + key: 'propTypes', + value: { + bounds: _typesBounds2['default'].isRequired + }, + enumerable: true + }]); + + return Rectangle; + })(_Path3['default']); + + exports['default'] = Rectangle; + module.exports = exports['default']; + +/***/ }, +/* 103 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _BaseTileLayer2 = __webpack_require__(7); + + var _BaseTileLayer3 = _interopRequireDefault(_BaseTileLayer2); + + var TileLayer = (function (_BaseTileLayer) { + _inherits(TileLayer, _BaseTileLayer); + + function TileLayer() { + _classCallCheck(this, TileLayer); + + _get(Object.getPrototypeOf(TileLayer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(TileLayer, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(TileLayer.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var url = _props.url; + + var props = _objectWithoutProperties(_props, ['map', 'url']); + + this.leafletElement = (0, _leaflet.tileLayer)(url, props); + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate(prevProps) { + var url = this.props.url; + + if (url && url !== prevProps.url) { + this.leafletElement.setUrl(url); + } + } + }], [{ + key: 'propTypes', + value: { + url: _react.PropTypes.string.isRequired + }, + enumerable: true + }]); + + return TileLayer; + })(_BaseTileLayer3['default']); + + exports['default'] = TileLayer; + module.exports = exports['default']; + +/***/ }, +/* 104 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true + }); + + var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + + var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _react = __webpack_require__(4); + + var _leaflet = __webpack_require__(1); + + var _BaseTileLayer2 = __webpack_require__(7); + + var _BaseTileLayer3 = _interopRequireDefault(_BaseTileLayer2); + + var WMSTileLayer = (function (_BaseTileLayer) { + _inherits(WMSTileLayer, _BaseTileLayer); + + function WMSTileLayer() { + _classCallCheck(this, WMSTileLayer); + + _get(Object.getPrototypeOf(WMSTileLayer.prototype), 'constructor', this).apply(this, arguments); + } + + _createClass(WMSTileLayer, [{ + key: 'componentWillMount', + value: function componentWillMount() { + _get(Object.getPrototypeOf(WMSTileLayer.prototype), 'componentWillMount', this).call(this); + var _props = this.props; + var map = _props.map; + var url = _props.url; + + var props = _objectWithoutProperties(_props, ['map', 'url']); + + this.leafletElement = _leaflet.tileLayer.wms(url, props); + } + }], [{ + key: 'propTypes', + value: { + url: _react.PropTypes.string.isRequired + }, + enumerable: true + }]); + + return WMSTileLayer; + })(_BaseTileLayer3['default']); + + exports['default'] = WMSTileLayer; + module.exports = exports['default']; + +/***/ } +/******/ ]) +}); +; \ No newline at end of file diff --git a/dist/react-leaflet.min.js b/dist/react-leaflet.min.js new file mode 100644 index 00000000..f2e91ba0 --- /dev/null +++ b/dist/react-leaflet.min.js @@ -0,0 +1,2 @@ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("react"),require("leaflet"),require("react-dom")):"function"==typeof define&&define.amd?define(["react","leaflet","react-dom"],e):"object"==typeof exports?exports.ReactLeaflet=e(require("react"),require("leaflet"),require("react-dom")):t.ReactLeaflet=e(t.React,t.L,t.ReactDOM)}(this,function(t,e,r){return function(t){function e(n){if(r[n])return r[n].exports;var o=r[n]={exports:{},id:n,loaded:!1};return t[n].call(o.exports,o,o.exports,e),o.loaded=!0,o.exports}var r={};return e.m=t,e.c=r,e.p="",e(0)}([function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{"default":t}}Object.defineProperty(e,"__esModule",{value:!0});var o=r(2),u=n(o),i=r(56),a=n(i);e.PropTypes=a["default"];var l=r(14),c=n(l);e.BaseTileLayer=c["default"];var p=r(39),f=n(p);e.CanvasTileLayer=f["default"];var s=r(40),y=n(s);e.Circle=y["default"];var v=r(41),d=n(v);e.CircleMarker=d["default"];var b=r(42),h=n(b);e.FeatureGroup=h["default"];var O=r(43),m=n(O);e.GeoJson=m["default"];var g=r(44),j=n(g);e.ImageOverlay=j["default"];var P=r(45),_=n(P);e.LayerGroup=_["default"];var w=r(46),x=n(w);e.Map=x["default"];var E=r(15),T=n(E);e.MapComponent=T["default"];var M=r(13),k=n(M);e.MapLayer=k["default"];var C=r(47),D=n(C);e.Marker=D["default"];var L=r(48),A=n(L);e.MultiPolygon=A["default"];var S=r(49),W=n(S);e.MultiPolyline=W["default"];var U=r(4),I=n(U);e.Path=I["default"];var F=r(50),R=n(F);e.Polygon=R["default"];var q=r(51),B=n(q);e.Polyline=B["default"];var N=r(52),z=n(N);e.Popup=z["default"];var $=r(18),G=n($);e.PopupContainer=G["default"];var Z=r(53),J=n(Z);e.Rectangle=J["default"];var V=r(54),H=n(V);e.TileLayer=H["default"];var K=r(55),Q=n(K);e.WMSTileLayer=Q["default"];var X=function(t){u["default"].Icon.Default.imagePath=t};e.setIconDefaultImagePath=X,X("//cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.5/images")},function(e,r){e.exports=t},function(t,r){t.exports=e},function(t,e,r){var n=r(32),o=r(10),u=r(11),i="[object Array]",a=Object.prototype,l=a.toString,c=n(Array,"isArray"),p=c||function(t){return u(t)&&o(t.length)&&l.call(t)==i};t.exports=p},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{"default":t}}function o(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function u(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var i=function(){function t(t,e){for(var r=0;r-1&&t%1==0&&n>=t}var n=9007199254740991;t.exports=r},function(t,e){function r(t){return!!t&&"object"==typeof t}t.exports=r},function(t,e,r){var n=r(32),o=r(17),u=r(6),i=r(92),a=n(Object,"keys"),l=a?function(t){var e=null==t?void 0:t.constructor;return"function"==typeof e&&e.prototype===t||"function"!=typeof t&&o(t)?i(t):u(t)?a(t):[]}:i;t.exports=l},function(t,e,r){"use strict";function n(t){return t&&t.__esModule?t:{"default":t}}function o(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function u(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var i=function(){function t(t,e){for(var r=0;r-1&&t%1==0&&e>t}var n=/^\d+$/,o=9007199254740991;t.exports=r},function(t,e,r){function n(t){return u(t)&&o(t)&&a.call(t,"callee")&&!l.call(t,"callee")}var o=r(17),u=r(11),i=Object.prototype,a=i.hasOwnProperty,l=i.propertyIsEnumerable;t.exports=n},function(t,e){function r(t,e){if("function"!=typeof t)throw new TypeError(n);return e=o(void 0===e?t.length-1:+e||0,0),function(){for(var r=arguments,n=-1,u=o(r.length-e,0),i=Array(u);++nn;)t=t[e[n++]];return n&&n==u?t:void 0}}var o=r(5);t.exports=n},function(t,e){function r(t){return function(e){return null==e?void 0:e[t]}}t.exports=r},function(t,e){function r(t){return null==t?"":t+""}t.exports=r},function(t,e,r){var n=r(29),o=n("length");t.exports=o},function(t,e,r){function n(t,e){var r=null==t?void 0:t[e];return o(r)?r:void 0}var o=r(96);t.exports=n},function(t,e,r){function n(t,e,r){if(!i(r))return!1;var n=typeof e;if("number"==n?o(r)&&u(e,r.length):"string"==n&&e in r){var a=r[e];return t===t?t===a:a!==a}return!1}var o=r(17),u=r(20),i=r(6);t.exports=n},function(t,e,r){function n(t,e){var r=typeof t;if("string"==r&&a.test(t)||"number"==r)return!0;if(o(t))return!1;var n=!i.test(t);return n||null!=e&&t in u(e)}var o=r(3),u=r(5),i=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/,a=/^\w*$/;t.exports=n},function(t,e,r){function n(t){return t===t&&!o(t)}var o=r(6);t.exports=n},function(t,e,r){function n(t){if(u(t))return t;var e=[];return o(t).replace(i,function(t,r,n,o){e.push(n?o.replace(a,"$1"):r||t)}),e}var o=r(30),u=r(3),i=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g,a=/\\(\\)?/g;t.exports=n},function(t,e,r){function n(t){if(null==t)return[];l(t)||(t=Object(t));var e=t.length;e=e&&a(e)&&(u(t)||o(t))&&e||0;for(var r=t.constructor,n=-1,c="function"==typeof r&&r.prototype===t,f=Array(e),s=e>0;++n=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;r=0||Object.prototype.hasOwnProperty.call(t,n)&&(r[n]=t[n]);return r}function u(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function i(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(t,e):t.__proto__=e)}Object.defineProperty(e,"__esModule",{value:!0});var a=function(){function t(t,e){for(var r=0;re&&(e=-e>o?0:o+e),r=void 0===r||r>o?o:+r||0,0>r&&(r+=o),o=e>r?0:r-e>>>0,e>>>=0;for(var u=Array(o);++n2?r[i-2]:void 0,l=i>2?r[2]:void 0,c=i>1?r[i-1]:void 0;for("function"==typeof a?(a=o(a,c,5),i-=2):(a="function"==typeof c?c:void 0,i-=a?1:0),l&&u(r[0],r[1],l)&&(a=3>i?void 0:a,i=1);++nc))return!1;for(;++l/node_modules/babel-jest", diff --git a/webpack.config.js b/webpack.config.js new file mode 100644 index 00000000..697e65c0 --- /dev/null +++ b/webpack.config.js @@ -0,0 +1,38 @@ +/* eslint-disable */ +module.exports = { + output: { + library: 'ReactLeaflet', + libraryTarget: 'umd' + }, + externals: [ + { + leaflet: { + amd: 'leaflet', + commonjs: 'leaflet', + commonjs2: 'leaflet', + root: 'L' + } + }, + { + react: { + amd: 'react', + commonjs: 'react', + commonjs2: 'react', + root: 'React' + } + }, + { + 'react-dom': { + amd: 'react-dom', + commonjs: 'react-dom', + commonjs2: 'react-dom', + root: 'ReactDOM' + } + } + ], + module: { + loaders: [ + {test: /\.js$/, exclude: /node_modules/, loader: 'babel'} + ] + } +};