https://mrsale.hu/wp-content/plugins/hungarian-pickup-points-for-w…/assets/js/frontend.min.js?ver=4.2.8

1139	'GS': [47.6404, 17.3863],
1140	'HB': [47.4835, 21.6140],
1141	'HE': [47.8131, 20.1920],
1142	'JN': [47.2266, 20.5014],
1143	'KE': [47.6198, 18.3420],
1144	'NO': [48.0130, 19.5863],
1145	'SO': [46.4838, 17.6299],
1146	'SZ': [48.0260, 22.1060],
1147	'TO': [46.5258, 18.5796],
1148	'VE': [47.1683, 17.7088],
1149	'ZA': [46.6823, 16.9070]
1150};
1151const vp_woo_pont_country_coordinates = {
1152	'CZ': [49.8509, 15.6689],
1153	'SK': [48.8394, 19.8575],
1154	'RO': [45.9280, 24.8392],
1155	'PL': [52.1721, 19.3782],
1156	'DE': [51.1657, 10.4515],
1157	'AT': [47.5162, 14.5501],
1158	'SI': [46.1512, 14.9955],
1159	'HR': [45.1000, 15.2000],
1160	'BA': [44.0000, 18.0000],
1161	'RS': [44.0165, 21.0059],
1162	'UA': [48.3794, 31.1656],
1163	'BG': [42.7339, 25.4858],
1164	'HR': [45.1000, 15.2000],
1165	'IT': [41.8719, 12.5674],
1166	'CH': [46.8182, 8.2275],
1167	'LI': [47.1660, 9.5554],
1168	'MK': [41.6086, 21.7453],
1169	'AL': [41.1533, 20.1683],
1170	'ME': [42.7087, 19.3744],
1171	'XK': [42.6026, 20.9020],
1172	'GR': [39.0742, 21.8243],
1173	'TR': [38.9637, 35.2433],
1174	'MD': [47.4116, 28.3699],
1175	'BY': [53.7098, 27.9534],
1176	'RU': [61.5240, 105.3188],
1177	'LT': [55.1694, 23.8813],
1178	'LV': [56.8796, 24.6032],
1179	'EE': [58.5953, 25.0136],
1180	'FI': [61.9241, 25.7482],
1181	'NO': [60.4720, 8.4689],
1182	'SE': [60.1282, 18.6435],
1183	'DK': [56.2639, 9.5018],
1184	'FR': [46.6034, 1.8883],
1185	'NL': [52.1326, 5.2913],
1186	'LU': [49.8153, 6.1296],
1187	'PT': [39.3999, -8.2245],
1188	'IE': [53.4129, -8.2439],
1189}
1190
1191module.exports = {
1192	vp_woo_pont_state_postcodes,
1193    vp_woo_pont_state_coordinates,
1194    vp_woo_pont_country_coordinates,
1195};
1196},{}],3:[function(require,module,exports){
1197!function(e,o){if("function"==typeof define&&define.amd)define(["exports"],o);else if("undefined"!=typeof exports)o(exports);else{var t={};o(t),e.bodyScrollLock=t}}(this,function(exports){"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=!1;if("undefined"!=typeof window){var e={get passive(){t=!0}};window.addEventListener("testPassive",null,e),window.removeEventListener("testPassive",null,e)}var n="undefined"!=typeof window&&window.navigator&&window.navigator.platform&&(/iP(ad|hone|od)/.test(window.navigator.platform)||"MacIntel"===window.navigator.platform&&1<window.navigator.maxTouchPoints),i=[],d=!1,l=-1,c=void 0,s=void 0,u=void 0,a=function(o){return i.some(function(e){return!(!e.options.allowTouchMove||!e.options.allowTouchMove(o))})},v=function(e){var o=e||window.event;return!!a(o.target)||(1<o.touches.length||(o.preventDefault&&o.preventDefault(),!1))},r=function(){void 0!==u&&(document.body.style.paddingRight=u,u=void 0),void 0!==c&&(document.body.style.overflow=c,c=void 0)},f=function(){if(void 0!==s){var e=-parseInt(document.body.style.top,10),o=-parseInt(document.body.style.left,10);document.body.style.position=s.position,document.body.style.top=s.top,document.body.style.left=s.left,window.scrollTo(o,e),s=void 0}};exports.disableBodyScroll=function(r,e){if(r){if(!i.some(function(e){return e.targetElement===r})){var o={targetElement:r,options:e||{}};i=[].concat(function(e){if(Array.isArray(e)){for(var o=0,t=Array(e.length);o<e.length;o++)t[o]=e[o];return t}return Array.from(e)}(i),[o]),n?window.requestAnimationFrame(function(){if(void 0===s){s={position:document.body.style.position,top:document.body.style.top,left:document.body.style.left};var e=window,o=e.scrollY,t=e.scrollX,n=e.innerHeight;document.body.style.position="fixed",document.body.style.top=-o,document.body.style.left=-t,setTimeout(function(){return window.requestAnimationFrame(function(){var e=n-window.innerHeight;e&&n<=o&&(document.body.style.top=-(o+e))})},300)}}):function(e){if(void 0===u){var o=!!e&&!0===e.reserveScrollBarGap,t=window.innerWidth-document.documentElement.clientWidth;if(o&&0<t){var n=parseInt(window.getComputedStyle(document.body).getPropertyValue("padding-right"),10);u=document.body.style.paddingRight,document.body.style.paddingRight=n+t+"px"}}void 0===c&&(c=document.body.style.overflow,document.body.style.overflow="hidden")}(e),n&&(r.ontouchstart=function(e){1===e.targetTouches.length&&(l=e.targetTouches[0].clientY)},r.ontouchmove=function(e){var o,t,n,i;1===e.targetTouches.length&&(t=r,i=(o=e).targetTouches[0].clientY-l,!a(o.target)&&(t&&0===t.scrollTop&&0<i?v(o):(n=t)&&n.scrollHeight-n.scrollTop<=n.clientHeight&&i<0?v(o):o.stopPropagation()))},d||(document.addEventListener("touchmove",v,t?{passive:!1}:void 0),d=!0))}}else console.error("disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.")},exports.clearAllBodyScrollLocks=function(){n&&(i.forEach(function(e){e.targetElement.ontouchstart=null,e.targetElement.ontouchmove=null}),d&&(document.removeEventListener("touchmove",v,t?{passive:!1}:void 0),d=!1),l=-1),n?f():r(),i=[]},exports.enableBodyScroll=function(o){o?(i=i.filter(function(e){return e.targetElement!==o}),n&&(o.ontouchstart=null,o.ontouchmove=null,d&&0===i.length&&(document.removeEventListener("touchmove",v,t?{passive:!1}:void 0),d=!1)),n?f():r()):console.error("enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.")}});
1198
1199},{}],4:[function(require,module,exports){

1200(function (global, factory) {
1201  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
1202  typeof define === 'function' && define.amd ? define(['exports'], factory) :
1203  (global = global || self, factory(global.JsSearch = {}));
1204}(this, (function (exports) { 'use strict';
1205
1206  /**
1207   * Indexes for all substring searches (e.g. the term "cat" is indexed as "c", "ca", "cat", "a", "at", and "t").
1208   */
1209  var AllSubstringsIndexStrategy = /*#__PURE__*/function () {
1210    function AllSubstringsIndexStrategy() {}
1211
1212    var _proto = AllSubstringsIndexStrategy.prototype;
1213
1214    /**
1215     * @inheritDocs
1216     */
1217    _proto.expandToken = function expandToken(token) {
1218      var expandedTokens = [];
1219      var string;
1220
1221      for (var i = 0, length = token.length; i < length; ++i) {
1222        string = '';
1223
1224        for (var j = i; j < length; ++j) {
1225          string += token.charAt(j);
1226          expandedTokens.push(string);
1227        }
1228      }
1229
1230      return expandedTokens;
1231    };
1232
1233    return AllSubstringsIndexStrategy;
1234  }();
1235
1236  /**
1237   * Indexes for exact word matches.
1238   */
1239  var ExactWordIndexStrategy = /*#__PURE__*/function () {
1240    function ExactWordIndexStrategy() {}
1241
1242    var _proto = ExactWordIndexStrategy.prototype;
1243
1244    /**
1245     * @inheritDocs
1246     */
1247    _proto.expandToken = function expandToken(token) {
1248      return token ? [token] : [];
1249    };
1250
1251    return ExactWordIndexStrategy;
1252  }();
1253
1254  /**
1255   * Indexes for prefix searches (e.g. the term "cat" is indexed as "c", "ca", and "cat" allowing prefix search lookups).
1256   */
1257  var PrefixIndexStrategy = /*#__PURE__*/function () {
1258    function PrefixIndexStrategy() {}
1259
1260    var _proto = PrefixIndexStrategy.prototype;
1261
1262    /**
1263     * @inheritDocs
1264     */
1265    _proto.expandToken = function expandToken(token) {
1266      var expandedTokens = [];
1267      var string = '';
1268
1269      for (var i = 0, length = token.length; i < length; ++i) {
1270        string += token.charAt(i);
1271        expandedTokens.push(string);
1272      }
1273
1274      return expandedTokens;
1275    };
1276
1277    return PrefixIndexStrategy;
1278  }();
1279
1280  /**
1281   * Enforces case-sensitive text matches.
1282   */
1283  var CaseSensitiveSanitizer = /*#__PURE__*/function () {
1284    function CaseSensitiveSanitizer() {}
1285
1286    var _proto = CaseSensitiveSanitizer.prototype;
1287
1288    /**
1289     * @inheritDocs
1290     */
1291    _proto.sanitize = function sanitize(text) {
1292      return text ? text.trim() : '';
1293    };
1294
1295    return CaseSensitiveSanitizer;
1296  }();
1297
1298  /**
1299   * Sanitizes text by converting to a locale-friendly lower-case version and triming leading and trailing whitespace.
1300   */
1301  var LowerCaseSanitizer = /*#__PURE__*/function () {
1302    function LowerCaseSanitizer() {}
1303
1304    var _proto = LowerCaseSanitizer.prototype;
1305
1306    /**
1307     * @inheritDocs
1308     */
1309    _proto.sanitize = function sanitize(text) {
1310      return text ? text.toLocaleLowerCase().trim() : '';
1311    };
1312
1313    return LowerCaseSanitizer;
1314  }();
1315
1316  /**
1317   * Find and return a nested object value.
1318   *
1319   * @param object to crawl
1320   * @param path Property path
1321   * @returns {any}
1322   */
1323  function getNestedFieldValue(object, path) {
1324    path = path || [];
1325    object = object || {};
1326    var value = object; // walk down the property path
1327
1328    for (var i = 0; i < path.length; i++) {
1329      value = value[path[i]];
1330
1331      if (value == null) {
1332        return null;
1333      }
1334    }
1335
1336    return value;
1337  }
1338
1339  /**
1340   * Search index capable of returning results matching a set of tokens and ranked according to TF-IDF.
1341   */
1342  var TfIdfSearchIndex = /*#__PURE__*/function () {
1343    function TfIdfSearchIndex(uidFieldName) {
1344      this._uidFieldName = uidFieldName;
1345      this._tokenToIdfCache = {};
1346      this._tokenMap = {};
1347    }
1348    /**
1349     * @inheritDocs
1350     */
1351
1352
1353    var _proto = TfIdfSearchIndex.prototype;
1354
1355    _proto.indexDocument = function indexDocument(token, uid, doc) {
1356      this._tokenToIdfCache = {}; // New index invalidates previous IDF caches
1357
1358      var tokenMap = this._tokenMap;
1359      var tokenDatum;
1360
1361      if (typeof tokenMap[token] !== 'object') {
1362        tokenMap[token] = tokenDatum = {
1363          $numDocumentOccurrences: 0,
1364          $totalNumOccurrences: 1,
1365          $uidMap: {}
1366        };
1367      } else {
1368        tokenDatum = tokenMap[token];
1369        tokenDatum.$totalNumOccurrences++;
1370      }
1371
1372      var uidMap = tokenDatum.$uidMap;
1373
1374      if (typeof uidMap[uid] !== 'object') {
1375        tokenDatum.$numDocumentOccurrences++;
1376        uidMap[uid] = {
1377          $document: doc,
1378          $numTokenOccurrences: 1
1379        };
1380      } else {
1381        uidMap[uid].$numTokenOccurrences++;
1382      }
1383    }
1384    /**
1385     * @inheritDocs
1386     */
1387    ;
1388
1389    _proto.search = function search(tokens, corpus) {
1390      var uidToDocumentMap = {};
1391
1392      for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {
1393        var token = tokens[i];
1394        var tokenMetadata = this._tokenMap[token]; // Short circuit if no matches were found for any given token.
1395
1396        if (!tokenMetadata) {
1397          return [];
1398        }
1399
1400        if (i === 0) {
1401          var keys = Object.keys(tokenMetadata.$uidMap);
1402
1403          for (var j = 0, numKeys = keys.length; j < numKeys; j++) {
1404            var uid = keys[j];
1405            uidToDocumentMap[uid] = tokenMetadata.$uidMap[uid].$document;
1406          }
1407        } else {
1408          var keys = Object.keys(uidToDocumentMap);
1409
1410          for (var j = 0, numKeys = keys.length; j < numKeys; j++) {
1411            var uid = keys[j];
1412
1413            if (typeof tokenMetadata.$uidMap[uid] !== 'object') {
1414              delete uidToDocumentMap[uid];
1415            }
1416          }
1417        }
1418      }
1419
1420      var documents = [];
1421
1422      for (var uid in uidToDocumentMap) {
1423        documents.push(uidToDocumentMap[uid]);
1424      }
1425
1426      var calculateTfIdf = this._createCalculateTfIdf(); // Return documents sorted by TF-IDF
1427
1428
1429      return documents.sort(function (documentA, documentB) {
1430        return calculateTfIdf(tokens, documentB, corpus) - calculateTfIdf(tokens, documentA, corpus);
1431      });
1432    };
1433
1434    _proto._createCalculateIdf = function _createCalculateIdf() {
1435      var tokenMap = this._tokenMap;
1436      var tokenToIdfCache = this._tokenToIdfCache;
1437      return function calculateIdf(token, documents) {
1438        if (!tokenToIdfCache[token]) {
1439          var numDocumentsWithToken = typeof tokenMap[token] !== 'undefined' ? tokenMap[token].$numDocumentOccurrences : 0;
1440          tokenToIdfCache[token] = 1 + Math.log(documents.length / (1 + numDocumentsWithToken));
1441        }
1442
1443        return tokenToIdfCache[token];
1444      };
1445    };
1446
1447    _proto._createCalculateTfIdf = function _createCalculateTfIdf() {
1448      var tokenMap = this._tokenMap;
1449      var uidFieldName = this._uidFieldName;
1450
1451      var calculateIdf = this._createCalculateIdf();
1452
1453      return function calculateTfIdf(tokens, document, documents) {
1454        var score = 0;
1455
1456        for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
1457          var token = tokens[i];
1458          var inverseDocumentFrequency = calculateIdf(token, documents);
1459
1460          if (inverseDocumentFrequency === Infinity) {
1461            inverseDocumentFrequency = 0;
1462          }
1463
1464          var uid;
1465
1466          if (uidFieldName instanceof Array) {
1467            uid = document && getNestedFieldValue(document, uidFieldName);
1468          } else {
1469            uid = document && document[uidFieldName];
1470          }
1471
1472          var termFrequency = typeof tokenMap[token] !== 'undefined' && typeof tokenMap[token].$uidMap[uid] !== 'undefined' ? tokenMap[token].$uidMap[uid].$numTokenOccurrences : 0;
1473          score += termFrequency * inverseDocumentFrequency;
1474        }
1475
1476        return score;
1477      };
1478    };
1479
1480    return TfIdfSearchIndex;
1481  }();
1482
1483  /**
1484   * Search index capable of returning results matching a set of tokens but without any meaningful rank or order.
1485   */
1486  var UnorderedSearchIndex = /*#__PURE__*/function () {
1487    function UnorderedSearchIndex() {
1488      this._tokenToUidToDocumentMap = {};
1489    }
1490    /**
1491     * @inheritDocs
1492     */
1493
1494
1495    var _proto = UnorderedSearchIndex.prototype;
1496
1497    _proto.indexDocument = function indexDocument(token, uid, doc) {
1498      if (typeof this._tokenToUidToDocumentMap[token] !== 'object') {
1499        this._tokenToUidToDocumentMap[token] = {};
1500      }
1501
1502      this._tokenToUidToDocumentMap[token][uid] = doc;
1503    }
1504    /**
1505     * @inheritDocs
1506     */
1507    ;
1508
1509    _proto.search = function search(tokens, corpus) {
1510      var intersectingDocumentMap = {};
1511      var tokenToUidToDocumentMap = this._tokenToUidToDocumentMap;
1512
1513      for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {
1514        var token = tokens[i];
1515        var documentMap = tokenToUidToDocumentMap[token]; // Short circuit if no matches were found for any given token.
1516
1517        if (!documentMap) {
1518          return [];
1519        }
1520
1521        if (i === 0) {
1522          var keys = Object.keys(documentMap);
1523
1524          for (var j = 0, numKeys = keys.length; j < numKeys; j++) {
1525            var uid = keys[j];
1526            intersectingDocumentMap[uid] = documentMap[uid];
1527          }
1528        } else {
1529          var keys = Object.keys(intersectingDocumentMap);
1530
1531          for (var j = 0, numKeys = keys.length; j < numKeys; j++) {
1532            var uid = keys[j];
1533
1534            if (typeof documentMap[uid] !== 'object') {
1535              delete intersectingDocumentMap[uid];
1536            }
1537          }
1538        }
1539      }
1540
1541      var keys = Object.keys(intersectingDocumentMap);
1542      var documents = [];
1543
1544      for (var i = 0, numKeys = keys.length; i < numKeys; i++) {
1545        var uid = keys[i];
1546        documents.push(intersectingDocumentMap[uid]);
1547      }
1548
1549      return documents;
1550    };
1551
1552    return UnorderedSearchIndex;
1553  }();
1554
1555  var REGEX = /[^a-zа-яё0-9\-']+/i;
1556  /**
1557   * Simple tokenizer that splits strings on whitespace characters and returns an array of all non-empty substrings.
1558   */
1559
1560  var SimpleTokenizer = /*#__PURE__*/function () {
1561    function SimpleTokenizer() {}
1562
1563    var _proto = SimpleTokenizer.prototype;
1564
1565    /**
1566     * @inheritDocs
1567     */
1568    _proto.tokenize = function tokenize(text) {
1569      return text.split(REGEX).filter(function (text) {
1570        return text;
1571      } // Filter empty tokens
1572      );
1573    };
1574
1575    return SimpleTokenizer;
1576  }();
1577
1578  /**
1579   * Stemming is the process of reducing search tokens to their root (or stem) so that searches for different forms of a
1580   * word will match. For example "search", "searching" and "searched" are all reduced to the stem "search".
1581   *
1582   * <p>This stemming tokenizer converts tokens (words) to their stem forms before returning them. It requires an
1583   * external stemming function to be provided; for this purpose I recommend the NPM 'porter-stemmer' library.
1584   *
1585   * <p>For more information see http : //tartarus.org/~martin/PorterStemmer/
1586   */
1587  var StemmingTokenizer = /*#__PURE__*/function () {
1588    /**
1589     * Constructor.
1590     *
1591     * @param stemmingFunction Function capable of accepting a word and returning its stem.
1592     * @param decoratedIndexStrategy Index strategy to be run after all stop words have been removed.
1593     */
1594    function StemmingTokenizer(stemmingFunction, decoratedTokenizer) {
1595      this._stemmingFunction = stemmingFunction;
1596      this._tokenizer = decoratedTokenizer;
1597    }
1598    /**
1599     * @inheritDocs
1600     */
1601
1602
1603    var _proto = StemmingTokenizer.prototype;
1604
1605    _proto.tokenize = function tokenize(text) {
1606      return this._tokenizer.tokenize(text).map(this._stemmingFunction);
1607    };
1608
1609    return StemmingTokenizer;
1610  }();
1611
1612  /**
1613   * Stop words list copied from Lunr JS.
1614   */
1615  var StopWordsMap = {
1616    a: true,
1617    able: true,
1618    about: true,
1619    across: true,
1620    after: true,
1621    all: true,
1622    almost: true,
1623    also: true,
1624    am: true,
1625    among: true,
1626    an: true,
1627    and: true,
1628    any: true,
1629    are: true,
1630    as: true,
1631    at: true,
1632    be: true,
1633    because: true,
1634    been: true,
1635    but: true,
1636    by: true,
1637    can: true,
1638    cannot: true,
1639    could: true,
1640    dear: true,
1641    did: true,
1642    'do': true,
1643    does: true,
1644    either: true,
1645    'else': true,
1646    ever: true,
1647    every: true,
1648    'for': true,
1649    from: true,
1650    'get': true,
1651    got: true,
1652    had: true,
1653    has: true,
1654    have: true,
1655    he: true,
1656    her: true,
1657    hers: true,
1658    him: true,
1659    his: true,
1660    how: true,
1661    however: true,
1662    i: true,
1663    'if': true,
1664    'in': true,
1665    into: true,
1666    is: true,
1667    it: true,
1668    its: true,
1669    just: true,
1670    least: true,
1671    "let": true,
1672    like: true,
1673    likely: true,
1674    may: true,
1675    me: true,
1676    might: true,
1677    most: true,
1678    must: true,
1679    my: true,
1680    neither: true,
1681    no: true,
1682    nor: true,
1683    not: true,
1684    of: true,
1685    off: true,
1686    often: true,
1687    on: true,
1688    only: true,
1689    or: true,
1690    other: true,
1691    our: true,
1692    own: true,
1693    rather: true,
1694    said: true,
1695    say: true,
1696    says: true,
1697    she: true,
1698    should: true,
1699    since: true,
1700    so: true,
1701    some: true,
1702    than: true,
1703    that: true,
1704    the: true,
1705    their: true,
1706    them: true,
1707    then: true,
1708    there: true,
1709    these: true,
1710    they: true,
1711    'this': true,
1712    tis: true,
1713    to: true,
1714    too: true,
1715    twas: true,
1716    us: true,
1717    wants: true,
1718    was: true,
1719    we: true,
1720    were: true,
1721    what: true,
1722    when: true,
1723    where: true,
1724    which: true,
1725    'while': true,
1726    who: true,
1727    whom: true,
1728    why: true,
1729    will: true,
1730    'with': true,
1731    would: true,
1732    yet: true,
1733    you: true,
1734    your: true
1735  }; // Prevent false positives for inherited properties
1736
1737  StopWordsMap.constructor = false;
1738  StopWordsMap.hasOwnProperty = false;
1739  StopWordsMap.isPrototypeOf = false;
1740  StopWordsMap.propertyIsEnumerable = false;
1741  StopWordsMap.toLocaleString = false;
1742  StopWordsMap.toString = false;
1743  StopWordsMap.valueOf = false;
1744
1745  /**
1746   * Stop words are very common (e.g. "a", "and", "the") and are often not semantically meaningful in the context of a
1747   * search. This tokenizer removes stop words from a set of tokens before passing the remaining tokens along for
1748   * indexing or searching purposes.
1749   */
1750
1751  var StopWordsTokenizer = /*#__PURE__*/function () {
1752    /**
1753     * Constructor.
1754     *
1755     * @param decoratedIndexStrategy Index strategy to be run after all stop words have been removed.
1756     */
1757    function StopWordsTokenizer(decoratedTokenizer) {
1758      this._tokenizer = decoratedTokenizer;
1759    }
1760    /**
1761     * @inheritDocs
1762     */
1763
1764
1765    var _proto = StopWordsTokenizer.prototype;
1766
1767    _proto.tokenize = function tokenize(text) {
1768      return this._tokenizer.tokenize(text).filter(function (token) {
1769        return !StopWordsMap[token];
1770      });
1771    };
1772
1773    return StopWordsTokenizer;
1774  }();
1775
1776  function _defineProperties(target, props) {
1777    for (var i = 0; i < props.length; i++) {
1778      var descriptor = props[i];
1779      descriptor.enumerable = descriptor.enumerable || false;
1780      descriptor.configurable = true;
1781      if ("value" in descriptor) descriptor.writable = true;
1782      Object.defineProperty(target, descriptor.key, descriptor);
1783    }
1784  }
1785
1786  function _createClass(Constructor, protoProps, staticProps) {
1787    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
1788    if (staticProps) _defineProperties(Constructor, staticProps);
1789    return Constructor;
1790  }
1791
1792  /**
1793   * Simple client-side searching within a set of documents.
1794   *
1795   * <p>Documents can be searched by any number of fields. Indexing and search strategies are highly customizable.
1796   */
1797  var Search = /*#__PURE__*/function () {
1798    /**
1799     * Array containing either a property name or a path (list of property names) to a nested value
1800     */
1801
1802    /**
1803     * Constructor.
1804     * @param uidFieldName Field containing values that uniquely identify search documents; this field's values are used
1805     *                     to ensure that a search result set does not contain duplicate objects.
1806     */
1807    function Search(uidFieldName) {
1808      if (!uidFieldName) {
1809        throw Error('js-search requires a uid field name constructor parameter');
1810      }
1811
1812      this._uidFieldName = uidFieldName; // Set default/recommended strategies
1813
1814      this._indexStrategy = new PrefixIndexStrategy();
1815      this._searchIndex = new TfIdfSearchIndex(uidFieldName);
1816      this._sanitizer = new LowerCaseSanitizer();
1817      this._tokenizer = new SimpleTokenizer();
1818      this._documents = [];
1819      this._searchableFields = [];
1820    }
1821    /**
1822     * Override the default index strategy.
1823     * @param value Custom index strategy
1824     * @throws Error if documents have already been indexed by this search instance
1825     */
1826
1827
1828    var _proto = Search.prototype;
1829
1830    /**
1831     * Add a searchable document to the index. Document will automatically be indexed for search.
1832     * @param document
1833     */
1834    _proto.addDocument = function addDocument(document) {
1835      this.addDocuments([document]);
1836    }
1837    /**
1838     * Adds searchable documents to the index. Documents will automatically be indexed for search.
1839     * @param document
1840     */
1841    ;
1842
1843    _proto.addDocuments = function addDocuments(documents) {
1844      this._documents = this._documents.concat(documents);
1845      this.indexDocuments_(documents, this._searchableFields);
1846    }
1847    /**
1848     * Add a new searchable field to the index. Existing documents will automatically be indexed using this new field.
1849     *
1850     * @param field Searchable field or field path. Pass a string to index a top-level field and an array of strings for nested fields.
1851     */
1852    ;
1853
1854    _proto.addIndex = function addIndex(field) {
1855      this._searchableFields.push(field);
1856
1857      this.indexDocuments_(this._documents, [field]);
1858    }
1859    /**
1860     * Search all documents for ones matching the specified query text.
1861     * @param query
1862     * @returns {Array<Object>}
1863     */
1864    ;
1865
1866    _proto.search = function search(query) {
1867      var tokens = this._tokenizer.tokenize(this._sanitizer.sanitize(query));
1868
1869      return this._searchIndex.search(tokens, this._documents);
1870    }
1871    /**
1872     * @param documents
1873     * @param _searchableFields Array containing property names and paths (lists of property names) to nested values
1874     * @private
1875     */
1876    ;
1877
1878    _proto.indexDocuments_ = function indexDocuments_(documents, _searchableFields) {
1879      this._initialized = true;
1880      var indexStrategy = this._indexStrategy;
1881      var sanitizer = this._sanitizer;
1882      var searchIndex = this._searchIndex;
1883      var tokenizer = this._tokenizer;
1884      var uidFieldName = this._uidFieldName;
1885
1886      for (var di = 0, numDocuments = documents.length; di < numDocuments; di++) {
1887        var doc = documents[di];
1888        var uid;
1889
1890        if (uidFieldName instanceof Array) {
1891          uid = getNestedFieldValue(doc, uidFieldName);
1892        } else {
1893          uid = doc[uidFieldName];
1894        }
1895
1896        for (var sfi = 0, numSearchableFields = _searchableFields.length; sfi < numSearchableFields; sfi++) {
1897          var fieldValue;
1898          var searchableField = _searchableFields[sfi];
1899
1900          if (searchableField instanceof Array) {
1901            fieldValue = getNestedFieldValue(doc, searchableField);
1902          } else {
1903            fieldValue = doc[searchableField];
1904          }
1905
1906          if (fieldValue != null && typeof fieldValue !== 'string' && fieldValue.toString) {
1907            fieldValue = fieldValue.toString();
1908          }
1909
1910          if (typeof fieldValue === 'string') {
1911            var fieldTokens = tokenizer.tokenize(sanitizer.sanitize(fieldValue));
1912
1913            for (var fti = 0, numFieldValues = fieldTokens.length; fti < numFieldValues; fti++) {
1914              var fieldToken = fieldTokens[fti];
1915              var expandedTokens = indexStrategy.expandToken(fieldToken);
1916
1917              for (var eti = 0, nummExpandedTokens = expandedTokens.length; eti < nummExpandedTokens; eti++) {
1918                var expandedToken = expandedTokens[eti];
1919                searchIndex.indexDocument(expandedToken, uid, doc);
1920              }
1921            }
1922          }
1923        }
1924      }
1925    };
1926
1927    _createClass(Search, [{
1928      key: "indexStrategy",
1929      set: function set(value) {
1930        if (this._initialized) {
1931          throw Error('IIndexStrategy cannot be set after initialization');
1932        }
1933
1934        this._indexStrategy = value;
1935      },
1936      get: function get() {
1937        return this._indexStrategy;
1938      }
1939      /**
1940       * Override the default text sanitizing strategy.
1941       * @param value Custom text sanitizing strategy
1942       * @throws Error if documents have already been indexed by this search instance
1943       */
1944
1945    }, {
1946      key: "sanitizer",
1947      set: function set(value) {
1948        if (this._initialized) {
1949          throw Error('ISanitizer cannot be set after initialization');
1950        }
1951
1952        this._sanitizer = value;
1953      },
1954      get: function get() {
1955        return this._sanitizer;
1956      }
1957      /**
1958       * Override the default search index strategy.
1959       * @param value Custom search index strategy
1960       * @throws Error if documents have already been indexed
1961       */
1962
1963    }, {
1964      key: "searchIndex",
1965      set: function set(value) {
1966        if (this._initialized) {
1967          throw Error('ISearchIndex cannot be set after initialization');
1968        }
1969
1970        this._searchIndex = value;
1971      },
1972      get: function get() {
1973        return this._searchIndex;
1974      }
1975      /**
1976       * Override the default text tokenizing strategy.
1977       * @param value Custom text tokenizing strategy
1978       * @throws Error if documents have already been indexed by this search instance
1979       */
1980
1981    }, {
1982      key: "tokenizer",
1983      set: function set(value) {
1984        if (this._initialized) {
1985          throw Error('ITokenizer cannot be set after initialization');
1986        }
1987
1988        this._tokenizer = value;
1989      },
1990      get: function get() {
1991        return this._tokenizer;
1992      }
1993    }]);
1994
1995    return Search;
1996  }();
1997
1998  /**
1999   * This utility highlights the occurrences of tokens within a string of text. It can be used to give visual indicators
2000   * of match criteria within searchable fields.
2001   *
2002   * <p>For performance purposes this highlighter only works with full-word or prefix token indexes.
2003   */
2004  var TokenHighlighter = /*#__PURE__*/function () {
2005    /**
2006     * Constructor.
2007     *
2008     * @param opt_indexStrategy Index strategy used by Search
2009     * @param opt_sanitizer Sanitizer used by Search
2010     * @param opt_wrapperTagName Optional wrapper tag name; defaults to 'mark' (e.g. <mark>)
2011     */
2012    function TokenHighlighter(opt_indexStrategy, opt_sanitizer, opt_wrapperTagName) {
2013      this._indexStrategy = opt_indexStrategy || new PrefixIndexStrategy();
2014      this._sanitizer = opt_sanitizer || new LowerCaseSanitizer();
2015      this._wrapperTagName = opt_wrapperTagName || 'mark';
2016    }
2017    /**
2018     * Highlights token occurrences within a string by wrapping them with a DOM element.
2019     *
2020     * @param text e.g. "john wayne"
2021     * @param tokens e.g. ["wa"]
2022     * @returns {string} e.g. "john <mark>wa</mark>yne"
2023     */
2024
2025
2026    var _proto = TokenHighlighter.prototype;
2027
2028    _proto.highlight = function highlight(text, tokens) {
2029      var tagsLength = this._wrapText('').length;
2030
2031      var tokenDictionary = Object.create(null); // Create a token map for easier lookup below.
2032
2033      for (var i = 0, numTokens = tokens.length; i < numTokens; i++) {
2034        var token = this._sanitizer.sanitize(tokens[i]);
2035
2036        var expandedTokens = this._indexStrategy.expandToken(token);
2037
2038        for (var j = 0, numExpandedTokens = expandedTokens.length; j < numExpandedTokens; j++) {
2039          var expandedToken = expandedTokens[j];
2040
2041          if (!tokenDictionary[expandedToken]) {
2042            tokenDictionary[expandedToken] = [token];
2043          } else {
2044            tokenDictionary[expandedToken].push(token);
2045          }
2046        }
2047      } // Track actualCurrentWord and sanitizedCurrentWord separately in case we encounter nested tags.
2048
2049
2050      var actualCurrentWord = '';
2051      var sanitizedCurrentWord = '';
2052      var currentWordStartIndex = 0; // Note this assumes either prefix or full word matching.
2053
2054      for (var i = 0, textLength = text.length; i < textLength; i++) {
2055        var character = text.charAt(i);
2056
2057        if (character === ' ') {
2058          actualCurrentWord = '';
2059          sanitizedCurrentWord = '';
2060          currentWordStartIndex = i + 1;
2061        } else {
2062          actualCurrentWord += character;
2063          sanitizedCurrentWord += this._sanitizer.sanitize(character);
2064        }
2065
2066        if (tokenDictionary[sanitizedCurrentWord] && tokenDictionary[sanitizedCurrentWord].indexOf(sanitizedCurrentWord) >= 0) {
2067          actualCurrentWord = this._wrapText(actualCurrentWord);
2068          text = text.substring(0, currentWordStartIndex) + actualCurrentWord + text.substring(i + 1);
2069          i += tagsLength;
2070          textLength += tagsLength;
2071        }
2072      }
2073
2074      return text;
2075    }
2076    /**
2077     * @param text to wrap
2078     * @returns Text wrapped by wrapper tag (e.g. "foo" becomes "<mark>foo</mark>")
2079     * @private
2080     */
2081    ;
2082
2083    _proto._wrapText = function _wrapText(text) {
2084      var tagName = this._wrapperTagName;
2085      return "<" + tagName + ">" + text + "</" + tagName + ">";
2086    };
2087
2088    return TokenHighlighter;
2089  }();
2090
2091  exports.AllSubstringsIndexStrategy = AllSubstringsIndexStrategy;
2092  exports.CaseSensitiveSanitizer = CaseSensitiveSanitizer;
2093  exports.ExactWordIndexStrategy = ExactWordIndexStrategy;
2094  exports.LowerCaseSanitizer = LowerCaseSanitizer;
2095  exports.PrefixIndexStrategy = PrefixIndexStrategy;
2096  exports.Search = Search;
2097  exports.SimpleTokenizer = SimpleTokenizer;
2098  exports.StemmingTokenizer = StemmingTokenizer;
2099  exports.StopWordsMap = StopWordsMap;
2100  exports.StopWordsTokenizer = StopWordsTokenizer;
2101  exports.TfIdfSearchIndex = TfIdfSearchIndex;
2102  exports.TokenHighlighter = TokenHighlighter;
2103  exports.UnorderedSearchIndex = UnorderedSearchIndex;
2104
2105  Object.defineProperty(exports, '__esModule', { value: true });
2106
2107})));

2108
2109},{}],5:[function(require,module,exports){
2110/*!
2111 Leaflet.FeatureGroup.SubGroup 1.0.2+00bb0d4
2112 (c) 2015-2017 Boris Seang
2113 License BSD-2-Clause
2114 */
2115!function(e,r){"function"==typeof define&&define.amd?define(["leaflet"],r):r("object"==typeof module&&module.exports?require("leaflet"):e.L)}(this,function(e){e.FeatureGroup.SubGroup=e.FeatureGroup.extend({initialize:function(r,t){e.FeatureGroup.prototype.initialize.call(this,t),this.setParentGroup(r)},setParentGroup:function(r){var t=r instanceof e.LayerGroup;return this._parentGroup=r,this.onAdd=t?"function"==typeof r.addLayers?this._onAddToGroupBatch:this._onAddToGroup:this._onAddToMap,this.onRemove=t?"function"==typeof r.removeLayers?this._onRemoveFromGroupBatch:this._onRemoveFromGroup:this._onRemoveFromMap,this.addLayer=t?this._addLayerToGroup:this._addLayerToMap,this.removeLayer=t?this._removeLayerFromGroup:this._removeLayerFromMap,this},setParentGroupSafe:function(e){var r=this._map;return r&&r.removeLayer(this),this.setParentGroup(e),r&&r.addLayer(this),this},getParentGroup:function(){return this._parentGroup},_onAddToGroupBatch:function(e){var r=this.getLayers();this._map=e,this._parentGroup.addLayers(r)},_onRemoveFromGroupBatch:function(){var e=this.getLayers();this._parentGroup.removeLayers(e),this._map=null},_onAddToGroup:function(e){var r=this._parentGroup;this._map=e,this.eachLayer(r.addLayer,r)},_onRemoveFromGroup:function(){var e=this._parentGroup;this.eachLayer(e.removeLayer,e),this._map=null},_onAddToMap:e.FeatureGroup.prototype.onAdd,_onRemoveFromMap:e.FeatureGroup.prototype.onRemove,_addLayerToGroup:function(e){if(this.hasLayer(e))return this;e.addEventParent(this);var r=this.getLayerId(e);return this._layers[r]=e,this._map&&this._parentGroup.addLayer(e),this.fire("layeradd",{layer:e})},_removeLayerFromGroup:function(e){if(!this.hasLayer(e))return this;var r=e in this._layers?e:this.getLayerId(e);return e=this._layers[r],e.removeEventParent(this),this._map&&e&&this._parentGroup.removeLayer(e),delete this._layers[r],this.fire("layerremove",{layer:e})},_addLayerToMap:e.FeatureGroup.prototype.addLayer,_removeLayerFromMap:e.FeatureGroup.prototype.removeLayer}),e.featureGroup.subGroup=function(r,t){return new e.FeatureGroup.SubGroup(r,t)}});
2116},{"leaflet":7}],6:[function(require,module,exports){

2117/*
2118 * Leaflet.markercluster 1.5.3+master.e5124b2,
2119 * Provides Beautiful Animated Marker Clustering functionality for Leaflet, a JS library for interactive maps.
2120 * https://github.com/Leaflet/Leaflet.markercluster
2121 * (c) 2012-2017, Dave Leaver, smartrak
2122 */
2123(function (global, factory) {
2124	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
2125	typeof define === 'function' && define.amd ? define(['exports'], factory) :
2126	(global = global || self, factory((global.Leaflet = global.Leaflet || {}, global.Leaflet.markercluster = {})));
2127}(this, function (exports) { 'use strict';
2128
2129	/*
2130	 * L.MarkerClusterGroup extends L.FeatureGroup by clustering the markers contained within
2131	 */
2132
2133	var MarkerClusterGroup = L.MarkerClusterGroup = L.FeatureGroup.extend({
2134
2135		options: {
2136			maxClusterRadius: 80, //A cluster will cover at most this many pixels from its center
2137			iconCreateFunction: null,
2138			clusterPane: L.Marker.prototype.options.pane,
2139
2140			spiderfyOnEveryZoom: false,
2141			spiderfyOnMaxZoom: true,
2142			showCoverageOnHover: true,
2143			zoomToBoundsOnClick: true,
2144			singleMarkerMode: false,
2145
2146			disableClusteringAtZoom: null,
2147
2148			// Setting this to false prevents the removal of any clusters outside of the viewpoint, which
2149			// is the default behaviour for performance reasons.
2150			removeOutsideVisibleBounds: true,
2151
2152			// Set to false to disable all animations (zoom and spiderfy).
2153			// If false, option animateAddingMarkers below has no effect.
2154			// If L.DomUtil.TRANSITION is falsy, this option has no effect.
2155			animate: true,
2156
2157			//Whether to animate adding markers after adding the MarkerClusterGroup to the map
2158			// If you are adding individual markers set to true, if adding bulk markers leave false for massive performance gains.
2159			animateAddingMarkers: false,
2160
2161			// Make it possible to provide custom function to calculate spiderfy shape positions
2162			spiderfyShapePositions: null,
2163
2164			//Increase to increase the distance away that spiderfied markers appear from the center
2165			spiderfyDistanceMultiplier: 1,
2166
2167			// Make it possible to specify a polyline options on a spider leg
2168			spiderLegPolylineOptions: { weight: 1.5, color: '#222', opacity: 0.5 },
2169
2170			// When bulk adding layers, adds markers in chunks. Means addLayers may not add all the layers in the call, others will be loaded during setTimeouts
2171			chunkedLoading: false,
2172			chunkInterval: 200, // process markers for a maximum of ~ n milliseconds (then trigger the chunkProgress callback)
2173			chunkDelay: 50, // at the end of each interval, give n milliseconds back to system/browser
2174			chunkProgress: null, // progress callback: function(processed, total, elapsed) (e.g. for a progress indicator)
2175
2176			//Options to pass to the L.Polygon constructor
2177			polygonOptions: {}
2178		},
2179
2180		initialize: function (options) {
2181			L.Util.setOptions(this, options);
2182			if (!this.options.iconCreateFunction) {
2183				this.options.iconCreateFunction = this._defaultIconCreateFunction;
2184			}
2185
2186			this._featureGroup = L.featureGroup();
2187			this._featureGroup.addEventParent(this);
2188
2189			this._nonPointGroup = L.featureGroup();
2190			this._nonPointGroup.addEventParent(this);
2191
2192			this._inZoomAnimation = 0;
2193			this._needsClustering = [];
2194			this._needsRemoving = []; //Markers removed while we aren't on the map need to be kept track of
2195			//The bounds of the currently shown area (from _getExpandedVisibleBounds) Updated on zoom/move
2196			this._currentShownBounds = null;
2197
2198			this._queue = [];
2199
2200			this._childMarkerEventHandlers = {
2201				'dragstart': this._childMarkerDragStart,
2202				'move': this._childMarkerMoved,
2203				'dragend': this._childMarkerDragEnd,
2204			};
2205
2206			// Hook the appropriate animation methods.
2207			var animate = L.DomUtil.TRANSITION && this.options.animate;
2208			L.extend(this, animate ? this._withAnimation : this._noAnimation);
2209			// Remember which MarkerCluster class to instantiate (animated or not).
2210			this._markerCluster = animate ? L.MarkerCluster : L.MarkerClusterNonAnimated;
2211		},
2212
2213		addLayer: function (layer) {
2214
2215			if (layer instanceof L.LayerGroup) {
2216				return this.addLayers([layer]);
2217			}
2218
2219			//Don't cluster non point data
2220			if (!layer.getLatLng) {
2221				this._nonPointGroup.addLayer(layer);
2222				this.fire('layeradd', { layer: layer });
2223				return this;
2224			}
2225
2226			if (!this._map) {
2227				this._needsClustering.push(layer);
2228				this.fire('layeradd', { layer: layer });
2229				return this;
2230			}
2231
2232			if (this.hasLayer(layer)) {
2233				return this;
2234			}
2235
2236
2237			//If we have already clustered we'll need to add this one to a cluster
2238
2239			if (this._unspiderfy) {
2240				this._unspiderfy();
2241			}
2242
2243			this._addLayer(layer, this._maxZoom);
2244			this.fire('layeradd', { layer: layer });
2245
2246			// Refresh bounds and weighted positions.
2247			this._topClusterLevel._recalculateBounds();
2248
2249			this._refreshClustersIcons();
2250
2251			//Work out what is visible
2252			var visibleLayer = layer,
2253			    currentZoom = this._zoom;
2254			if (layer.__parent) {
2255				while (visibleLayer.__parent._zoom >= currentZoom) {
2256					visibleLayer = visibleLayer.__parent;
2257				}
2258			}
2259
2260			if (this._currentShownBounds.contains(visibleLayer.getLatLng())) {
2261				if (this.options.animateAddingMarkers) {
2262					this._animationAddLayer(layer, visibleLayer);
2263				} else {
2264					this._animationAddLayerNonAnimated(layer, visibleLayer);
2265				}
2266			}
2267			return this;
2268		},
2269
2270		removeLayer: function (layer) {
2271
2272			if (layer instanceof L.LayerGroup) {
2273				return this.removeLayers([layer]);
2274			}
2275
2276			//Non point layers
2277			if (!layer.getLatLng) {
2278				this._nonPointGroup.removeLayer(layer);
2279				this.fire('layerremove', { layer: layer });
2280				return this;
2281			}
2282
2283			if (!this._map) {
2284				if (!this._arraySplice(this._needsClustering, layer) && this.hasLayer(layer)) {
2285					this._needsRemoving.push({ layer: layer, latlng: layer._latlng });
2286				}
2287				this.fire('layerremove', { layer: layer });
2288				return this;
2289			}
2290
2291			if (!layer.__parent) {
2292				return this;
2293			}
2294
2295			if (this._unspiderfy) {
2296				this._unspiderfy();
2297				this._unspiderfyLayer(layer);
2298			}
2299
2300			//Remove the marker from clusters
2301			this._removeLayer(layer, true);
2302			this.fire('layerremove', { layer: layer });
2303
2304			// Refresh bounds and weighted positions.
2305			this._topClusterLevel._recalculateBounds();
2306
2307			this._refreshClustersIcons();
2308
2309			layer.off(this._childMarkerEventHandlers, this);
2310
2311			if (this._featureGroup.hasLayer(layer)) {
2312				this._featureGroup.removeLayer(layer);
2313				if (layer.clusterShow) {
2314					layer.clusterShow();
2315				}
2316			}
2317
2318			return this;
2319		},
2320
2321		//Takes an array of markers and adds them in bulk
2322		addLayers: function (layersArray, skipLayerAddEvent) {
2323			if (!L.Util.isArray(layersArray)) {
2324				return this.addLayer(layersArray);
2325			}
2326
2327			var fg = this._featureGroup,
2328			    npg = this._nonPointGroup,
2329			    chunked = this.options.chunkedLoading,
2330			    chunkInterval = this.options.chunkInterval,
2331			    chunkProgress = this.options.chunkProgress,
2332			    l = layersArray.length,
2333			    offset = 0,
2334			    originalArray = true,
2335			    m;
2336
2337			if (this._map) {
2338				var started = (new Date()).getTime();
2339				var process = L.bind(function () {
2340					var start = (new Date()).getTime();
2341
2342					// Make sure to unspiderfy before starting to add some layers
2343					if (this._map && this._unspiderfy) {
2344						this._unspiderfy();
2345					}
2346
2347					for (; offset < l; offset++) {
2348						if (chunked && offset % 200 === 0) {
2349							// every couple hundred markers, instrument the time elapsed since processing started:
2350							var elapsed = (new Date()).getTime() - start;
2351							if (elapsed > chunkInterval) {
2352								break; // been working too hard, time to take a break :-)
2353							}
2354						}
2355
2356						m = layersArray[offset];
2357
2358						// Group of layers, append children to layersArray and skip.
2359						// Side effects:
2360						// - Total increases, so chunkProgress ratio jumps backward.
2361						// - Groups are not included in this group, only their non-group child layers (hasLayer).
2362						// Changing array length while looping does not affect performance in current browsers:
2363						// http://jsperf.com/for-loop-changing-length/6
2364						if (m instanceof L.LayerGroup) {
2365							if (originalArray) {
2366								layersArray = layersArray.slice();
2367								originalArray = false;
2368							}
2369							this._extractNonGroupLayers(m, layersArray);
2370							l = layersArray.length;
2371							continue;
2372						}
2373
2374						//Not point data, can't be clustered
2375						if (!m.getLatLng) {
2376							npg.addLayer(m);
2377							if (!skipLayerAddEvent) {
2378								this.fire('layeradd', { layer: m });
2379							}
2380							continue;
2381						}
2382
2383						if (this.hasLayer(m)) {
2384							continue;
2385						}
2386
2387						this._addLayer(m, this._maxZoom);
2388						if (!skipLayerAddEvent) {
2389							this.fire('layeradd', { layer: m });
2390						}
2391
2392						//If we just made a cluster of size 2 then we need to remove the other marker from the map (if it is) or we never will
2393						if (m.__parent) {
2394							if (m.__parent.getChildCount() === 2) {
2395								var markers = m.__parent.getAllChildMarkers(),
2396								    otherMarker = markers[0] === m ? markers[1] : markers[0];
2397								fg.removeLayer(otherMarker);
2398							}
2399						}
2400					}
2401
2402					if (chunkProgress) {
2403						// report progress and time elapsed:
2404						chunkProgress(offset, l, (new Date()).getTime() - started);
2405					}
2406
2407					// Completed processing all markers.
2408					if (offset === l) {
2409
2410						// Refresh bounds and weighted positions.
2411						this._topClusterLevel._recalculateBounds();
2412
2413						this._refreshClustersIcons();
2414
2415						this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
2416					} else {
2417						setTimeout(process, this.options.chunkDelay);
2418					}
2419				}, this);
2420
2421				process();
2422			} else {
2423				var needsClustering = this._needsClustering;
2424
2425				for (; offset < l; offset++) {
2426					m = layersArray[offset];
2427
2428					// Group of layers, append children to layersArray and skip.
2429					if (m instanceof L.LayerGroup) {
2430						if (originalArray) {
2431							layersArray = layersArray.slice();
2432							originalArray = false;
2433						}
2434						this._extractNonGroupLayers(m, layersArray);
2435						l = layersArray.length;
2436						continue;
2437					}
2438
2439					//Not point data, can't be clustered
2440					if (!m.getLatLng) {
2441						npg.addLayer(m);
2442						continue;
2443					}
2444
2445					if (this.hasLayer(m)) {
2446						continue;
2447					}
2448
2449					needsClustering.push(m);
2450				}
2451			}
2452			return this;
2453		},
2454
2455		//Takes an array of markers and removes them in bulk
2456		removeLayers: function (layersArray) {
2457			var i, m,
2458			    l = layersArray.length,
2459			    fg = this._featureGroup,
2460			    npg = this._nonPointGroup,
2461			    originalArray = true;
2462
2463			if (!this._map) {
2464				for (i = 0; i < l; i++) {
2465					m = layersArray[i];
2466
2467					// Group of layers, append children to layersArray and skip.
2468					if (m instanceof L.LayerGroup) {
2469						if (originalArray) {
2470							layersArray = layersArray.slice();
2471							originalArray = false;
2472						}
2473						this._extractNonGroupLayers(m, layersArray);
2474						l = layersArray.length;
2475						continue;
2476					}
2477
2478					this._arraySplice(this._needsClustering, m);
2479					npg.removeLayer(m);
2480					if (this.hasLayer(m)) {
2481						this._needsRemoving.push({ layer: m, latlng: m._latlng });
2482					}
2483					this.fire('layerremove', { layer: m });
2484				}
2485				return this;
2486			}
2487
2488			if (this._unspiderfy) {
2489				this._unspiderfy();
2490
2491				// Work on a copy of the array, so that next loop is not affected.
2492				var layersArray2 = layersArray.slice(),
2493				    l2 = l;
2494				for (i = 0; i < l2; i++) {
2495					m = layersArray2[i];
2496
2497					// Group of layers, append children to layersArray and skip.
2498					if (m instanceof L.LayerGroup) {
2499						this._extractNonGroupLayers(m, layersArray2);
2500						l2 = layersArray2.length;
2501						continue;
2502					}
2503
2504					this._unspiderfyLayer(m);
2505				}
2506			}
2507
2508			for (i = 0; i < l; i++) {
2509				m = layersArray[i];
2510
2511				// Group of layers, append children to layersArray and skip.
2512				if (m instanceof L.LayerGroup) {
2513					if (originalArray) {
2514						layersArray = layersArray.slice();
2515						originalArray = false;
2516					}
2517					this._extractNonGroupLayers(m, layersArray);
2518					l = layersArray.length;
2519					continue;
2520				}
2521
2522				if (!m.__parent) {
2523					npg.removeLayer(m);
2524					this.fire('layerremove', { layer: m });
2525					continue;
2526				}
2527
2528				this._removeLayer(m, true, true);
2529				this.fire('layerremove', { layer: m });
2530
2531				if (fg.hasLayer(m)) {
2532					fg.removeLayer(m);
2533					if (m.clusterShow) {
2534						m.clusterShow();
2535					}
2536				}
2537			}
2538
2539			// Refresh bounds and weighted positions.
2540			this._topClusterLevel._recalculateBounds();
2541
2542			this._refreshClustersIcons();
2543
2544			//Fix up the clusters and markers on the map
2545			this._topClusterLevel._recursivelyAddChildrenToMap(null, this._zoom, this._currentShownBounds);
2546
2547			return this;
2548		},
2549
2550		//Removes all layers from the MarkerClusterGroup
2551		clearLayers: function () {
2552			//Need our own special implementation as the LayerGroup one doesn't work for us
2553
2554			//If we aren't on the map (yet), blow away the markers we know of
2555			if (!this._map) {
2556				this._needsClustering = [];
2557				this._needsRemoving = [];
2558				delete this._gridClusters;
2559				delete this._gridUnclustered;
2560			}
2561
2562			if (this._noanimationUnspiderfy) {
2563				this._noanimationUnspiderfy();
2564			}
2565
2566			//Remove all the visible layers
2567			this._featureGroup.clearLayers();
2568			this._nonPointGroup.clearLayers();
2569
2570			this.eachLayer(function (marker) {
2571				marker.off(this._childMarkerEventHandlers, this);
2572				delete marker.__parent;
2573			}, this);
2574
2575			if (this._map) {
2576				//Reset _topClusterLevel and the DistanceGrids
2577				this._generateInitialClusters();
2578			}
2579
2580			return this;
2581		},
2582
2583		//Override FeatureGroup.getBounds as it doesn't work
2584		getBounds: function () {
2585			var bounds = new L.LatLngBounds();
2586
2587			if (this._topClusterLevel) {
2588				bounds.extend(this._topClusterLevel._bounds);
2589			}
2590
2591			for (var i = this._needsClustering.length - 1; i >= 0; i--) {
2592				bounds.extend(this._needsClustering[i].getLatLng());
2593			}
2594
2595			bounds.extend(this._nonPointGroup.getBounds());
2596
2597			return bounds;
2598		},
2599
2600		//Overrides LayerGroup.eachLayer
2601		eachLayer: function (method, context) {
2602			var markers = this._needsClustering.slice(),
2603				needsRemoving = this._needsRemoving,
2604				thisNeedsRemoving, i, j;
2605
2606			if (this._topClusterLevel) {
2607				this._topClusterLevel.getAllChildMarkers(markers);
2608			}
2609
2610			for (i = markers.length - 1; i >= 0; i--) {
2611				thisNeedsRemoving = true;
2612
2613				for (j = needsRemoving.length - 1; j >= 0; j--) {
2614					if (needsRemoving[j].layer === markers[i]) {
2615						thisNeedsRemoving = false;
2616						break;
2617					}
2618				}
2619
2620				if (thisNeedsRemoving) {
2621					method.call(context, markers[i]);
2622				}
2623			}
2624
2625			this._nonPointGroup.eachLayer(method, context);
2626		},
2627
2628		//Overrides LayerGroup.getLayers
2629		getLayers: function () {
2630			var layers = [];
2631			this.eachLayer(function (l) {
2632				layers.push(l);
2633			});
2634			return layers;
2635		},
2636
2637		//Overrides LayerGroup.getLayer, WARNING: Really bad performance
2638		getLayer: function (id) {
2639			var result = null;
2640
2641			id = parseInt(id, 10);
2642
2643			this.eachLayer(function (l) {
2644				if (L.stamp(l) === id) {
2645					result = l;
2646				}
2647			});
2648
2649			return result;
2650		},
2651
2652		//Returns true if the given layer is in this MarkerClusterGroup
2653		hasLayer: function (layer) {
2654			if (!layer) {
2655				return false;
2656			}
2657
2658			var i, anArray = this._needsClustering;
2659
2660			for (i = anArray.length - 1; i >= 0; i--) {
2661				if (anArray[i] === layer) {
2662					return true;
2663				}
2664			}
2665
2666			anArray = this._needsRemoving;
2667			for (i = anArray.length - 1; i >= 0; i--) {
2668				if (anArray[i].layer === layer) {
2669					return false;
2670				}
2671			}
2672
2673			return !!(layer.__parent && layer.__parent._group === this) || this._nonPointGroup.hasLayer(layer);
2674		},
2675
2676		//Zoom down to show the given layer (spiderfying if necessary) then calls the callback
2677		zoomToShowLayer: function (layer, callback) {
2678
2679			var map = this._map;
2680
2681			if (typeof callback !== 'function') {
2682				callback = function () {};
2683			}
2684
2685			var showMarker = function () {
2686				// Assumes that map.hasLayer checks for direct appearance on map, not recursively calling
2687				// hasLayer on Layer Groups that are on map (typically not calling this MarkerClusterGroup.hasLayer, which would always return true)
2688				if ((map.hasLayer(layer) || map.hasLayer(layer.__parent)) && !this._inZoomAnimation) {
2689					this._map.off('moveend', showMarker, this);
2690					this.off('animationend', showMarker, this);
2691
2692					if (map.hasLayer(layer)) {
2693						callback();
2694					} else if (layer.__parent._icon) {
2695						this.once('spiderfied', callback, this);
2696						layer.__parent.spiderfy();
2697					}
2698				}
2699			};
2700
2701			if (layer._icon && this._map.getBounds().contains(layer.getLatLng())) {
2702				//Layer is visible ond on screen, immediate return
2703				callback();
2704			} else if (layer.__parent._zoom < Math.round(this._map._zoom)) {
2705				//Layer should be visible at this zoom level. It must not be on screen so just pan over to it
2706				this._map.on('moveend', showMarker, this);
2707				this._map.panTo(layer.getLatLng());
2708			} else {
2709				this._map.on('moveend', showMarker, this);
2710				this.on('animationend', showMarker, this);
2711				layer.__parent.zoomToBounds();
2712			}
2713		},
2714
2715		//Overrides FeatureGroup.onAdd
2716		onAdd: function (map) {
2717			this._map = map;
2718			var i, l, layer;
2719
2720			if (!isFinite(this._map.getMaxZoom())) {
2721				throw "Map has no maxZoom specified";
2722			}
2723
2724			this._featureGroup.addTo(map);
2725			this._nonPointGroup.addTo(map);
2726
2727			if (!this._gridClusters) {
2728				this._generateInitialClusters();
2729			}
2730
2731			this._maxLat = map.options.crs.projection.MAX_LATITUDE;
2732
2733			//Restore all the positions as they are in the MCG before removing them
2734			for (i = 0, l = this._needsRemoving.length; i < l; i++) {
2735				layer = this._needsRemoving[i];
2736				layer.newlatlng = layer.layer._latlng;
2737				layer.layer._latlng = layer.latlng;
2738			}
2739			//Remove them, then restore their new positions
2740			for (i = 0, l = this._needsRemoving.length; i < l; i++) {
2741				layer = this._needsRemoving[i];
2742				this._removeLayer(layer.layer, true);
2743				layer.layer._latlng = layer.newlatlng;
2744			}
2745			this._needsRemoving = [];
2746
2747			//Remember the current zoom level and bounds
2748			this._zoom = Math.round(this._map._zoom);
2749			this._currentShownBounds = this._getExpandedVisibleBounds();
2750
2751			this._map.on('zoomend', this._zoomEnd, this);
2752			this._map.on('moveend', this._moveEnd, this);
2753
2754			if (this._spiderfierOnAdd) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
2755				this._spiderfierOnAdd();
2756			}
2757
2758			this._bindEvents();
2759
2760			//Actually add our markers to the map:
2761			l = this._needsClustering;
2762			this._needsClustering = [];
2763			this.addLayers(l, true);
2764		},
2765
2766		//Overrides FeatureGroup.onRemove
2767		onRemove: function (map) {
2768			map.off('zoomend', this._zoomEnd, this);
2769			map.off('moveend', this._moveEnd, this);
2770
2771			this._unbindEvents();
2772
2773			//In case we are in a cluster animation
2774			this._map._mapPane.className = this._map._mapPane.className.replace(' leaflet-cluster-anim', '');
2775
2776			if (this._spiderfierOnRemove) { //TODO FIXME: Not sure how to have spiderfier add something on here nicely
2777				this._spiderfierOnRemove();
2778			}
2779
2780			delete this._maxLat;
2781
2782			//Clean up all the layers we added to the map
2783			this._hideCoverage();
2784			this._featureGroup.remove();
2785			this._nonPointGroup.remove();
2786
2787			this._featureGroup.clearLayers();
2788
2789			this._map = null;
2790		},
2791
2792		getVisibleParent: function (marker) {
2793			var vMarker = marker;
2794			while (vMarker && !vMarker._icon) {
2795				vMarker = vMarker.__parent;
2796			}
2797			return vMarker || null;
2798		},
2799
2800		//Remove the given object from the given array
2801		_arraySplice: function (anArray, obj) {
2802			for (var i = anArray.length - 1; i >= 0; i--) {
2803				if (anArray[i] === obj) {
2804					anArray.splice(i, 1);
2805					return true;
2806				}
2807			}
2808		},
2809
2810		/**
2811		 * Removes a marker from all _gridUnclustered zoom levels, starting at the supplied zoom.
2812		 * @param marker to be removed from _gridUnclustered.
2813		 * @param z integer bottom start zoom level (included)
2814		 * @private
2815		 */
2816		_removeFromGridUnclustered: function (marker, z) {
2817			var map = this._map,
2818			    gridUnclustered = this._gridUnclustered,
2819				minZoom = Math.floor(this._map.getMinZoom());
2820
2821			for (; z >= minZoom; z--) {
2822				if (!gridUnclustered[z].removeObject(marker, map.project(marker.getLatLng(), z))) {
2823					break;
2824				}
2825			}
2826		},
2827
2828		_childMarkerDragStart: function (e) {
2829			e.target.__dragStart = e.target._latlng;
2830		},
2831
2832		_childMarkerMoved: function (e) {
2833			if (!this._ignoreMove && !e.target.__dragStart) {
2834				var isPopupOpen = e.target._popup && e.target._popup.isOpen();
2835
2836				this._moveChild(e.target, e.oldLatLng, e.latlng);
2837
2838				if (isPopupOpen) {
2839					e.target.openPopup();
2840				}
2841			}
2842		},
2843
2844		_moveChild: function (layer, from, to) {
2845			layer._latlng = from;
2846			this.removeLayer(layer);
2847
2848			layer._latlng = to;
2849			this.addLayer(layer);
2850		},
2851
2852		_childMarkerDragEnd: function (e) {
2853			var dragStart = e.target.__dragStart;
2854			delete e.target.__dragStart;
2855			if (dragStart) {
2856				this._moveChild(e.target, dragStart, e.target._latlng);
2857			}		
2858		},
2859
2860
2861		//Internal function for removing a marker from everything.
2862		//dontUpdateMap: set to true if you will handle updating the map manually (for bulk functions)
2863		_removeLayer: function (marker, removeFromDistanceGrid, dontUpdateMap) {
2864			var gridClusters = this._gridClusters,
2865				gridUnclustered = this._gridUnclustered,
2866				fg = this._featureGroup,
2867				map = this._map,
2868				minZoom = Math.floor(this._map.getMinZoom());
2869
2870			//Remove the marker from distance clusters it might be in
2871			if (removeFromDistanceGrid) {
2872				this._removeFromGridUnclustered(marker, this._maxZoom);
2873			}
2874
2875			//Work our way up the clusters removing them as we go if required
2876			var cluster = marker.__parent,
2877				markers = cluster._markers,
2878				otherMarker;
2879
2880			//Remove the marker from the immediate parents marker list
2881			this._arraySplice(markers, marker);
2882
2883			while (cluster) {
2884				cluster._childCount--;
2885				cluster._boundsNeedUpdate = true;
2886
2887				if (cluster._zoom < minZoom) {
2888					//Top level, do nothing
2889					break;
2890				} else if (removeFromDistanceGrid && cluster._childCount <= 1) { //Cluster no longer required
2891					//We need to push the other marker up to the parent
2892					otherMarker = cluster._markers[0] === marker ? cluster._markers[1] : cluster._markers[0];
2893
2894					//Update distance grid
2895					gridClusters[cluster._zoom].removeObject(cluster, map.project(cluster._cLatLng, cluster._zoom));
2896					gridUnclustered[cluster._zoom].addObject(otherMarker, map.project(otherMarker.getLatLng(), cluster._zoom));
2897
2898					//Move otherMarker up to parent
2899					this._arraySplice(cluster.__parent._childClusters, cluster);
2900					cluster.__parent._markers.push(otherMarker);
2901					otherMarker.__parent = cluster.__parent;
2902
2903					if (cluster._icon) {
2904						//Cluster is currently on the map, need to put the marker on the map instead
2905						fg.removeLayer(cluster);
2906						if (!dontUpdateMap) {
2907							fg.addLayer(otherMarker);
2908						}
2909					}
2910				} else {
2911					cluster._iconNeedsUpdate = true;
2912				}
2913
2914				cluster = cluster.__parent;
2915			}
2916
2917			delete marker.__parent;
2918		},
2919
2920		_isOrIsParent: function (el, oel) {
2921			while (oel) {
2922				if (el === oel) {
2923					return true;
2924				}
2925				oel = oel.parentNode;
2926			}
2927			return false;
2928		},
2929
2930		//Override L.Evented.fire
2931		fire: function (type, data, propagate) {
2932			if (data && data.layer instanceof L.MarkerCluster) {
2933				//Prevent multiple clustermouseover/off events if the icon is made up of stacked divs (Doesn't work in ie <= 8, no relatedTarget)
2934				if (data.originalEvent && this._isOrIsParent(data.layer._icon, data.originalEvent.relatedTarget)) {
2935					return;
2936				}
2937				type = 'cluster' + type;
2938			}
2939
2940			L.FeatureGroup.prototype.fire.call(this, type, data, propagate);
2941		},
2942
2943		//Override L.Evented.listens
2944		listens: function (type, propagate) {
2945			return L.FeatureGroup.prototype.listens.call(this, type, propagate) || L.FeatureGroup.prototype.listens.call(this, 'cluster' + type, propagate);
2946		},
2947
2948		//Default functionality
2949		_defaultIconCreateFunction: function (cluster) {
2950			var childCount = cluster.getChildCount();
2951
2952			var c = ' marker-cluster-';
2953			if (childCount < 10) {
2954				c += 'small';
2955			} else if (childCount < 100) {
2956				c += 'medium';
2957			} else {
2958				c += 'large';
2959			}
2960
2961			return new L.DivIcon({ html: '<div><span>' + childCount + '</span></div>', className: 'marker-cluster' + c, iconSize: new L.Point(40, 40) });
2962		},
2963
2964		_bindEvents: function () {
2965			var map = this._map,
2966			    spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom,
2967			    showCoverageOnHover = this.options.showCoverageOnHover,
2968			    zoomToBoundsOnClick = this.options.zoomToBoundsOnClick,
2969			    spiderfyOnEveryZoom = this.options.spiderfyOnEveryZoom;
2970
2971			//Zoom on cluster click or spiderfy if we are at the lowest level
2972			if (spiderfyOnMaxZoom || zoomToBoundsOnClick || spiderfyOnEveryZoom) {
2973				this.on('clusterclick clusterkeypress', this._zoomOrSpiderfy, this);
2974			}
2975
2976			//Show convex hull (boundary) polygon on mouse over
2977			if (showCoverageOnHover) {
2978				this.on('clustermouseover', this._showCoverage, this);
2979				this.on('clustermouseout', this._hideCoverage, this);
2980				map.on('zoomend', this._hideCoverage, this);
2981			}
2982		},
2983
2984		_zoomOrSpiderfy: function (e) {
2985			var cluster = e.layer,
2986			    bottomCluster = cluster;
2987
2988			if (e.type === 'clusterkeypress' && e.originalEvent && e.originalEvent.keyCode !== 13) {
2989				return;
2990			}
2991
2992			while (bottomCluster._childClusters.length === 1) {
2993				bottomCluster = bottomCluster._childClusters[0];
2994			}
2995
2996			if (bottomCluster._zoom === this._maxZoom &&
2997				bottomCluster._childCount === cluster._childCount &&
2998				this.options.spiderfyOnMaxZoom) {
2999
3000				// All child markers are contained in a single cluster from this._maxZoom to this cluster.
3001				cluster.spiderfy();
3002			} else if (this.options.zoomToBoundsOnClick) {
3003				cluster.zoomToBounds();
3004			}
3005
3006			if (this.options.spiderfyOnEveryZoom) {
3007				cluster.spiderfy();
3008			}
3009
3010			// Focus the map again for keyboard users.
3011			if (e.originalEvent && e.originalEvent.keyCode === 13) {
3012				this._map._container.focus();
3013			}
3014		},
3015
3016		_showCoverage: function (e) {
3017			var map = this._map;
3018			if (this._inZoomAnimation) {
3019				return;
3020			}
3021			if (this._shownPolygon) {
3022				map.removeLayer(this._shownPolygon);
3023			}
3024			if (e.layer.getChildCount() > 2 && e.layer !== this._spiderfied) {
3025				this._shownPolygon = new L.Polygon(e.layer.getConvexHull(), this.options.polygonOptions);
3026				map.addLayer(this._shownPolygon);
3027			}
3028		},
3029
3030		_hideCoverage: function () {
3031			if (this._shownPolygon) {
3032				this._map.removeLayer(this._shownPolygon);
3033				this._shownPolygon = null;
3034			}
3035		},
3036
3037		_unbindEvents: function () {
3038			var spiderfyOnMaxZoom = this.options.spiderfyOnMaxZoom,
3039				showCoverageOnHover = this.options.showCoverageOnHover,
3040				zoomToBoundsOnClick = this.options.zoomToBoundsOnClick,
3041				spiderfyOnEveryZoom = this.options.spiderfyOnEveryZoom,
3042				map = this._map;
3043
3044			if (spiderfyOnMaxZoom || zoomToBoundsOnClick || spiderfyOnEveryZoom) {
3045				this.off('clusterclick clusterkeypress', this._zoomOrSpiderfy, this);
3046			}
3047			if (showCoverageOnHover) {
3048				this.off('clustermouseover', this._showCoverage, this);
3049				this.off('clustermouseout', this._hideCoverage, this);
3050				map.off('zoomend', this._hideCoverage, this);
3051			}
3052		},
3053
3054		_zoomEnd: function () {
3055			if (!this._map) { //May have been removed from the map by a zoomEnd handler
3056				return;
3057			}
3058			this._mergeSplitClusters();
3059
3060			this._zoom = Math.round(this._map._zoom);
3061			this._currentShownBounds = this._getExpandedVisibleBounds();
3062		},
3063
3064		_moveEnd: function () {
3065			if (this._inZoomAnimation) {
3066				return;
3067			}
3068
3069			var newBounds = this._getExpandedVisibleBounds();
3070
3071			this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), this._zoom, newBounds);
3072			this._topClusterLevel._recursivelyAddChildrenToMap(null, Math.round(this._map._zoom), newBounds);
3073
3074			this._currentShownBounds = newBounds;
3075			return;
3076		},
3077
3078		_generateInitialClusters: function () {
3079			var maxZoom = Math.ceil(this._map.getMaxZoom()),
3080				minZoom = Math.floor(this._map.getMinZoom()),
3081				radius = this.options.maxClusterRadius,
3082				radiusFn = radius;
3083
3084			//If we just set maxClusterRadius to a single number, we need to create
3085			//a simple function to return that number. Otherwise, we just have to
3086			//use the function we've passed in.
3087			if (typeof radius !== "function") {
3088				radiusFn = function () { return radius; };
3089			}
3090
3091			if (this.options.disableClusteringAtZoom !== null) {
3092				maxZoom = this.options.disableClusteringAtZoom - 1;
3093			}
3094			this._maxZoom = maxZoom;
3095			this._gridClusters = {};
3096			this._gridUnclustered = {};
3097
3098			//Set up DistanceGrids for each zoom
3099			for (var zoom = maxZoom; zoom >= minZoom; zoom--) {
3100				this._gridClusters[zoom] = new L.DistanceGrid(radiusFn(zoom));
3101				this._gridUnclustered[zoom] = new L.DistanceGrid(radiusFn(zoom));
3102			}
3103
3104			// Instantiate the appropriate L.MarkerCluster class (animated or not).
3105			this._topClusterLevel = new this._markerCluster(this, minZoom - 1);
3106		},
3107
3108		//Zoom: Zoom to start adding at (Pass this._maxZoom to start at the bottom)
3109		_addLayer: function (layer, zoom) {
3110			var gridClusters = this._gridClusters,
3111			    gridUnclustered = this._gridUnclustered,
3112				minZoom = Math.floor(this._map.getMinZoom()),
3113			    markerPoint, z;
3114
3115			if (this.options.singleMarkerMode) {
3116				this._overrideMarkerIcon(layer);
3117			}
3118
3119			layer.on(this._childMarkerEventHandlers, this);
3120
3121			//Find the lowest zoom level to slot this one in
3122			for (; zoom >= minZoom; zoom--) {
3123				markerPoint = this._map.project(layer.getLatLng(), zoom); // calculate pixel position
3124
3125				//Try find a cluster close by
3126				var closest = gridClusters[zoom].getNearObject(markerPoint);
3127				if (closest) {
3128					closest._addChild(layer);
3129					layer.__parent = closest;
3130					return;
3131				}
3132
3133				//Try find a marker close by to form a new cluster with
3134				closest = gridUnclustered[zoom].getNearObject(markerPoint);
3135				if (closest) {
3136					var parent = closest.__parent;
3137					if (parent) {
3138						this._removeLayer(closest, false);
3139					}
3140
3141					//Create new cluster with these 2 in it
3142
3143					var newCluster = new this._markerCluster(this, zoom, closest, layer);
3144					gridClusters[zoom].addObject(newCluster, this._map.project(newCluster._cLatLng, zoom));
3145					closest.__parent = newCluster;
3146					layer.__parent = newCluster;
3147
3148					//First create any new intermediate parent clusters that don't exist
3149					var lastParent = newCluster;
3150					for (z = zoom - 1; z > parent._zoom; z--) {
3151						lastParent = new this._markerCluster(this, z, lastParent);
3152						gridClusters[z].addObject(lastParent, this._map.project(closest.getLatLng(), z));
3153					}
3154					parent._addChild(lastParent);
3155
3156					//Remove closest from this zoom level and any above that it is in, replace with newCluster
3157					this._removeFromGridUnclustered(closest, zoom);
3158
3159					return;
3160				}
3161
3162				//Didn't manage to cluster in at this zoom, record us as a marker here and continue upwards
3163				gridUnclustered[zoom].addObject(layer, markerPoint);
3164			}
3165
3166			//Didn't get in anything, add us to the top
3167			this._topClusterLevel._addChild(layer);
3168			layer.__parent = this._topClusterLevel;
3169			return;
3170		},
3171
3172		/**
3173		 * Refreshes the icon of all "dirty" visible clusters.
3174		 * Non-visible "dirty" clusters will be updated when they are added to the map.
3175		 * @private
3176		 */
3177		_refreshClustersIcons: function () {
3178			this._featureGroup.eachLayer(function (c) {
3179				if (c instanceof L.MarkerCluster && c._iconNeedsUpdate) {
3180					c._updateIcon();
3181				}
3182			});
3183		},
3184
3185		//Enqueue code to fire after the marker expand/contract has happened
3186		_enqueue: function (fn) {
3187			this._queue.push(fn);
3188			if (!this._queueTimeout) {
3189				this._queueTimeout = setTimeout(L.bind(this._processQueue, this), 300);
3190			}
3191		},
3192		_processQueue: function () {
3193			for (var i = 0; i < this._queue.length; i++) {
3194				this._queue[i].call(this);
3195			}
3196			this._queue.length = 0;
3197			clearTimeout(this._queueTimeout);
3198			this._queueTimeout = null;
3199		},
3200
3201		//Merge and split any existing clusters that are too big or small
3202		_mergeSplitClusters: function () {
3203			var mapZoom = Math.round(this._map._zoom);
3204
3205			//In case we are starting to split before the animation finished
3206			this._processQueue();
3207
3208			if (this._zoom < mapZoom && this._currentShownBounds.intersects(this._getExpandedVisibleBounds())) { //Zoom in, split
3209				this._animationStart();
3210				//Remove clusters now off screen
3211				this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), this._zoom, this._getExpandedVisibleBounds());
3212
3213				this._animationZoomIn(this._zoom, mapZoom);
3214
3215			} else if (this._zoom > mapZoom) { //Zoom out, merge
3216				this._animationStart();
3217
3218				this._animationZoomOut(this._zoom, mapZoom);
3219			} else {
3220				this._moveEnd();
3221			}
3222		},
3223
3224		//Gets the maps visible bounds expanded in each direction by the size of the screen (so the user cannot see an area we do not cover in one pan)
3225		_getExpandedVisibleBounds: function () {
3226			if (!this.options.removeOutsideVisibleBounds) {
3227				return this._mapBoundsInfinite;
3228			} else if (L.Browser.mobile) {
3229				return this._checkBoundsMaxLat(this._map.getBounds());
3230			}
3231
3232			return this._checkBoundsMaxLat(this._map.getBounds().pad(1)); // Padding expands the bounds by its own dimensions but scaled with the given factor.
3233		},
3234
3235		/**
3236		 * Expands the latitude to Infinity (or -Infinity) if the input bounds reach the map projection maximum defined latitude
3237		 * (in the case of Web/Spherical Mercator, it is 85.0511287798 / see https://en.wikipedia.org/wiki/Web_Mercator#Formulas).
3238		 * Otherwise, the removeOutsideVisibleBounds option will remove markers beyond that limit, whereas the same markers without
3239		 * this option (or outside MCG) will have their position floored (ceiled) by the projection and rendered at that limit,
3240		 * making the user think that MCG "eats" them and never displays them again.
3241		 * @param bounds L.LatLngBounds
3242		 * @returns {L.LatLngBounds}
3243		 * @private
3244		 */
3245		_checkBoundsMaxLat: function (bounds) {
3246			var maxLat = this._maxLat;
3247
3248			if (maxLat !== undefined) {
3249				if (bounds.getNorth() >= maxLat) {
3250					bounds._northEast.lat = Infinity;
3251				}
3252				if (bounds.getSouth() <= -maxLat) {
3253					bounds._southWest.lat = -Infinity;
3254				}
3255			}
3256
3257			return bounds;
3258		},
3259
3260		//Shared animation code
3261		_animationAddLayerNonAnimated: function (layer, newCluster) {
3262			if (newCluster === layer) {
3263				this._featureGroup.addLayer(layer);
3264			} else if (newCluster._childCount === 2) {
3265				newCluster._addToMap();
3266
3267				var markers = newCluster.getAllChildMarkers();
3268				this._featureGroup.removeLayer(markers[0]);
3269				this._featureGroup.removeLayer(markers[1]);
3270			} else {
3271				newCluster._updateIcon();
3272			}
3273		},
3274
3275		/**
3276		 * Extracts individual (i.e. non-group) layers from a Layer Group.
3277		 * @param group to extract layers from.
3278		 * @param output {Array} in which to store the extracted layers.
3279		 * @returns {*|Array}
3280		 * @private
3281		 */
3282		_extractNonGroupLayers: function (group, output) {
3283			var layers = group.getLayers(),
3284			    i = 0,
3285			    layer;
3286
3287			output = output || [];
3288
3289			for (; i < layers.length; i++) {
3290				layer = layers[i];
3291
3292				if (layer instanceof L.LayerGroup) {
3293					this._extractNonGroupLayers(layer, output);
3294					continue;
3295				}
3296
3297				output.push(layer);
3298			}
3299
3300			return output;
3301		},
3302
3303		/**
3304		 * Implements the singleMarkerMode option.
3305		 * @param layer Marker to re-style using the Clusters iconCreateFunction.
3306		 * @returns {L.Icon} The newly created icon.
3307		 * @private
3308		 */
3309		_overrideMarkerIcon: function (layer) {
3310			var icon = layer.options.icon = this.options.iconCreateFunction({
3311				getChildCount: function () {
3312					return 1;
3313				},
3314				getAllChildMarkers: function () {
3315					return [layer];
3316				}
3317			});
3318
3319			return icon;
3320		}
3321	});
3322
3323	// Constant bounds used in case option "removeOutsideVisibleBounds" is set to false.
3324	L.MarkerClusterGroup.include({
3325		_mapBoundsInfinite: new L.LatLngBounds(new L.LatLng(-Infinity, -Infinity), new L.LatLng(Infinity, Infinity))
3326	});
3327
3328	L.MarkerClusterGroup.include({
3329		_noAnimation: {
3330			//Non Animated versions of everything
3331			_animationStart: function () {
3332				//Do nothing...
3333			},
3334			_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
3335				this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel);
3336				this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
3337
3338				//We didn't actually animate, but we use this event to mean "clustering animations have finished"
3339				this.fire('animationend');
3340			},
3341			_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
3342				this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel);
3343				this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
3344
3345				//We didn't actually animate, but we use this event to mean "clustering animations have finished"
3346				this.fire('animationend');
3347			},
3348			_animationAddLayer: function (layer, newCluster) {
3349				this._animationAddLayerNonAnimated(layer, newCluster);
3350			}
3351		},
3352
3353		_withAnimation: {
3354			//Animated versions here
3355			_animationStart: function () {
3356				this._map._mapPane.className += ' leaflet-cluster-anim';
3357				this._inZoomAnimation++;
3358			},
3359
3360			_animationZoomIn: function (previousZoomLevel, newZoomLevel) {
3361				var bounds = this._getExpandedVisibleBounds(),
3362				    fg = this._featureGroup,
3363					minZoom = Math.floor(this._map.getMinZoom()),
3364				    i;
3365
3366				this._ignoreMove = true;
3367
3368				//Add all children of current clusters to map and remove those clusters from map
3369				this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
3370					var startPos = c._latlng,
3371					    markers  = c._markers,
3372					    m;
3373
3374					if (!bounds.contains(startPos)) {
3375						startPos = null;
3376					}
3377
3378					if (c._isSingleParent() && previousZoomLevel + 1 === newZoomLevel) { //Immediately add the new child and remove us
3379						fg.removeLayer(c);
3380						c._recursivelyAddChildrenToMap(null, newZoomLevel, bounds);
3381					} else {
3382						//Fade out old cluster
3383						c.clusterHide();
3384						c._recursivelyAddChildrenToMap(startPos, newZoomLevel, bounds);
3385					}
3386
3387					//Remove all markers that aren't visible any more
3388					//TODO: Do we actually need to do this on the higher levels too?
3389					for (i = markers.length - 1; i >= 0; i--) {
3390						m = markers[i];
3391						if (!bounds.contains(m._latlng)) {
3392							fg.removeLayer(m);
3393						}
3394					}
3395
3396				});
3397
3398				this._forceLayout();
3399
3400				//Update opacities
3401				this._topClusterLevel._recursivelyBecomeVisible(bounds, newZoomLevel);
3402				//TODO Maybe? Update markers in _recursivelyBecomeVisible
3403				fg.eachLayer(function (n) {
3404					if (!(n instanceof L.MarkerCluster) && n._icon) {
3405						n.clusterShow();
3406					}
3407				});
3408
3409				//update the positions of the just added clusters/markers
3410				this._topClusterLevel._recursively(bounds, previousZoomLevel, newZoomLevel, function (c) {
3411					c._recursivelyRestoreChildPositions(newZoomLevel);
3412				});
3413
3414				this._ignoreMove = false;
3415
3416				//Remove the old clusters and close the zoom animation
3417				this._enqueue(function () {
3418					//update the positions of the just added clusters/markers
3419					this._topClusterLevel._recursively(bounds, previousZoomLevel, minZoom, function (c) {
3420						fg.removeLayer(c);
3421						c.clusterShow();
3422					});
3423
3424					this._animationEnd();
3425				});
3426			},
3427
3428			_animationZoomOut: function (previousZoomLevel, newZoomLevel) {
3429				this._animationZoomOutSingle(this._topClusterLevel, previousZoomLevel - 1, newZoomLevel);
3430
3431				//Need to add markers for those that weren't on the map before but are now
3432				this._topClusterLevel._recursivelyAddChildrenToMap(null, newZoomLevel, this._getExpandedVisibleBounds());
3433				//Remove markers that were on the map before but won't be now
3434				this._topClusterLevel._recursivelyRemoveChildrenFromMap(this._currentShownBounds, Math.floor(this._map.getMinZoom()), previousZoomLevel, this._getExpandedVisibleBounds());
3435			},
3436
3437			_animationAddLayer: function (layer, newCluster) {
3438				var me = this,
3439				    fg = this._featureGroup;
3440
3441				fg.addLayer(layer);
3442				if (newCluster !== layer) {
3443					if (newCluster._childCount > 2) { //Was already a cluster
3444
3445						newCluster._updateIcon();
3446						this._forceLayout();
3447						this._animationStart();
3448
3449						layer._setPos(this._map.latLngToLayerPoint(newCluster.getLatLng()));
3450						layer.clusterHide();
3451
3452						this._enqueue(function () {
3453							fg.removeLayer(layer);
3454							layer.clusterShow();
3455
3456							me._animationEnd();
3457						});
3458
3459					} else { //Just became a cluster
3460						this._forceLayout();
3461
3462						me._animationStart();
3463						me._animationZoomOutSingle(newCluster, this._map.getMaxZoom(), this._zoom);
3464					}
3465				}
3466			}
3467		},
3468
3469		// Private methods for animated versions.
3470		_animationZoomOutSingle: function (cluster, previousZoomLevel, newZoomLevel) {
3471			var bounds = this._getExpandedVisibleBounds(),
3472				minZoom = Math.floor(this._map.getMinZoom());
3473
3474			//Animate all of the markers in the clusters to move to their cluster center point
3475			cluster._recursivelyAnimateChildrenInAndAddSelfToMap(bounds, minZoom, previousZoomLevel + 1, newZoomLevel);
3476
3477			var me = this;
3478
3479			//Update the opacity (If we immediately set it they won't animate)
3480			this._forceLayout();
3481			cluster._recursivelyBecomeVisible(bounds, newZoomLevel);
3482
3483			//TODO: Maybe use the transition timing stuff to make this more reliable
3484			//When the animations are done, tidy up
3485			this._enqueue(function () {
3486
3487				//This cluster stopped being a cluster before the timeout fired
3488				if (cluster._childCount === 1) {
3489					var m = cluster._markers[0];
3490					//If we were in a cluster animation at the time then the opacity and position of our child could be wrong now, so fix it
3491					this._ignoreMove = true;
3492					m.setLatLng(m.getLatLng());
3493					this._ignoreMove = false;
3494					if (m.clusterShow) {
3495						m.clusterShow();
3496					}
3497				} else {
3498					cluster._recursively(bounds, newZoomLevel, minZoom, function (c) {
3499						c._recursivelyRemoveChildrenFromMap(bounds, minZoom, previousZoomLevel + 1);
3500					});
3501				}
3502				me._animationEnd();
3503			});
3504		},
3505
3506		_animationEnd: function () {
3507			if (this._map) {
3508				this._map._mapPane.className = this._map._mapPane.className.replace(' leaflet-cluster-anim', '');
3509			}
3510			this._inZoomAnimation--;
3511			this.fire('animationend');
3512		},
3513
3514		//Force a browser layout of stuff in the map
3515		// Should apply the current opacity and location to all elements so we can update them again for an animation
3516		_forceLayout: function () {
3517			//In my testing this works, infact offsetWidth of any element seems to work.
3518			//Could loop all this._layers and do this for each _icon if it stops working
3519
3520			L.Util.falseFn(document.body.offsetWidth);
3521		}
3522	});
3523
3524	L.markerClusterGroup = function (options) {
3525		return new L.MarkerClusterGroup(options);
3526	};
3527
3528	var MarkerCluster = L.MarkerCluster = L.Marker.extend({
3529		options: L.Icon.prototype.options,
3530
3531		initialize: function (group, zoom, a, b) {
3532
3533			L.Marker.prototype.initialize.call(this, a ? (a._cLatLng || a.getLatLng()) : new L.LatLng(0, 0),
3534	            { icon: this, pane: group.options.clusterPane });
3535
3536			this._group = group;
3537			this._zoom = zoom;
3538
3539			this._markers = [];
3540			this._childClusters = [];
3541			this._childCount = 0;
3542			this._iconNeedsUpdate = true;
3543			this._boundsNeedUpdate = true;
3544
3545			this._bounds = new L.LatLngBounds();
3546
3547			if (a) {
3548				this._addChild(a);
3549			}
3550			if (b) {
3551				this._addChild(b);
3552			}
3553		},
3554
3555		//Recursively retrieve all child markers of this cluster
3556		getAllChildMarkers: function (storageArray, ignoreDraggedMarker) {
3557			storageArray = storageArray || [];
3558
3559			for (var i = this._childClusters.length - 1; i >= 0; i--) {
3560				this._childClusters[i].getAllChildMarkers(storageArray, ignoreDraggedMarker);
3561			}
3562
3563			for (var j = this._markers.length - 1; j >= 0; j--) {
3564				if (ignoreDraggedMarker && this._markers[j].__dragStart) {
3565					continue;
3566				}
3567				storageArray.push(this._markers[j]);
3568			}
3569
3570			return storageArray;
3571		},
3572
3573		//Returns the count of how many child markers we have
3574		getChildCount: function () {
3575			return this._childCount;
3576		},
3577
3578		//Zoom to the minimum of showing all of the child markers, or the extents of this cluster
3579		zoomToBounds: function (fitBoundsOptions) {
3580			var childClusters = this._childClusters.slice(),
3581				map = this._group._map,
3582				boundsZoom = map.getBoundsZoom(this._bounds),
3583				zoom = this._zoom + 1,
3584				mapZoom = map.getZoom(),
3585				i;
3586
3587			//calculate how far we need to zoom down to see all of the markers
3588			while (childClusters.length > 0 && boundsZoom > zoom) {
3589				zoom++;
3590				var newClusters = [];
3591				for (i = 0; i < childClusters.length; i++) {
3592					newClusters = newClusters.concat(childClusters[i]._childClusters);
3593				}
3594				childClusters = newClusters;
3595			}
3596
3597			if (boundsZoom > zoom) {
3598				this._group._map.setView(this._latlng, zoom);
3599			} else if (boundsZoom <= mapZoom) { //If fitBounds wouldn't zoom us down, zoom us down instead
3600				this._group._map.setView(this._latlng, mapZoom + 1);
3601			} else {
3602				this._group._map.fitBounds(this._bounds, fitBoundsOptions);
3603			}
3604		},
3605
3606		getBounds: function () {
3607			var bounds = new L.LatLngBounds();
3608			bounds.extend(this._bounds);
3609			return bounds;
3610		},
3611
3612		_updateIcon: function () {
3613			this._iconNeedsUpdate = true;
3614			if (this._icon) {
3615				this.setIcon(this);
3616			}
3617		},
3618
3619		//Cludge for Icon, we pretend to be an icon for performance
3620		createIcon: function () {
3621			if (this._iconNeedsUpdate) {
3622				this._iconObj = this._group.options.iconCreateFunction(this);
3623				this._iconNeedsUpdate = false;
3624			}
3625			return this._iconObj.createIcon();
3626		},
3627		createShadow: function () {
3628			return this._iconObj.createShadow();
3629		},
3630
3631
3632		_addChild: function (new1, isNotificationFromChild) {
3633
3634			this._iconNeedsUpdate = true;
3635
3636			this._boundsNeedUpdate = true;
3637			this._setClusterCenter(new1);
3638
3639			if (new1 instanceof L.MarkerCluster) {
3640				if (!isNotificationFromChild) {
3641					this._childClusters.push(new1);
3642					new1.__parent = this;
3643				}
3644				this._childCount += new1._childCount;
3645			} else {
3646				if (!isNotificationFromChild) {
3647					this._markers.push(new1);
3648				}
3649				this._childCount++;
3650			}
3651
3652			if (this.__parent) {
3653				this.__parent._addChild(new1, true);
3654			}
3655		},
3656
3657		/**
3658		 * Makes sure the cluster center is set. If not, uses the child center if it is a cluster, or the marker position.
3659		 * @param child L.MarkerCluster|L.Marker that will be used as cluster center if not defined yet.
3660		 * @private
3661		 */
3662		_setClusterCenter: function (child) {
3663			if (!this._cLatLng) {
3664				// when clustering, take position of the first point as the cluster center
3665				this._cLatLng = child._cLatLng || child._latlng;
3666			}
3667		},
3668
3669		/**
3670		 * Assigns impossible bounding values so that the next extend entirely determines the new bounds.
3671		 * This method avoids having to trash the previous L.LatLngBounds object and to create a new one, which is much slower for this class.
3672		 * As long as the bounds are not extended, most other methods would probably fail, as they would with bounds initialized but not extended.
3673		 * @private
3674		 */
3675		_resetBounds: function () {
3676			var bounds = this._bounds;
3677
3678			if (bounds._southWest) {
3679				bounds._southWest.lat = Infinity;
3680				bounds._southWest.lng = Infinity;
3681			}
3682			if (bounds._northEast) {
3683				bounds._northEast.lat = -Infinity;
3684				bounds._northEast.lng = -Infinity;
3685			}
3686		},
3687
3688		_recalculateBounds: function () {
3689			var markers = this._markers,
3690			    childClusters = this._childClusters,
3691			    latSum = 0,
3692			    lngSum = 0,
3693			    totalCount = this._childCount,
3694			    i, child, childLatLng, childCount;
3695
3696			// Case where all markers are removed from the map and we are left with just an empty _topClusterLevel.
3697			if (totalCount === 0) {
3698				return;
3699			}
3700
3701			// Reset rather than creating a new object, for performance.
3702			this._resetBounds();
3703
3704			// Child markers.
3705			for (i = 0; i < markers.length; i++) {
3706				childLatLng = markers[i]._latlng;
3707
3708				this._bounds.extend(childLatLng);
3709
3710				latSum += childLatLng.lat;
3711				lngSum += childLatLng.lng;
3712			}
3713
3714			// Child clusters.
3715			for (i = 0; i < childClusters.length; i++) {
3716				child = childClusters[i];
3717
3718				// Re-compute child bounds and weighted position first if necessary.
3719				if (child._boundsNeedUpdate) {
3720					child._recalculateBounds();
3721				}
3722
3723				this._bounds.extend(child._bounds);
3724
3725				childLatLng = child._wLatLng;
3726				childCount = child._childCount;
3727
3728				latSum += childLatLng.lat * childCount;
3729				lngSum += childLatLng.lng * childCount;
3730			}
3731
3732			this._latlng = this._wLatLng = new L.LatLng(latSum / totalCount, lngSum / totalCount);
3733
3734			// Reset dirty flag.
3735			this._boundsNeedUpdate = false;
3736		},
3737
3738		//Set our markers position as given and add it to the map
3739		_addToMap: function (startPos) {
3740			if (startPos) {
3741				this._backupLatlng = this._latlng;
3742				this.setLatLng(startPos);
3743			}
3744			this._group._featureGroup.addLayer(this);
3745		},
3746
3747		_recursivelyAnimateChildrenIn: function (bounds, center, maxZoom) {
3748			this._recursively(bounds, this._group._map.getMinZoom(), maxZoom - 1,
3749				function (c) {
3750					var markers = c._markers,
3751						i, m;
3752					for (i = markers.length - 1; i >= 0; i--) {
3753						m = markers[i];
3754
3755						//Only do it if the icon is still on the map
3756						if (m._icon) {
3757							m._setPos(center);
3758							m.clusterHide();
3759						}
3760					}
3761				},
3762				function (c) {
3763					var childClusters = c._childClusters,
3764						j, cm;
3765					for (j = childClusters.length - 1; j >= 0; j--) {
3766						cm = childClusters[j];
3767						if (cm._icon) {
3768							cm._setPos(center);
3769							cm.clusterHide();
3770						}
3771					}
3772				}
3773			);
3774		},
3775
3776		_recursivelyAnimateChildrenInAndAddSelfToMap: function (bounds, mapMinZoom, previousZoomLevel, newZoomLevel) {
3777			this._recursively(bounds, newZoomLevel, mapMinZoom,
3778				function (c) {
3779					c._recursivelyAnimateChildrenIn(bounds, c._group._map.latLngToLayerPoint(c.getLatLng()).round(), previousZoomLevel);
3780
3781					//TODO: depthToAnimateIn affects _isSingleParent, if there is a multizoom we may/may not be.
3782					//As a hack we only do a animation free zoom on a single level zoom, if someone does multiple levels then we always animate
3783					if (c._isSingleParent() && previousZoomLevel - 1 === newZoomLevel) {
3784						c.clusterShow();
3785						c._recursivelyRemoveChildrenFromMap(bounds, mapMinZoom, previousZoomLevel); //Immediately remove our children as we are replacing them. TODO previousBounds not bounds
3786					} else {
3787						c.clusterHide();
3788					}
3789
3790					c._addToMap();
3791				}
3792			);
3793		},
3794
3795		_recursivelyBecomeVisible: function (bounds, zoomLevel) {
3796			this._recursively(bounds, this._group._map.getMinZoom(), zoomLevel, null, function (c) {
3797				c.clusterShow();
3798			});
3799		},
3800
3801		_recursivelyAddChildrenToMap: function (startPos, zoomLevel, bounds) {
3802			this._recursively(bounds, this._group._map.getMinZoom() - 1, zoomLevel,
3803				function (c) {
3804					if (zoomLevel === c._zoom) {
3805						return;
3806					}
3807
3808					//Add our child markers at startPos (so they can be animated out)
3809					for (var i = c._markers.length - 1; i >= 0; i--) {
3810						var nm = c._markers[i];
3811
3812						if (!bounds.contains(nm._latlng)) {
3813							continue;
3814						}
3815
3816						if (startPos) {
3817							nm._backupLatlng = nm.getLatLng();
3818
3819							nm.setLatLng(startPos);
3820							if (nm.clusterHide) {
3821								nm.clusterHide();
3822							}
3823						}
3824
3825						c._group._featureGroup.addLayer(nm);
3826					}
3827				},
3828				function (c) {
3829					c._addToMap(startPos);
3830				}
3831			);
3832		},
3833
3834		_recursivelyRestoreChildPositions: function (zoomLevel) {
3835			//Fix positions of child markers
3836			for (var i = this._markers.length - 1; i >= 0; i--) {
3837				var nm = this._markers[i];
3838				if (nm._backupLatlng) {
3839					nm.setLatLng(nm._backupLatlng);
3840					delete nm._backupLatlng;
3841				}
3842			}
3843
3844			if (zoomLevel - 1 === this._zoom) {
3845				//Reposition child clusters
3846				for (var j = this._childClusters.length - 1; j >= 0; j--) {
3847					this._childClusters[j]._restorePosition();
3848				}
3849			} else {
3850				for (var k = this._childClusters.length - 1; k >= 0; k--) {
3851					this._childClusters[k]._recursivelyRestoreChildPositions(zoomLevel);
3852				}
3853			}
3854		},
3855
3856		_restorePosition: function () {
3857			if (this._backupLatlng) {
3858				this.setLatLng(this._backupLatlng);
3859				delete this._backupLatlng;
3860			}
3861		},
3862
3863		//exceptBounds: If set, don't remove any markers/clusters in it
3864		_recursivelyRemoveChildrenFromMap: function (previousBounds, mapMinZoom, zoomLevel, exceptBounds) {
3865			var m, i;
3866			this._recursively(previousBounds, mapMinZoom - 1, zoomLevel - 1,
3867				function (c) {
3868					//Remove markers at every level
3869					for (i = c._markers.length - 1; i >= 0; i--) {
3870						m = c._markers[i];
3871						if (!exceptBounds || !exceptBounds.contains(m._latlng)) {
3872							c._group._featureGroup.removeLayer(m);
3873							if (m.clusterShow) {
3874								m.clusterShow();
3875							}
3876						}
3877					}
3878				},
3879				function (c) {
3880					//Remove child clusters at just the bottom level
3881					for (i = c._childClusters.length - 1; i >= 0; i--) {
3882						m = c._childClusters[i];
3883						if (!exceptBounds || !exceptBounds.contains(m._latlng)) {
3884							c._group._featureGroup.removeLayer(m);
3885							if (m.clusterShow) {
3886								m.clusterShow();
3887							}
3888						}
3889					}
3890				}
3891			);
3892		},
3893
3894		//Run the given functions recursively to this and child clusters
3895		// boundsToApplyTo: a L.LatLngBounds representing the bounds of what clusters to recurse in to
3896		// zoomLevelToStart: zoom level to start running functions (inclusive)
3897		// zoomLevelToStop: zoom level to stop running functions (inclusive)
3898		// runAtEveryLevel: function that takes an L.MarkerCluster as an argument that should be applied on every level
3899		// runAtBottomLevel: function that takes an L.MarkerCluster as an argument that should be applied at only the bottom level
3900		_recursively: function (boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel) {
3901			var childClusters = this._childClusters,
3902			    zoom = this._zoom,
3903			    i, c;
3904
3905			if (zoomLevelToStart <= zoom) {
3906				if (runAtEveryLevel) {
3907					runAtEveryLevel(this);
3908				}
3909				if (runAtBottomLevel && zoom === zoomLevelToStop) {
3910					runAtBottomLevel(this);
3911				}
3912			}
3913
3914			if (zoom < zoomLevelToStart || zoom < zoomLevelToStop) {
3915				for (i = childClusters.length - 1; i >= 0; i--) {
3916					c = childClusters[i];
3917					if (c._boundsNeedUpdate) {
3918						c._recalculateBounds();
3919					}
3920					if (boundsToApplyTo.intersects(c._bounds)) {
3921						c._recursively(boundsToApplyTo, zoomLevelToStart, zoomLevelToStop, runAtEveryLevel, runAtBottomLevel);
3922					}
3923				}
3924			}
3925		},
3926
3927		//Returns true if we are the parent of only one cluster and that cluster is the same as us
3928		_isSingleParent: function () {
3929			//Don't need to check this._markers as the rest won't work if there are any
3930			return this._childClusters.length > 0 && this._childClusters[0]._childCount === this._childCount;
3931		}
3932	});
3933
3934	/*
3935	* Extends L.Marker to include two extra methods: clusterHide and clusterShow.
3936	* 
3937	* They work as setOpacity(0) and setOpacity(1) respectively, but
3938	* don't overwrite the options.opacity
3939	* 
3940	*/
3941
3942	L.Marker.include({
3943		clusterHide: function () {
3944			var backup = this.options.opacity;
3945			this.setOpacity(0);
3946			this.options.opacity = backup;
3947			return this;
3948		},
3949		
3950		clusterShow: function () {
3951			return this.setOpacity(this.options.opacity);
3952		}
3953	});
3954
3955	L.DistanceGrid = function (cellSize) {
3956		this._cellSize = cellSize;
3957		this._sqCellSize = cellSize * cellSize;
3958		this._grid = {};
3959		this._objectPoint = { };
3960	};
3961
3962	L.DistanceGrid.prototype = {
3963
3964		addObject: function (obj, point) {
3965			var x = this._getCoord(point.x),
3966			    y = this._getCoord(point.y),
3967			    grid = this._grid,
3968			    row = grid[y] = grid[y] || {},
3969			    cell = row[x] = row[x] || [],
3970			    stamp = L.Util.stamp(obj);
3971
3972			this._objectPoint[stamp] = point;
3973
3974			cell.push(obj);
3975		},
3976
3977		updateObject: function (obj, point) {
3978			this.removeObject(obj);
3979			this.addObject(obj, point);
3980		},
3981
3982		//Returns true if the object was found
3983		removeObject: function (obj, point) {
3984			var x = this._getCoord(point.x),
3985			    y = this._getCoord(point.y),
3986			    grid = this._grid,
3987			    row = grid[y] = grid[y] || {},
3988			    cell = row[x] = row[x] || [],
3989			    i, len;
3990
3991			delete this._objectPoint[L.Util.stamp(obj)];
3992
3993			for (i = 0, len = cell.length; i < len; i++) {
3994				if (cell[i] === obj) {
3995
3996					cell.splice(i, 1);
3997
3998					if (len === 1) {
3999						delete row[x];
4000					}
4001
4002					return true;
4003				}
4004			}
4005
4006		},
4007
4008		eachObject: function (fn, context) {
4009			var i, j, k, len, row, cell, removed,
4010			    grid = this._grid;
4011
4012			for (i in grid) {
4013				row = grid[i];
4014
4015				for (j in row) {
4016					cell = row[j];
4017
4018					for (k = 0, len = cell.length; k < len; k++) {
4019						removed = fn.call(context, cell[k]);
4020						if (removed) {
4021							k--;
4022							len--;
4023						}
4024					}
4025				}
4026			}
4027		},
4028
4029		getNearObject: function (point) {
4030			var x = this._getCoord(point.x),
4031			    y = this._getCoord(point.y),
4032			    i, j, k, row, cell, len, obj, dist,
4033			    objectPoint = this._objectPoint,
4034			    closestDistSq = this._sqCellSize,
4035			    closest = null;
4036
4037			for (i = y - 1; i <= y + 1; i++) {
4038				row = this._grid[i];
4039				if (row) {
4040
4041					for (j = x - 1; j <= x + 1; j++) {
4042						cell = row[j];
4043						if (cell) {
4044
4045							for (k = 0, len = cell.length; k < len; k++) {
4046								obj = cell[k];
4047								dist = this._sqDist(objectPoint[L.Util.stamp(obj)], point);
4048								if (dist < closestDistSq ||
4049									dist <= closestDistSq && closest === null) {
4050									closestDistSq = dist;
4051									closest = obj;
4052								}
4053							}
4054						}
4055					}
4056				}
4057			}
4058			return closest;
4059		},
4060
4061		_getCoord: function (x) {
4062			var coord = Math.floor(x / this._cellSize);
4063			return isFinite(coord) ? coord : x;
4064		},
4065
4066		_sqDist: function (p, p2) {
4067			var dx = p2.x - p.x,
4068			    dy = p2.y - p.y;
4069			return dx * dx + dy * dy;
4070		}
4071	};
4072
4073	/* Copyright (c) 2012 the authors listed at the following URL, and/or
4074	the authors of referenced articles or incorporated external code:
4075	http://en.literateprograms.org/Quickhull_(Javascript)?action=history&offset=20120410175256
4076
4077	Permission is hereby granted, free of charge, to any person obtaining
4078	a copy of this software and associated documentation files (the
4079	"Software"), to deal in the Software without restriction, including
4080	without limitation the rights to use, copy, modify, merge, publish,
4081	distribute, sublicense, and/or sell copies of the Software, and to
4082	permit persons to whom the Software is furnished to do so, subject to
4083	the following conditions:
4084
4085	The above copyright notice and this permission notice shall be
4086	included in all copies or substantial portions of the Software.
4087
4088	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
4089	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
4090	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
4091	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
4092	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
4093	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
4094	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
4095
4096	Retrieved from: http://en.literateprograms.org/Quickhull_(Javascript)?oldid=18434
4097	*/
4098
4099	(function () {
4100		L.QuickHull = {
4101
4102			/*
4103			 * @param {Object} cpt a point to be measured from the baseline
4104			 * @param {Array} bl the baseline, as represented by a two-element
4105			 *   array of latlng objects.
4106			 * @returns {Number} an approximate distance measure
4107			 */
4108			getDistant: function (cpt, bl) {
4109				var vY = bl[1].lat - bl[0].lat,
4110					vX = bl[0].lng - bl[1].lng;
4111				return (vX * (cpt.lat - bl[0].lat) + vY * (cpt.lng - bl[0].lng));
4112			},
4113
4114			/*
4115			 * @param {Array} baseLine a two-element array of latlng objects
4116			 *   representing the baseline to project from
4117			 * @param {Array} latLngs an array of latlng objects
4118			 * @returns {Object} the maximum point and all new points to stay
4119			 *   in consideration for the hull.
4120			 */
4121			findMostDistantPointFromBaseLine: function (baseLine, latLngs) {
4122				var maxD = 0,
4123					maxPt = null,
4124					newPoints = [],
4125					i, pt, d;
4126
4127				for (i = latLngs.length - 1; i >= 0; i--) {
4128					pt = latLngs[i];
4129					d = this.getDistant(pt, baseLine);
4130
4131					if (d > 0) {
4132						newPoints.push(pt);
4133					} else {
4134						continue;
4135					}
4136
4137					if (d > maxD) {
4138						maxD = d;
4139						maxPt = pt;
4140					}
4141				}
4142
4143				return { maxPoint: maxPt, newPoints: newPoints };
4144			},
4145
4146
4147			/*
4148			 * Given a baseline, compute the convex hull of latLngs as an array
4149			 * of latLngs.
4150			 *
4151			 * @param {Array} latLngs
4152			 * @returns {Array}
4153			 */
4154			buildConvexHull: function (baseLine, latLngs) {
4155				var convexHullBaseLines = [],
4156					t = this.findMostDistantPointFromBaseLine(baseLine, latLngs);
4157
4158				if (t.maxPoint) { // if there is still a point "outside" the base line
4159					convexHullBaseLines =
4160						convexHullBaseLines.concat(
4161							this.buildConvexHull([baseLine[0], t.maxPoint], t.newPoints)
4162						);
4163					convexHullBaseLines =
4164						convexHullBaseLines.concat(
4165							this.buildConvexHull([t.maxPoint, baseLine[1]], t.newPoints)
4166						);
4167					return convexHullBaseLines;
4168				} else {  // if there is no more point "outside" the base line, the current base line is part of the convex hull
4169					return [baseLine[0]];
4170				}
4171			},
4172
4173			/*
4174			 * Given an array of latlngs, compute a convex hull as an array
4175			 * of latlngs
4176			 *
4177			 * @param {Array} latLngs
4178			 * @returns {Array}
4179			 */
4180			getConvexHull: function (latLngs) {
4181				// find first baseline
4182				var maxLat = false, minLat = false,
4183					maxLng = false, minLng = false,
4184					maxLatPt = null, minLatPt = null,
4185					maxLngPt = null, minLngPt = null,
4186					maxPt = null, minPt = null,
4187					i;
4188
4189				for (i = latLngs.length - 1; i >= 0; i--) {
4190					var pt = latLngs[i];
4191					if (maxLat === false || pt.lat > maxLat) {
4192						maxLatPt = pt;
4193						maxLat = pt.lat;
4194					}
4195					if (minLat === false || pt.lat < minLat) {
4196						minLatPt = pt;
4197						minLat = pt.lat;
4198					}
4199					if (maxLng === false || pt.lng > maxLng) {
4200						maxLngPt = pt;
4201						maxLng = pt.lng;
4202					}
4203					if (minLng === false || pt.lng < minLng) {
4204						minLngPt = pt;
4205						minLng = pt.lng;
4206					}
4207				}
4208				
4209				if (minLat !== maxLat) {
4210					minPt = minLatPt;
4211					maxPt = maxLatPt;
4212				} else {
4213					minPt = minLngPt;
4214					maxPt = maxLngPt;
4215				}
4216
4217				var ch = [].concat(this.buildConvexHull([minPt, maxPt], latLngs),
4218									this.buildConvexHull([maxPt, minPt], latLngs));
4219				return ch;
4220			}
4221		};
4222	}());
4223
4224	L.MarkerCluster.include({
4225		getConvexHull: function () {
4226			var childMarkers = this.getAllChildMarkers(),
4227				points = [],
4228				p, i;
4229
4230			for (i = childMarkers.length - 1; i >= 0; i--) {
4231				p = childMarkers[i].getLatLng();
4232				points.push(p);
4233			}
4234
4235			return L.QuickHull.getConvexHull(points);
4236		}
4237	});
4238
4239	//This code is 100% based on https://github.com/jawj/OverlappingMarkerSpiderfier-Leaflet
4240	//Huge thanks to jawj for implementing it first to make my job easy :-)
4241
4242	L.MarkerCluster.include({
4243
4244		_2PI: Math.PI * 2,
4245		_circleFootSeparation: 25, //related to circumference of circle
4246		_circleStartAngle: 0,
4247
4248		_spiralFootSeparation:  28, //related to size of spiral (experiment!)
4249		_spiralLengthStart: 11,
4250		_spiralLengthFactor: 5,
4251
4252		_circleSpiralSwitchover: 9, //show spiral instead of circle from this marker count upwards.
4253									// 0 -> always spiral; Infinity -> always circle
4254
4255		spiderfy: function () {
4256			if (this._group._spiderfied === this || this._group._inZoomAnimation) {
4257				return;
4258			}
4259
4260			var childMarkers = this.getAllChildMarkers(null, true),
4261				group = this._group,
4262				map = group._map,
4263				center = map.latLngToLayerPoint(this._latlng),
4264				positions;
4265
4266			this._group._unspiderfy();
4267			this._group._spiderfied = this;
4268
4269			//TODO Maybe: childMarkers order by distance to center
4270
4271			if (this._group.options.spiderfyShapePositions) {
4272				positions = this._group.options.spiderfyShapePositions(childMarkers.length, center);
4273			} else if (childMarkers.length >= this._circleSpiralSwitchover) {
4274				positions = this._generatePointsSpiral(childMarkers.length, center);
4275			} else {
4276				center.y += 10; // Otherwise circles look wrong => hack for standard blue icon, renders differently for other icons.
4277				positions = this._generatePointsCircle(childMarkers.length, center);
4278			}
4279
4280			this._animationSpiderfy(childMarkers, positions);
4281		},
4282
4283		unspiderfy: function (zoomDetails) {
4284			/// <param Name="zoomDetails">Argument from zoomanim if being called in a zoom animation or null otherwise</param>
4285			if (this._group._inZoomAnimation) {
4286				return;
4287			}
4288			this._animationUnspiderfy(zoomDetails);
4289
4290			this._group._spiderfied = null;
4291		},
4292
4293		_generatePointsCircle: function (count, centerPt) {
4294			var circumference = this._group.options.spiderfyDistanceMultiplier * this._circleFootSeparation * (2 + count),
4295				legLength = circumference / this._2PI,  //radius from circumference
4296				angleStep = this._2PI / count,
4297				res = [],
4298				i, angle;
4299
4300			legLength = Math.max(legLength, 35); // Minimum distance to get outside the cluster icon.
4301
4302			res.length = count;
4303
4304			for (i = 0; i < count; i++) { // Clockwise, like spiral.
4305				angle = this._circleStartAngle + i * angleStep;
4306				res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
4307			}
4308
4309			return res;
4310		},
4311
4312		_generatePointsSpiral: function (count, centerPt) {
4313			var spiderfyDistanceMultiplier = this._group.options.spiderfyDistanceMultiplier,
4314				legLength = spiderfyDistanceMultiplier * this._spiralLengthStart,
4315				separation = spiderfyDistanceMultiplier * this._spiralFootSeparation,
4316				lengthFactor = spiderfyDistanceMultiplier * this._spiralLengthFactor * this._2PI,
4317				angle = 0,
4318				res = [],
4319				i;
4320
4321			res.length = count;
4322
4323			// Higher index, closer position to cluster center.
4324			for (i = count; i >= 0; i--) {
4325				// Skip the first position, so that we are already farther from center and we avoid
4326				// being under the default cluster icon (especially important for Circle Markers).
4327				if (i < count) {
4328					res[i] = new L.Point(centerPt.x + legLength * Math.cos(angle), centerPt.y + legLength * Math.sin(angle))._round();
4329				}
4330				angle += separation / legLength + i * 0.0005;
4331				legLength += lengthFactor / angle;
4332			}
4333			return res;
4334		},
4335
4336		_noanimationUnspiderfy: function () {
4337			var group = this._group,
4338				map = group._map,
4339				fg = group._featureGroup,
4340				childMarkers = this.getAllChildMarkers(null, true),
4341				m, i;
4342
4343			group._ignoreMove = true;
4344
4345			this.setOpacity(1);
4346			for (i = childMarkers.length - 1; i >= 0; i--) {
4347				m = childMarkers[i];
4348
4349				fg.removeLayer(m);
4350
4351				if (m._preSpiderfyLatlng) {
4352					m.setLatLng(m._preSpiderfyLatlng);
4353					delete m._preSpiderfyLatlng;
4354				}
4355				if (m.setZIndexOffset) {
4356					m.setZIndexOffset(0);
4357				}
4358
4359				if (m._spiderLeg) {
4360					map.removeLayer(m._spiderLeg);
4361					delete m._spiderLeg;
4362				}
4363			}
4364
4365			group.fire('unspiderfied', {
4366				cluster: this,
4367				markers: childMarkers
4368			});
4369			group._ignoreMove = false;
4370			group._spiderfied = null;
4371		}
4372	});
4373
4374	//Non Animated versions of everything
4375	L.MarkerClusterNonAnimated = L.MarkerCluster.extend({
4376		_animationSpiderfy: function (childMarkers, positions) {
4377			var group = this._group,
4378				map = group._map,
4379				fg = group._featureGroup,
4380				legOptions = this._group.options.spiderLegPolylineOptions,
4381				i, m, leg, newPos;
4382
4383			group._ignoreMove = true;
4384
4385			// Traverse in ascending order to make sure that inner circleMarkers are on top of further legs. Normal markers are re-ordered by newPosition.
4386			// The reverse order trick no longer improves performance on modern browsers.
4387			for (i = 0; i < childMarkers.length; i++) {
4388				newPos = map.layerPointToLatLng(positions[i]);
4389				m = childMarkers[i];
4390
4391				// Add the leg before the marker, so that in case the latter is a circleMarker, the leg is behind it.
4392				leg = new L.Polyline([this._latlng, newPos], legOptions);
4393				map.addLayer(leg);
4394				m._spiderLeg = leg;
4395
4396				// Now add the marker.
4397				m._preSpiderfyLatlng = m._latlng;
4398				m.setLatLng(newPos);
4399				if (m.setZIndexOffset) {
4400					m.setZIndexOffset(1000000); //Make these appear on top of EVERYTHING
4401				}
4402
4403				fg.addLayer(m);
4404			}
4405			this.setOpacity(0.3);
4406
4407			group._ignoreMove = false;
4408			group.fire('spiderfied', {
4409				cluster: this,
4410				markers: childMarkers
4411			});
4412		},
4413
4414		_animationUnspiderfy: function () {
4415			this._noanimationUnspiderfy();
4416		}
4417	});
4418
4419	//Animated versions here
4420	L.MarkerCluster.include({
4421
4422		_animationSpiderfy: function (childMarkers, positions) {
4423			var me = this,
4424				group = this._group,
4425				map = group._map,
4426				fg = group._featureGroup,
4427				thisLayerLatLng = this._latlng,
4428				thisLayerPos = map.latLngToLayerPoint(thisLayerLatLng),
4429				svg = L.Path.SVG,
4430				legOptions = L.extend({}, this._group.options.spiderLegPolylineOptions), // Copy the options so that we can modify them for animation.
4431				finalLegOpacity = legOptions.opacity,
4432				i, m, leg, legPath, legLength, newPos;
4433
4434			if (finalLegOpacity === undefined) {
4435				finalLegOpacity = L.MarkerClusterGroup.prototype.options.spiderLegPolylineOptions.opacity;
4436			}
4437
4438			if (svg) {
4439				// If the initial opacity of the spider leg is not 0 then it appears before the animation starts.
4440				legOptions.opacity = 0;
4441
4442				// Add the class for CSS transitions.
4443				legOptions.className = (legOptions.className || '') + ' leaflet-cluster-spider-leg';
4444			} else {
4445				// Make sure we have a defined opacity.
4446				legOptions.opacity = finalLegOpacity;
4447			}
4448
4449			group._ignoreMove = true;
4450
4451			// Add markers and spider legs to map, hidden at our center point.
4452			// Traverse in ascending order to make sure that inner circleMarkers are on top of further legs. Normal markers are re-ordered by newPosition.
4453			// The reverse order trick no longer improves performance on modern browsers.
4454			for (i = 0; i < childMarkers.length; i++) {
4455				m = childMarkers[i];
4456
4457				newPos = map.layerPointToLatLng(positions[i]);
4458
4459				// Add the leg before the marker, so that in case the latter is a circleMarker, the leg is behind it.
4460				leg = new L.Polyline([thisLayerLatLng, newPos], legOptions);
4461				map.addLayer(leg);
4462				m._spiderLeg = leg;
4463
4464				// Explanations: https://jakearchibald.com/2013/animated-line-drawing-svg/
4465				// In our case the transition property is declared in the CSS file.
4466				if (svg) {
4467					legPath = leg._path;
4468					legLength = legPath.getTotalLength() + 0.1; // Need a small extra length to avoid remaining dot in Firefox.
4469					legPath.style.strokeDasharray = legLength; // Just 1 length is enough, it will be duplicated.
4470					legPath.style.strokeDashoffset = legLength;
4471				}
4472
4473				// If it is a marker, add it now and we'll animate it out
4474				if (m.setZIndexOffset) {
4475					m.setZIndexOffset(1000000); // Make normal markers appear on top of EVERYTHING
4476				}
4477				if (m.clusterHide) {
4478					m.clusterHide();
4479				}
4480				
4481				// Vectors just get immediately added
4482				fg.addLayer(m);
4483
4484				if (m._setPos) {
4485					m._setPos(thisLayerPos);
4486				}
4487			}
4488
4489			group._forceLayout();
4490			group._animationStart();
4491
4492			// Reveal markers and spider legs.
4493			for (i = childMarkers.length - 1; i >= 0; i--) {
4494				newPos = map.layerPointToLatLng(positions[i]);
4495				m = childMarkers[i];
4496
4497				//Move marker to new position
4498				m._preSpiderfyLatlng = m._latlng;
4499				m.setLatLng(newPos);
4500				
4501				if (m.clusterShow) {
4502					m.clusterShow();
4503				}
4504
4505				// Animate leg (animation is actually delegated to CSS transition).
4506				if (svg) {
4507					leg = m._spiderLeg;
4508					legPath = leg._path;
4509					legPath.style.strokeDashoffset = 0;
4510					//legPath.style.strokeOpacity = finalLegOpacity;
4511					leg.setStyle({opacity: finalLegOpacity});
4512				}
4513			}
4514			this.setOpacity(0.3);
4515
4516			group._ignoreMove = false;
4517
4518			setTimeout(function () {
4519				group._animationEnd();
4520				group.fire('spiderfied', {
4521					cluster: me,
4522					markers: childMarkers
4523				});
4524			}, 200);
4525		},
4526
4527		_animationUnspiderfy: function (zoomDetails) {
4528			var me = this,
4529				group = this._group,
4530				map = group._map,
4531				fg = group._featureGroup,
4532				thisLayerPos = zoomDetails ? map._latLngToNewLayerPoint(this._latlng, zoomDetails.zoom, zoomDetails.center) : map.latLngToLayerPoint(this._latlng),
4533				childMarkers = this.getAllChildMarkers(null, true),
4534				svg = L.Path.SVG,
4535				m, i, leg, legPath, legLength, nonAnimatable;
4536
4537			group._ignoreMove = true;
4538			group._animationStart();
4539
4540			//Make us visible and bring the child markers back in
4541			this.setOpacity(1);
4542			for (i = childMarkers.length - 1; i >= 0; i--) {
4543				m = childMarkers[i];
4544
4545				//Marker was added to us after we were spiderfied
4546				if (!m._preSpiderfyLatlng) {
4547					continue;
4548				}
4549
4550				//Close any popup on the marker first, otherwise setting the location of the marker will make the map scroll
4551				m.closePopup();
4552
4553				//Fix up the location to the real one
4554				m.setLatLng(m._preSpiderfyLatlng);
4555				delete m._preSpiderfyLatlng;
4556
4557				//Hack override the location to be our center
4558				nonAnimatable = true;
4559				if (m._setPos) {
4560					m._setPos(thisLayerPos);
4561					nonAnimatable = false;
4562				}
4563				if (m.clusterHide) {
4564					m.clusterHide();
4565					nonAnimatable = false;
4566				}
4567				if (nonAnimatable) {
4568					fg.removeLayer(m);
4569				}
4570
4571				// Animate the spider leg back in (animation is actually delegated to CSS transition).
4572				if (svg) {
4573					leg = m._spiderLeg;
4574					legPath = leg._path;
4575					legLength = legPath.getTotalLength() + 0.1;
4576					legPath.style.strokeDashoffset = legLength;
4577					leg.setStyle({opacity: 0});
4578				}
4579			}
4580
4581			group._ignoreMove = false;
4582
4583			setTimeout(function () {
4584				//If we have only <= one child left then that marker will be shown on the map so don't remove it!
4585				var stillThereChildCount = 0;
4586				for (i = childMarkers.length - 1; i >= 0; i--) {
4587					m = childMarkers[i];
4588					if (m._spiderLeg) {
4589						stillThereChildCount++;
4590					}
4591				}
4592
4593
4594				for (i = childMarkers.length - 1; i >= 0; i--) {
4595					m = childMarkers[i];
4596
4597					if (!m._spiderLeg) { //Has already been unspiderfied
4598						continue;
4599					}
4600
4601					if (m.clusterShow) {
4602						m.clusterShow();
4603					}
4604					if (m.setZIndexOffset) {
4605						m.setZIndexOffset(0);
4606					}
4607
4608					if (stillThereChildCount > 1) {
4609						fg.removeLayer(m);
4610					}
4611
4612					map.removeLayer(m._spiderLeg);
4613					delete m._spiderLeg;
4614				}
4615				group._animationEnd();
4616				group.fire('unspiderfied', {
4617					cluster: me,
4618					markers: childMarkers
4619				});
4620			}, 200);
4621		}
4622	});
4623
4624
4625	L.MarkerClusterGroup.include({
4626		//The MarkerCluster currently spiderfied (if any)
4627		_spiderfied: null,
4628
4629		unspiderfy: function () {
4630			this._unspiderfy.apply(this, arguments);
4631		},
4632
4633		_spiderfierOnAdd: function () {
4634			this._map.on('click', this._unspiderfyWrapper, this);
4635
4636			if (this._map.options.zoomAnimation) {
4637				this._map.on('zoomstart', this._unspiderfyZoomStart, this);
4638			}
4639			//Browsers without zoomAnimation or a big zoom don't fire zoomstart
4640			this._map.on('zoomend', this._noanimationUnspiderfy, this);
4641
4642			if (!L.Browser.touch) {
4643				this._map.getRenderer(this);
4644				//Needs to happen in the pageload, not after, or animations don't work in webkit
4645				//  http://stackoverflow.com/questions/8455200/svg-animate-with-dynamically-added-elements
4646				//Disable on touch browsers as the animation messes up on a touch zoom and isn't very noticable
4647			}
4648		},
4649
4650		_spiderfierOnRemove: function () {
4651			this._map.off('click', this._unspiderfyWrapper, this);
4652			this._map.off('zoomstart', this._unspiderfyZoomStart, this);
4653			this._map.off('zoomanim', this._unspiderfyZoomAnim, this);
4654			this._map.off('zoomend', this._noanimationUnspiderfy, this);
4655
4656			//Ensure that markers are back where they should be
4657			// Use no animation to avoid a sticky leaflet-cluster-anim class on mapPane
4658			this._noanimationUnspiderfy();
4659		},
4660
4661		//On zoom start we add a zoomanim handler so that we are guaranteed to be last (after markers are animated)
4662		//This means we can define the animation they do rather than Markers doing an animation to their actual location
4663		_unspiderfyZoomStart: function () {
4664			if (!this._map) { //May have been removed from the map by a zoomEnd handler
4665				return;
4666			}
4667
4668			this._map.on('zoomanim', this._unspiderfyZoomAnim, this);
4669		},
4670
4671		_unspiderfyZoomAnim: function (zoomDetails) {
4672			//Wait until the first zoomanim after the user has finished touch-zooming before running the animation
4673			if (L.DomUtil.hasClass(this._map._mapPane, 'leaflet-touching')) {
4674				return;
4675			}
4676
4677			this._map.off('zoomanim', this._unspiderfyZoomAnim, this);
4678			this._unspiderfy(zoomDetails);
4679		},
4680
4681		_unspiderfyWrapper: function () {
4682			/// <summary>_unspiderfy but passes no arguments</summary>
4683			this._unspiderfy();
4684		},
4685
4686		_unspiderfy: function (zoomDetails) {
4687			if (this._spiderfied) {
4688				this._spiderfied.unspiderfy(zoomDetails);
4689			}
4690		},
4691
4692		_noanimationUnspiderfy: function () {
4693			if (this._spiderfied) {
4694				this._spiderfied._noanimationUnspiderfy();
4695			}
4696		},
4697
4698		//If the given layer is currently being spiderfied then we unspiderfy it so it isn't on the map anymore etc
4699		_unspiderfyLayer: function (layer) {
4700			if (layer._spiderLeg) {
4701				this._featureGroup.removeLayer(layer);
4702
4703				if (layer.clusterShow) {
4704					layer.clusterShow();
4705				}
4706					//Position will be fixed up immediately in _animationUnspiderfy
4707				if (layer.setZIndexOffset) {
4708					layer.setZIndexOffset(0);
4709				}
4710
4711				this._map.removeLayer(layer._spiderLeg);
4712				delete layer._spiderLeg;
4713			}
4714		}
4715	});
4716
4717	/**
4718	 * Adds 1 public method to MCG and 1 to L.Marker to facilitate changing
4719	 * markers' icon options and refreshing their icon and their parent clusters
4720	 * accordingly (case where their iconCreateFunction uses data of childMarkers
4721	 * to make up the cluster icon).
4722	 */
4723
4724
4725	L.MarkerClusterGroup.include({
4726		/**
4727		 * Updates the icon of all clusters which are parents of the given marker(s).
4728		 * In singleMarkerMode, also updates the given marker(s) icon.
4729		 * @param layers L.MarkerClusterGroup|L.LayerGroup|Array(L.Marker)|Map(L.Marker)|
4730		 * L.MarkerCluster|L.Marker (optional) list of markers (or single marker) whose parent
4731		 * clusters need to be updated. If not provided, retrieves all child markers of this.
4732		 * @returns {L.MarkerClusterGroup}
4733		 */
4734		refreshClusters: function (layers) {
4735			if (!layers) {
4736				layers = this._topClusterLevel.getAllChildMarkers();
4737			} else if (layers instanceof L.MarkerClusterGroup) {
4738				layers = layers._topClusterLevel.getAllChildMarkers();
4739			} else if (layers instanceof L.LayerGroup) {
4740				layers = layers._layers;
4741			} else if (layers instanceof L.MarkerCluster) {
4742				layers = layers.getAllChildMarkers();
4743			} else if (layers instanceof L.Marker) {
4744				layers = [layers];
4745			} // else: must be an Array(L.Marker)|Map(L.Marker)
4746			this._flagParentsIconsNeedUpdate(layers);
4747			this._refreshClustersIcons();
4748
4749			// In case of singleMarkerMode, also re-draw the markers.
4750			if (this.options.singleMarkerMode) {
4751				this._refreshSingleMarkerModeMarkers(layers);
4752			}
4753
4754			return this;
4755		},
4756
4757		/**
4758		 * Simply flags all parent clusters of the given markers as having a "dirty" icon.
4759		 * @param layers Array(L.Marker)|Map(L.Marker) list of markers.
4760		 * @private
4761		 */
4762		_flagParentsIconsNeedUpdate: function (layers) {
4763			var id, parent;
4764
4765			// Assumes layers is an Array or an Object whose prototype is non-enumerable.
4766			for (id in layers) {
4767				// Flag parent clusters' icon as "dirty", all the way up.
4768				// Dumb process that flags multiple times upper parents, but still
4769				// much more efficient than trying to be smart and make short lists,
4770				// at least in the case of a hierarchy following a power law:
4771				// http://jsperf.com/flag-nodes-in-power-hierarchy/2
4772				parent = layers[id].__parent;
4773				while (parent) {
4774					parent._iconNeedsUpdate = true;
4775					parent = parent.__parent;
4776				}
4777			}
4778		},
4779
4780		/**
4781		 * Re-draws the icon of the supplied markers.
4782		 * To be used in singleMarkerMode only.
4783		 * @param layers Array(L.Marker)|Map(L.Marker) list of markers.
4784		 * @private
4785		 */
4786		_refreshSingleMarkerModeMarkers: function (layers) {
4787			var id, layer;
4788
4789			for (id in layers) {
4790				layer = layers[id];
4791
4792				// Make sure we do not override markers that do not belong to THIS group.
4793				if (this.hasLayer(layer)) {
4794					// Need to re-create the icon first, then re-draw the marker.
4795					layer.setIcon(this._overrideMarkerIcon(layer));
4796				}
4797			}
4798		}
4799	});
4800
4801	L.Marker.include({
4802		/**
4803		 * Updates the given options in the marker's icon and refreshes the marker.
4804		 * @param options map object of icon options.
4805		 * @param directlyRefreshClusters boolean (optional) true to trigger
4806		 * MCG.refreshClustersOf() right away with this single marker.
4807		 * @returns {L.Marker}
4808		 */
4809		refreshIconOptions: function (options, directlyRefreshClusters) {
4810			var icon = this.options.icon;
4811
4812			L.setOptions(icon, options);
4813
4814			this.setIcon(icon);
4815
4816			// Shortcut to refresh the associated MCG clusters right away.
4817			// To be used when refreshing a single marker.
4818			// Otherwise, better use MCG.refreshClusters() once at the end with
4819			// the list of modified markers.
4820			if (directlyRefreshClusters && this.__parent) {
4821				this.__parent._group.refreshClusters(this);
4822			}
4823
4824			return this;
4825		}
4826	});
4827
4828	exports.MarkerClusterGroup = MarkerClusterGroup;
4829	exports.MarkerCluster = MarkerCluster;
4830
4831	Object.defineProperty(exports, '__esModule', { value: true });
4832
4833}));