https://www.freenet.de/theme/js/md-web4-9275cd69.js

1(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2var m0 = require("../src/modules/1.general/10.links/40.link-hotline/_40.link-hotline.2.js");
3var m1 = require("../src/modules/1.general/10.links/50.link-anchor/_50.link-anchor.2.js");
4var m2 = require("../src/modules/1.general/20.button/25.button-icon--scrollup/_25.button-icon--scrollup.2.js");
5var m3 = require("../src/modules/1.general/50.forms-items/22.input--file/_22.input--file.2.js");
6var m4 = require("../src/modules/1.general/50.forms-items/23.date-input/_23.date-input.2.js");
7var m5 = require("../src/modules/1.general/50.forms-items/80.form-error/_80.form-error.2.js");
8var m6 = require("../src/modules/1.general/50.forms-items/90.switch/_90.switch.2.js");
9var m7 = require("../src/modules/1.general/50.forms-items/100.slider/_100.slider.2.js");
10var m8 = require("../src/modules/1.general/51.forms-parts/140.search/_140.search.2.js");
11var m9 = require("../src/modules/1.general/60.media/10.image-ext/_10.image-ext.2.js");
12var m10 = require("../src/modules/1.general/60.media/90.picture-tag/_90.picture-tag.2.js");
13var m11 = require("../src/modules/1.general/62.embedded/10.embedded-optin-yt/_10.embedded-optin-yt.2.js");
14var m12 = require("../src/modules/1.general/80.messages/20.tooltip-ext/_20.tooltip-ext.2.js");
15var m13 = require("../src/modules/1.general/80.messages/40.popup/_40.popup.2.js");
16var m14 = require("../src/modules/1.general/80.messages/50.message-outdated/_50.message-outdated.2.js");
17var m15 = require("../src/modules/1.general/90.accordion/10.accordion/_10.accordion.2.js");
18var m16 = require("../src/modules/2.products/10.product-details/23.variant-switch/_23.variant-switch.2.js");
19var m17 = require("../src/modules/2.products/10.product-details/71.product-rating--icon/_71.product-rating--icon.2.js");
20var m18 = require("../src/modules/2.products/10.product-details/90.cost-overview/_90.cost-overview.2.js");
21var m19 = require("../src/modules/2.products/11.offer-details/10.counter-time/_10.counter-time.2.js");
22var m20 = require("../src/modules/2.products/20.product-boxes/62.product-info-box-text/_62.product-info-box-text.2.js");
23var m21 = require("../src/modules/3.navigation/25.horizontal-nav/20.grid-slider/_20.grid-slider.2.js");
24var m22 = require("../src/modules/2.products/20.product-boxes/110.product-detail-tariff-offer/_110.product-detail-tariff-offer.2.js");
25var m23 = require("../src/modules/3.navigation/80.tabcontent/21.navigation-tabs--big/_21.navigation-tabs--big.2.js");
26var m24 = require("../src/modules/3.navigation/80.tabcontent/20.navigation-tabs/_20.navigation-tabs.2.js");
27var m25 = require("../src/modules/2.products/30.configurator/70.quick-start/_70.quick-start.2.js");
28var m26 = require("../src/modules/2.products/30.configurator/71.quick-start-modern/_71.quick-start-modern.2.js");
29var m27 = require("../src/modules/3.navigation/80.tabcontent/10.tabcontent/_10.tabcontent.2.js");
30var m28 = require("../src/modules/2.products/30.configurator/80.config-list/_80.config-list.2.js");
31var m29 = require("../src/modules/2.products/30.configurator/90.config-filter/_90.config-filter.2.js");
32var m30 = require("../src/modules/2.products/30.configurator/100.config-variant/_100.config-variant.2.js");
33var m31 = require("../src/modules/2.products/30.configurator/110.config-navigation/_110.config-navigation.2.js");
34var m32 = require("../src/modules/2.products/40.detail-layer/10.tariff-detail-layer/_10.tariff-detail-layer.2.js");
35var m33 = require("../src/modules/2.products/10.product-details/40.legal-texts/_40.legal-texts.2.js");
36var m34 = require("../src/modules/3.navigation/110.nav-boxes/10.nav-box/_10.nav-box.2.js");
37var m35 = require("../src/modules/5.content/40.steps/20.slider-steps/_20.slider-steps.2.js");
38var m36 = require("../src/modules/5.content/90.overlays/10.content-overlay/_10.content-overlay.2.js");
39var m37 = require("../src/modules/6.snippets/30.geo-location/10.location-search/_10.location-search.2.js");
40var m38 = require("../src/modules/6.snippets/30.geo-location/20.location-results/_20.location-results.2.js");
41var m39 = require("../src/modules/6.snippets/30.geo-location/30.location-map/_30.location-map.2.js");
42var m40 = require("../src/modules/6.snippets/50.extern/10.trusted-shops-snippet/_10.trusted-shops-snippet.2.js");
43var m41 = require("../src/modules/20.mobilcom/10.offer/31.md-campaign-box--expandable/_31.md-campaign-box--expandable.2.js");
44var m42 = require("../src/modules/20.mobilcom/20.stage/20.md-stage-basic--bundle/_20.md-stage-basic--bundle.2.js");
45var m43 = require("../src/modules/20.mobilcom/20.stage/30.md-stage-offer--pk/_30.md-stage-offer--pk.2.js");

46var m44 = require("../src/modules/20.mobilcom/40.general/40.md-header/_40.md-header.2.js");
47var m45 = require("../src/modules/90.nofrills/10.offer/60.nf-offer-box-modern/_60.nf-offer-box-modern.2.js");
48var m46 = require("../src/modules/90.nofrills/40.navigation/10.nf-navigation-tariff/_10.nf-navigation-tariff.2.js");
49var m47 = require("../src/modules/99.sites/10.shop/_11.tariff-listing-page.2.js");
50var m48 = require("../src/modules/3.navigation/40.plp-bar/_10.plp-bar.2.js");
51var m49 = require("../src/modules/2.products/10.product-details/100.product-options/_100.product-options.2.js");
52var m50 = require("../src/modules/2.products/10.product-details/110.product-crossselling/_110.product-crossselling.2.js");
53
54},{"../src/modules/1.general/10.links/40.link-hotline/_40.link-hotline.2.js":85,"../src/modules/1.general/10.links/50.link-anchor/_50.link-anchor.2.js":86,"../src/modules/1.general/20.button/25.button-icon--scrollup/_25.button-icon--scrollup.2.js":87,"../src/modules/1.general/50.forms-items/100.slider/_100.slider.2.js":88,"../src/modules/1.general/50.forms-items/22.input--file/_22.input--file.2.js":89,"../src/modules/1.general/50.forms-items/23.date-input/_23.date-input.2.js":90,"../src/modules/1.general/50.forms-items/80.form-error/_80.form-error.2.js":91,"../src/modules/1.general/50.forms-items/90.switch/_90.switch.2.js":92,"../src/modules/1.general/51.forms-parts/140.search/_140.search.2.js":93,"../src/modules/1.general/60.media/10.image-ext/_10.image-ext.2.js":94,"../src/modules/1.general/60.media/90.picture-tag/_90.picture-tag.2.js":95,"../src/modules/1.general/62.embedded/10.embedded-optin-yt/_10.embedded-optin-yt.2.js":96,"../src/modules/1.general/80.messages/20.tooltip-ext/_20.tooltip-ext.2.js":97,"../src/modules/1.general/80.messages/40.popup/_40.popup.2.js":98,"../src/modules/1.general/80.messages/50.message-outdated/_50.message-outdated.2.js":99,"../src/modules/1.general/90.accordion/10.accordion/_10.accordion.2.js":100,"../src/modules/2.products/10.product-details/100.product-options/_100.product-options.2.js":101,"../src/modules/2.products/10.product-details/110.product-crossselling/_110.product-crossselling.2.js":102,"../src/modules/2.products/10.product-details/23.variant-switch/_23.variant-switch.2.js":103,"../src/modules/2.products/10.product-details/40.legal-texts/_40.legal-texts.2.js":104,"../src/modules/2.products/10.product-details/71.product-rating--icon/_71.product-rating--icon.2.js":105,"../src/modules/2.products/10.product-details/90.cost-overview/_90.cost-overview.2.js":106,"../src/modules/2.products/11.offer-details/10.counter-time/_10.counter-time.2.js":107,"../src/modules/2.products/20.product-boxes/110.product-detail-tariff-offer/_110.product-detail-tariff-offer.2.js":108,"../src/modules/2.products/20.product-boxes/62.product-info-box-text/_62.product-info-box-text.2.js":109,"../src/modules/2.products/30.configurator/100.config-variant/_100.config-variant.2.js":110,"../src/modules/2.products/30.configurator/110.config-navigation/_110.config-navigation.2.js":111,"../src/modules/2.products/30.configurator/70.quick-start/_70.quick-start.2.js":112,"../src/modules/2.products/30.configurator/71.quick-start-modern/_71.quick-start-modern.2.js":113,"../src/modules/2.products/30.configurator/80.config-list/_80.config-list.2.js":114,"../src/modules/2.products/30.configurator/90.config-filter/_90.config-filter.2.js":115,"../src/modules/2.products/40.detail-layer/10.tariff-detail-layer/_10.tariff-detail-layer.2.js":116,"../src/modules/20.mobilcom/10.offer/31.md-campaign-box--expandable/_31.md-campaign-box--expandable.2.js":117,"../src/modules/20.mobilcom/20.stage/20.md-stage-basic--bundle/_20.md-stage-basic--bundle.2.js":118,"../src/modules/20.mobilcom/20.stage/30.md-stage-offer--pk/_30.md-stage-offer--pk.2.js":119,"../src/modules/20.mobilcom/40.general/40.md-header/_40.md-header.2.js":120,"../src/modules/3.navigation/110.nav-boxes/10.nav-box/_10.nav-box.2.js":121,"../src/modules/3.navigation/25.horizontal-nav/20.grid-slider/_20.grid-slider.2.js":122,"../src/modules/3.navigation/40.plp-bar/_10.plp-bar.2.js":123,"../src/modules/3.navigation/80.tabcontent/10.tabcontent/_10.tabcontent.2.js":124,"../src/modules/3.navigation/80.tabcontent/20.navigation-tabs/_20.navigation-tabs.2.js":125,"../src/modules/3.navigation/80.tabcontent/21.navigation-tabs--big/_21.navigation-tabs--big.2.js":126,"../src/modules/5.content/40.steps/20.slider-steps/_20.slider-steps.2.js":127,"../src/modules/5.content/90.overlays/10.content-overlay/_10.content-overlay.2.js":128,"../src/modules/6.snippets/30.geo-location/10.location-search/_10.location-search.2.js":130,"../src/modules/6.snippets/30.geo-location/20.location-results/_20.location-results.2.js":132,"../src/modules/6.snippets/30.geo-location/30.location-map/_30.location-map.2.js":134,"../src/modules/6.snippets/50.extern/10.trusted-shops-snippet/_10.trusted-shops-snippet.2.js":135,"../src/modules/90.nofrills/10.offer/60.nf-offer-box-modern/_60.nf-offer-box-modern.2.js":136,"../src/modules/90.nofrills/40.navigation/10.nf-navigation-tariff/_10.nf-navigation-tariff.2.js":137,"../src/modules/99.sites/10.shop/_11.tariff-listing-page.2.js":138}],2:[function(require,module,exports){
55function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
56/**
57 * @name MarkerClustererPlus for Google Maps V3
58 * @version 2.1.11
59 * @author Gary Little
60 * @fileoverview

61 * The library creates and manages per-zoom-level clusters for large amounts of markers.
62 * <p>
63 * This is an enhanced V3 implementation of the V2 MarkerClusterer by Xiaoxi Wu. It is
64 * based on the V3 MarkerClusterer port by Luke Mahe. MarkerClustererPlus was created
65 * by Gary Little.
66 * <p>
67 * v2.0 release: MarkerClustererPlus v2.0 is backward compatible with MarkerClusterer v1.0. It
68 *  adds support for the <code>ignoreHidden</code>, <code>title</code>, <code>batchSizeIE</code>,
69 *  and <code>calculator</code> properties as well as support for four more events. It also allows
70 *  greater control over the styling of the text that appears on the cluster marker. The
71 *  documentation has been significantly improved and the overall code has been simplified and
72 *  polished. Very large numbers of markers can now be managed without causing Javascript timeout
73 *  errors on Internet Explorer. Note that the name of the <code>clusterclick</code> event has been
74 *  deprecated. The new name is <code>click</code>, so please change your application code now.
75 */
76
77/**
78 * Licensed under the Apache License, Version 2.0 (the "License");
79 * you may not use this file except in compliance with the License.
80 * You may obtain a copy of the License at
81 *
82 *     http://www.apache.org/licenses/LICENSE-2.0
83 *
84 * Unless required by applicable law or agreed to in writing, software
85 * distributed under the License is distributed on an "AS IS" BASIS,
86 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
87 * See the License for the specific language governing permissions and
88 * limitations under the License.
89 */
90
91/**
92 * @name ClusterIconStyle
93 * @class This class represents the object for values in the <code>styles</code> array passed
94 *  to the {@link MarkerClusterer} constructor. The element in this array that is used to
95 *  style the cluster icon is determined by calling the <code>calculator</code> function.
96 *
97 * @property {string} url The URL of the cluster icon image file. Required.
98 * @property {number} height The display height (in pixels) of the cluster icon. Required.
99 * @property {number} width The display width (in pixels) of the cluster icon. Required.
100 * @property {Array} [anchorText] The position (in pixels) from the center of the cluster icon to
101 *  where the text label is to be centered and drawn. The format is <code>[yoffset, xoffset]</code>
102 *  where <code>yoffset</code> increases as you go down from center and <code>xoffset</code>
103 *  increases to the right of center. The default is <code>[0, 0]</code>.
104 * @property {Array} [anchorIcon] The anchor position (in pixels) of the cluster icon. This is the
105 *  spot on the cluster icon that is to be aligned with the cluster position. The format is
106 *  <code>[yoffset, xoffset]</code> where <code>yoffset</code> increases as you go down and
107 *  <code>xoffset</code> increases to the right of the top-left corner of the icon. The default
108 *  anchor position is the center of the cluster icon.
109 * @property {string} [textColor="black"] The color of the label text shown on the
110 *  cluster icon.
111 * @property {number} [textSize=11] The size (in pixels) of the label text shown on the
112 *  cluster icon.
113 * @property {string} [textDecoration="none"] The value of the CSS <code>text-decoration</code>
114 *  property for the label text shown on the cluster icon.
115 * @property {string} [fontWeight="bold"] The value of the CSS <code>font-weight</code>
116 *  property for the label text shown on the cluster icon.
117 * @property {string} [fontStyle="normal"] The value of the CSS <code>font-style</code>
118 *  property for the label text shown on the cluster icon.
119 * @property {string} [fontFamily="Arial,sans-serif"] The value of the CSS <code>font-family</code>
120 *  property for the label text shown on the cluster icon.
121 * @property {string} [backgroundPosition="0 0"] The position of the cluster icon image
122 *  within the image defined by <code>url</code>. The format is <code>"xpos ypos"</code>
123 *  (the same format as for the CSS <code>background-position</code> property). You must set
124 *  this property appropriately when the image defined by <code>url</code> represents a sprite
125 *  containing multiple images. Note that the position <i>must</i> be specified in px units.
126 */
127/**
128 * @name ClusterIconInfo

129 * @class This class is an object containing general information about a cluster icon. This is
130 *  the object that a <code>calculator</code> function returns.
131 *
132 * @property {string} text The text of the label to be shown on the cluster icon.
133 * @property {number} index The index plus 1 of the element in the <code>styles</code>
134 *  array to be used to style the cluster icon.
135 * @property {string} title The tooltip to display when the mouse moves over the cluster icon.
136 *  If this value is <code>undefined</code> or <code>""</code>, <code>title</code> is set to the
137 *  value of the <code>title</code> property passed to the MarkerClusterer.
138 */
139/**
140 * A cluster icon.
141 *
142 * @constructor
143 * @extends google.maps.OverlayView
144 * @param {Cluster} cluster The cluster with which the icon is to be associated.
145 * @param {Array} [styles] An array of {@link ClusterIconStyle} defining the cluster icons
146 *  to use for various cluster sizes.
147 * @private
148 */
149function ClusterIcon(cluster, styles) {
150  cluster.getMarkerClusterer().extend(ClusterIcon, google.maps.OverlayView);
151  this.cluster_ = cluster;
152  this.className_ = cluster.getMarkerClusterer().getClusterClass();
153  this.styles_ = styles;
154  this.center_ = null;
155  this.div_ = null;
156  this.sums_ = null;
157  this.visible_ = false;
158  this.setMap(cluster.getMap()); // Note: this causes onAdd to be called
159}
160
161/**
162 * Adds the icon to the DOM.
163 */
164ClusterIcon.prototype.onAdd = function () {
165  var cClusterIcon = this;
166  var cMouseDownInCluster;
167  var cDraggingMapByCluster;
168  var gmVersion = google.maps.version.split(".");
169  gmVersion = parseInt(gmVersion[0] * 100, 10) + parseInt(gmVersion[1], 10);
170  this.div_ = document.createElement("div");
171  this.div_.className = this.className_;
172  if (this.visible_) {
173    this.show();
174  }
175  this.getPanes().overlayMouseTarget.appendChild(this.div_);
176
177  // Fix for Issue 157
178  this.boundsChangedListener_ = google.maps.event.addListener(this.getMap(), "bounds_changed", function () {
179    cDraggingMapByCluster = cMouseDownInCluster;
180  });
181  google.maps.event.addDomListener(this.div_, "mousedown", function () {
182    cMouseDownInCluster = true;
183    cDraggingMapByCluster = false;
184  });
185
186  // March 1, 2018: Fix for this 3.32 exp bug, https://issuetracker.google.com/issues/73571522
187  // But it doesn't work with earlier releases so do a version check.
188  if (gmVersion >= 332) {
189    // Ugly version-dependent code
190    google.maps.event.addDomListener(this.div_, "touchstart", function (e) {
191      e.stopPropagation();
192    });
193  }
194  google.maps.event.addDomListener(this.div_, "click", function (e) {
195    cMouseDownInCluster = false;
196    if (!cDraggingMapByCluster) {
197      var theBounds;
198      var mz;
199      var mc = cClusterIcon.cluster_.getMarkerClusterer();
200      /**
201       * This event is fired when a cluster marker is clicked.
202       * @name MarkerClusterer#click
203       * @param {Cluster} c The cluster that was clicked.
204       * @event
205       */
206      google.maps.event.trigger(mc, "click", cClusterIcon.cluster_);
207      google.maps.event.trigger(mc, "clusterclick", cClusterIcon.cluster_); // deprecated name
208
209      // The default click handler follows. Disable it by setting
210      // the zoomOnClick property to false.
211      if (mc.getZoomOnClick()) {
212        // Zoom into the cluster.
213        mz = mc.getMaxZoom();
214        theBounds = cClusterIcon.cluster_.getBounds();
215        mc.getMap().fitBounds(theBounds);
216        // There is a fix for Issue 170 here:
217        setTimeout(function () {
218          mc.getMap().fitBounds(theBounds);
219          // Don't zoom beyond the max zoom level
220          if (mz !== null && mc.getMap().getZoom() > mz) {
221            mc.getMap().setZoom(mz + 1);
222          }
223        }, 100);
224      }
225
226      // Prevent event propagation to the map:
227      e.cancelBubble = true;
228      if (e.stopPropagation) {
229        e.stopPropagation();
230      }
231    }
232  });
233  google.maps.event.addDomListener(this.div_, "mouseover", function () {
234    var mc = cClusterIcon.cluster_.getMarkerClusterer();
235    /**
236     * This event is fired when the mouse moves over a cluster marker.
237     * @name MarkerClusterer#mouseover
238     * @param {Cluster} c The cluster that the mouse moved over.
239     * @event
240     */
241    google.maps.event.trigger(mc, "mouseover", cClusterIcon.cluster_);
242  });
243  google.maps.event.addDomListener(this.div_, "mouseout", function () {
244    var mc = cClusterIcon.cluster_.getMarkerClusterer();
245    /**

246     * This event is fired when the mouse moves out of a cluster marker.
247     * @name MarkerClusterer#mouseout
248     * @param {Cluster} c The cluster that the mouse moved out of.
249     * @event
250     */
251    google.maps.event.trigger(mc, "mouseout", cClusterIcon.cluster_);
252  });
253};
254
255/**
256 * Removes the icon from the DOM.
257 */
258ClusterIcon.prototype.onRemove = function () {
259  if (this.div_ && this.div_.parentNode) {
260    this.hide();
261    google.maps.event.removeListener(this.boundsChangedListener_);
262    google.maps.event.clearInstanceListeners(this.div_);
263    this.div_.parentNode.removeChild(this.div_);
264    this.div_ = null;
265  }
266};
267
268/**
269 * Draws the icon.
270 */
271ClusterIcon.prototype.draw = function () {
272  if (this.visible_) {
273    var pos = this.getPosFromLatLng_(this.center_);
274    this.div_.style.top = pos.y + "px";
275    this.div_.style.left = pos.x + "px";
276    this.div_.style.zIndex = google.maps.Marker.MAX_ZINDEX + 1; // Put above all unclustered markers
277  }
278};
279
280/**
281 * Hides the icon.
282 */
283ClusterIcon.prototype.hide = function () {
284  if (this.div_) {
285    this.div_.style.display = "none";
286  }
287  this.visible_ = false;
288};
289
290/**
291 * Positions and shows the icon.
292 */
293ClusterIcon.prototype.show = function () {
294  if (this.div_) {
295    var img = "";
296    // NOTE: values must be specified in px units
297    var bp = this.backgroundPosition_.split(" ");
298    var spriteH = parseInt(bp[0].replace(/^\s+|\s+$/g, ""), 10);
299    var spriteV = parseInt(bp[1].replace(/^\s+|\s+$/g, ""), 10);
300    var pos = this.getPosFromLatLng_(this.center_);
301    this.div_.style.cssText = this.createCss(pos);
302    img = "<img src='" + this.url_ + "' style='position: absolute; top: " + spriteV + "px; left: " + spriteH + "px; ";
303    if (this.cluster_.getMarkerClusterer().enableRetinaIcons_) {
304      img += "width: " + this.width_ + "px; height: " + this.height_ + "px;";
305    } else {
306      img += "clip: rect(" + -1 * spriteV + "px, " + (-1 * spriteH + this.width_) + "px, " + (-1 * spriteV + this.height_) + "px, " + -1 * spriteH + "px);";
307    }
308    img += "'>";
309    this.div_.innerHTML = img + "<div style='" + "position: absolute;" + "top: " + this.anchorText_[0] + "px;" + "left: " + this.anchorText_[1] + "px;" + "color: " + this.textColor_ + ";" + "font-size: " + this.textSize_ + "px;" + "font-family: " + this.fontFamily_ + ";" + "font-weight: " + this.fontWeight_ + ";" + "font-style: " + this.fontStyle_ + ";" + "text-decoration: " + this.textDecoration_ + ";" + "text-align: center;" + "width: " + this.width_ + "px;" + "line-height:" + this.height_ + "px;" + "'>" + this.sums_.text + "</div>";
310    if (typeof this.sums_.title === "undefined" || this.sums_.title === "") {
311      this.div_.title = this.cluster_.getMarkerClusterer().getTitle();
312    } else {
313      this.div_.title = this.sums_.title;
314    }
315    this.div_.style.display = "";
316  }
317  this.visible_ = true;
318};
319
320/**
321 * Sets the icon styles to the appropriate element in the styles array.
322 *
323 * @param {ClusterIconInfo} sums The icon label text and styles index.
324 */
325ClusterIcon.prototype.useStyle = function (sums) {
326  this.sums_ = sums;
327  var index = Math.max(0, sums.index - 1);
328  index = Math.min(this.styles_.length - 1, index);
329  var style = this.styles_[index];
330  this.url_ = style.url;
331  this.height_ = style.height;
332  this.width_ = style.width;
333  this.anchorText_ = style.anchorText || [0, 0];
334  this.anchorIcon_ = style.anchorIcon || [parseInt(this.height_ / 2, 10), parseInt(this.width_ / 2, 10)];
335  this.textColor_ = style.textColor || "black";
336  this.textSize_ = style.textSize || 11;
337  this.textDecoration_ = style.textDecoration || "none";
338  this.fontWeight_ = style.fontWeight || "bold";
339  this.fontStyle_ = style.fontStyle || "normal";
340  this.fontFamily_ = style.fontFamily || "Arial,sans-serif";
341  this.backgroundPosition_ = style.backgroundPosition || "0 0";
342};
343
344/**
345 * Sets the position at which to center the icon.
346 *
347 * @param {google.maps.LatLng} center The latlng to set as the center.
348 */
349ClusterIcon.prototype.setCenter = function (center) {
350  this.center_ = center;
351};
352
353/**
354 * Creates the cssText style parameter based on the position of the icon.
355 *
356 * @param {google.maps.Point} pos The position of the icon.
357 * @return {string} The CSS style text.
358 */
359ClusterIcon.prototype.createCss = function (pos) {
360  var style = [];
361  style.push("cursor: pointer;");
362  style.push("position: absolute; top: " + pos.y + "px; left: " + pos.x + "px;");
363  style.push("width: " + this.width_ + "px; height: " + this.height_ + "px;");
364  style.push("-webkit-user-select: none;");
365  style.push("-khtml-user-select: none;");
366  style.push("-moz-user-select: none;");
367  style.push("-o-user-select: none;");
368  style.push("user-select: none;");
369  return style.join("");
370};
371
372/**
373 * Returns the position at which to place the DIV depending on the latlng.
374 *
375 * @param {google.maps.LatLng} latlng The position in latlng.
376 * @return {google.maps.Point} The position in pixels.
377 */
378ClusterIcon.prototype.getPosFromLatLng_ = function (latlng) {
379  var pos = this.getProjection().fromLatLngToDivPixel(latlng);
380  pos.x -= this.anchorIcon_[1];
381  pos.y -= this.anchorIcon_[0];
382  pos.x = parseInt(pos.x, 10);
383  pos.y = parseInt(pos.y, 10);
384  return pos;
385};
386
387/**
388 * Creates a single cluster that manages a group of proximate markers.
389 *  Used internally, do not call this constructor directly.
390 * @constructor
391 * @param {MarkerClusterer} mc The <code>MarkerClusterer</code> object with which this
392 *  cluster is associated.
393 */
394function Cluster(mc) {
395  this.markerClusterer_ = mc;
396  this.map_ = mc.getMap();
397  this.gridSize_ = mc.getGridSize();
398  this.minClusterSize_ = mc.getMinimumClusterSize();
399  this.averageCenter_ = mc.getAverageCenter();
400  this.markers_ = [];
401  this.center_ = null;
402  this.bounds_ = null;
403  this.clusterIcon_ = new ClusterIcon(this, mc.getStyles());
404}
405
406/**
407 * Returns the number of markers managed by the cluster. You can call this from
408 * a <code>click</code>, <code>mouseover</code>, or <code>mouseout</code> event handler
409 * for the <code>MarkerClusterer</code> object.
410 *
411 * @return {number} The number of markers in the cluster.
412 */
413Cluster.prototype.getSize = function () {
414  return this.markers_.length;
415};
416
417/**
418 * Returns the array of markers managed by the cluster. You can call this from
419 * a <code>click</code>, <code>mouseover</code>, or <code>mouseout</code> event handler
420 * for the <code>MarkerClusterer</code> object.
421 *
422 * @return {Array} The array of markers in the cluster.
423 */
424Cluster.prototype.getMarkers = function () {
425  return this.markers_;
426};
427
428/**
429 * Returns the center of the cluster. You can call this from
430 * a <code>click</code>, <code>mouseover</code>, or <code>mouseout</code> event handler
431 * for the <code>MarkerClusterer</code> object.
432 *
433 * @return {google.maps.LatLng} The center of the cluster.
434 */
435Cluster.prototype.getCenter = function () {
436  return this.center_;
437};
438
439/**
440 * Returns the map with which the cluster is associated.
441 *
442 * @return {google.maps.Map} The map.
443 * @ignore
444 */
445Cluster.prototype.getMap = function () {
446  return this.map_;
447};
448
449/**
450 * Returns the <code>MarkerClusterer</code> object with which the cluster is associated.
451 *
452 * @return {MarkerClusterer} The associated marker clusterer.
453 * @ignore
454 */
455Cluster.prototype.getMarkerClusterer = function () {
456  return this.markerClusterer_;
457};
458
459/**
460 * Returns the bounds of the cluster.
461 *
462 * @return {google.maps.LatLngBounds} the cluster bounds.
463 * @ignore
464 */
465Cluster.prototype.getBounds = function () {
466  var i;
467  var bounds = new google.maps.LatLngBounds(this.center_, this.center_);
468  var markers = this.getMarkers();
469  for (i = 0; i < markers.length; i++) {
470    bounds.extend(markers[i].getPosition());
471  }
472  return bounds;
473};
474
475/**
476 * Removes the cluster from the map.
477 *
478 * @ignore
479 */
480Cluster.prototype.remove = function () {
481  this.clusterIcon_.setMap(null);
482  this.markers_ = [];
483  delete this.markers_;
484};
485
486/**
487 * Adds a marker to the cluster.
488 *
489 * @param {google.maps.Marker} marker The marker to be added.
490 * @return {boolean} True if the marker was added.
491 * @ignore
492 */
493Cluster.prototype.addMarker = function (marker) {
494  var i;
495  var mCount;
496  var mz;
497  if (this.isMarkerAlreadyAdded_(marker)) {
498    return false;

499  }
500  if (!this.center_) {
501    this.center_ = marker.getPosition();
502    this.calculateBounds_();
503  } else {
504    if (this.averageCenter_) {
505      var l = this.markers_.length + 1;
506      var lat = (this.center_.lat() * (l - 1) + marker.getPosition().lat()) / l;
507      var lng = (this.center_.lng() * (l - 1) + marker.getPosition().lng()) / l;
508      this.center_ = new google.maps.LatLng(lat, lng);
509      this.calculateBounds_();
510    }
511  }
512  marker.isAdded = true;
513  this.markers_.push(marker);
514  mCount = this.markers_.length;
515  mz = this.markerClusterer_.getMaxZoom();
516  if (mz !== null && this.map_.getZoom() > mz) {
517    // Zoomed in past max zoom, so show the marker.
518    if (marker.getMap() !== this.map_) {
519      marker.setMap(this.map_);
520    }
521  } else if (mCount < this.minClusterSize_) {
522    // Min cluster size not reached so show the marker.
523    if (marker.getMap() !== this.map_) {
524      marker.setMap(this.map_);
525    }
526  } else if (mCount === this.minClusterSize_) {
527    // Hide the markers that were showing.
528    for (i = 0; i < mCount; i++) {
529      this.markers_[i].setMap(null);
530    }
531  } else {
532    marker.setMap(null);
533  }
534  this.updateIcon_();
535  return true;
536};
537
538/**
539 * Determines if a marker lies within the cluster's bounds.
540 *
541 * @param {google.maps.Marker} marker The marker to check.
542 * @return {boolean} True if the marker lies in the bounds.
543 * @ignore
544 */
545Cluster.prototype.isMarkerInClusterBounds = function (marker) {
546  return this.bounds_.contains(marker.getPosition());
547};
548
549/**

550 * Calculates the extended bounds of the cluster with the grid.
551 */
552Cluster.prototype.calculateBounds_ = function () {
553  var bounds = new google.maps.LatLngBounds(this.center_, this.center_);
554  this.bounds_ = this.markerClusterer_.getExtendedBounds(bounds);
555};
556
557/**
558 * Updates the cluster icon.
559 */
560Cluster.prototype.updateIcon_ = function () {
561  var mCount = this.markers_.length;
562  var mz = this.markerClusterer_.getMaxZoom();
563  if (mz !== null && this.map_.getZoom() > mz) {
564    this.clusterIcon_.hide();
565    return;
566  }
567  if (mCount < this.minClusterSize_) {
568    // Min cluster size not yet reached.
569    this.clusterIcon_.hide();
570    return;
571  }
572  var numStyles = this.markerClusterer_.getStyles().length;
573  var sums = this.markerClusterer_.getCalculator()(this.markers_, numStyles);
574  this.clusterIcon_.setCenter(this.center_);
575  this.clusterIcon_.useStyle(sums);
576  this.clusterIcon_.show();
577};
578
579/**
580 * Determines if a marker has already been added to the cluster.
581 *
582 * @param {google.maps.Marker} marker The marker to check.
583 * @return {boolean} True if the marker has already been added.
584 */
585Cluster.prototype.isMarkerAlreadyAdded_ = function (marker) {
586  var i;
587  if (this.markers_.indexOf) {
588    return this.markers_.indexOf(marker) !== -1;
589  } else {
590    for (i = 0; i < this.markers_.length; i++) {
591      if (marker === this.markers_[i]) {
592        return true;
593      }
594    }
595  }
596  return false;
597};
598
599/**
600 * @name MarkerClustererOptions
601 * @class This class represents the optional parameter passed to
602 *  the {@link MarkerClusterer} constructor.
603 * @property {number} [gridSize=60] The grid size of a cluster in pixels. The grid is a square.
604 * @property {number} [maxZoom=null] The maximum zoom level at which clustering is enabled or
605 *  <code>null</code> if clustering is to be enabled at all zoom levels.
606 * @property {boolean} [zoomOnClick=true] Whether to zoom the map when a cluster marker is
607 *  clicked. You may want to set this to <code>false</code> if you have installed a handler
608 *  for the <code>click</code> event and it deals with zooming on its own.
609 * @property {boolean} [averageCenter=false] Whether the position of a cluster marker should be
610 *  the average position of all markers in the cluster. If set to <code>false</code>, the
611 *  cluster marker is positioned at the location of the first marker added to the cluster.
612 * @property {number} [minimumClusterSize=2] The minimum number of markers needed in a cluster
613 *  before the markers are hidden and a cluster marker appears.
614 * @property {boolean} [ignoreHidden=false] Whether to ignore hidden markers in clusters. You
615 *  may want to set this to <code>true</code> to ensure that hidden markers are not included
616 *  in the marker count that appears on a cluster marker (this count is the value of the
617 *  <code>text</code> property of the result returned by the default <code>calculator</code>).
618 *  If set to <code>true</code> and you change the visibility of a marker being clustered, be
619 *  sure to also call <code>MarkerClusterer.repaint()</code>.
620 * @property {string} [title=""] The tooltip to display when the mouse moves over a cluster
621 *  marker. (Alternatively, you can use a custom <code>calculator</code> function to specify a
622 *  different tooltip for each cluster marker.)
623 * @property {function} [calculator=MarkerClusterer.CALCULATOR] The function used to determine
624 *  the text to be displayed on a cluster marker and the index indicating which style to use
625 *  for the cluster marker. The input parameters for the function are (1) the array of markers
626 *  represented by a cluster marker and (2) the number of cluster icon styles. It returns a
627 *  {@link ClusterIconInfo} object. The default <code>calculator</code> returns a
628 *  <code>text</code> property which is the number of markers in the cluster and an
629 *  <code>index</code> property which is one higher than the lowest integer such that
630 *  <code>10^i</code> exceeds the number of markers in the cluster, or the size of the styles
631 *  array, whichever is less. The <code>styles</code> array element used has an index of
632 *  <code>index</code> minus 1. For example, the default <code>calculator</code> returns a
633 *  <code>text</code> value of <code>"125"</code> and an <code>index</code> of <code>3</code>
634 *  for a cluster icon representing 125 markers so the element used in the <code>styles</code>
635 *  array is <code>2</code>. A <code>calculator</code> may also return a <code>title</code>
636 *  property that contains the text of the tooltip to be used for the cluster marker. If
637 *   <code>title</code> is not defined, the tooltip is set to the value of the <code>title</code>
638 *   property for the MarkerClusterer.
639 * @property {string} [clusterClass="cluster"] The name of the CSS class defining general styles
640 *  for the cluster markers. Use this class to define CSS styles that are not set up by the code
641 *  that processes the <code>styles</code> array.

642 * @property {Array} [styles] An array of {@link ClusterIconStyle} elements defining the styles
643 *  of the cluster markers to be used. The element to be used to style a given cluster marker
644 *  is determined by the function defined by the <code>calculator</code> property.
645 *  The default is an array of {@link ClusterIconStyle} elements whose properties are derived
646 *  from the values for <code>imagePath</code>, <code>imageExtension</code>, and
647 *  <code>imageSizes</code>.
648 * @property {boolean} [enableRetinaIcons=false] Whether to allow the use of cluster icons that
649 * have sizes that are some multiple (typically double) of their actual display size. Icons such
650 * as these look better when viewed on high-resolution monitors such as Apple's Retina displays.
651 * Note: if this property is <code>true</code>, sprites cannot be used as cluster icons.
652 * @property {number} [batchSize=MarkerClusterer.BATCH_SIZE] Set this property to the
653 *  number of markers to be processed in a single batch when using a browser other than
654 *  Internet Explorer (for Internet Explorer, use the batchSizeIE property instead).
655 * @property {number} [batchSizeIE=MarkerClusterer.BATCH_SIZE_IE] When Internet Explorer is
656 *  being used, markers are processed in several batches with a small delay inserted between
657 *  each batch in an attempt to avoid Javascript timeout errors. Set this property to the
658 *  number of markers to be processed in a single batch; select as high a number as you can
659 *  without causing a timeout error in the browser. This number might need to be as low as 100
660 *  if 15,000 markers are being managed, for example.
661 * @property {string} [imagePath=MarkerClusterer.IMAGE_PATH]
662 *  The full URL of the root name of the group of image files to use for cluster icons.
663 *  The complete file name is of the form <code>imagePath</code>n.<code>imageExtension</code>
664 *  where n is the image file number (1, 2, etc.).
665 * @property {string} [imageExtension=MarkerClusterer.IMAGE_EXTENSION]
666 *  The extension name for the cluster icon image files (e.g., <code>"png"</code> or
667 *  <code>"jpg"</code>).
668 * @property {Array} [imageSizes=MarkerClusterer.IMAGE_SIZES]
669 *  An array of numbers containing the widths of the group of
670 *  <code>imagePath</code>n.<code>imageExtension</code> image files.
671 *  (The images are assumed to be square.)
672 */
673/**
674 * Creates a MarkerClusterer object with the options specified in {@link MarkerClustererOptions}.
675 * @constructor
676 * @extends google.maps.OverlayView
677 * @param {google.maps.Map} map The Google map to attach to.
678 * @param {Array.<google.maps.Marker>} [opt_markers] The markers to be added to the cluster.
679 * @param {MarkerClustererOptions} [opt_options] The optional parameters.
680 */
681function MarkerClusterer(map, opt_markers, opt_options) {
682  // MarkerClusterer implements google.maps.OverlayView interface. We use the
683  // extend function to extend MarkerClusterer with google.maps.OverlayView
684  // because it might not always be available when the code is defined so we
685  // look for it at the last possible moment. If it doesn't exist now then
686  // there is no point going ahead :)
687  this.extend(MarkerClusterer, google.maps.OverlayView);
688  opt_markers = opt_markers || [];
689  opt_options = opt_options || {};
690  this.markers_ = [];
691  this.clusters_ = [];
692  this.listeners_ = [];
693  this.activeMap_ = null;
694  this.ready_ = false;
695  this.gridSize_ = opt_options.gridSize || 60;
696  this.minClusterSize_ = opt_options.minimumClusterSize || 2;
697  this.maxZoom_ = opt_options.maxZoom || null;
698  this.styles_ = opt_options.styles || [];
699  this.title_ = opt_options.title || "";
700  this.zoomOnClick_ = true;
701  if (opt_options.zoomOnClick !== undefined) {
702    this.zoomOnClick_ = opt_options.zoomOnClick;
703  }
704  this.averageCenter_ = false;
705  if (opt_options.averageCenter !== undefined) {
706    this.averageCenter_ = opt_options.averageCenter;
707  }
708  this.ignoreHidden_ = false;
709  if (opt_options.ignoreHidden !== undefined) {
710    this.ignoreHidden_ = opt_options.ignoreHidden;
711  }
712  this.enableRetinaIcons_ = false;
713  if (opt_options.enableRetinaIcons !== undefined) {
714    this.enableRetinaIcons_ = opt_options.enableRetinaIcons;
715  }
716  this.imagePath_ = opt_options.imagePath || MarkerClusterer.IMAGE_PATH;
717  this.imageExtension_ = opt_options.imageExtension || MarkerClusterer.IMAGE_EXTENSION;
718  this.imageSizes_ = opt_options.imageSizes || MarkerClusterer.IMAGE_SIZES;
719  this.calculator_ = opt_options.calculator || MarkerClusterer.CALCULATOR;
720  this.batchSize_ = opt_options.batchSize || MarkerClusterer.BATCH_SIZE;
721  this.batchSizeIE_ = opt_options.batchSizeIE || MarkerClusterer.BATCH_SIZE_IE;
722  this.clusterClass_ = opt_options.clusterClass || "cluster";
723  if (navigator.userAgent.toLowerCase().indexOf("msie") !== -1) {
724    // Try to avoid IE timeout when processing a huge number of markers:
725    this.batchSize_ = this.batchSizeIE_;
726  }
727  this.setupStyles_();
728  this.addMarkers(opt_markers, true);

729  this.setMap(map); // Note: this causes onAdd to be called
730}
731
732/**
733 * Implementation of the onAdd interface method.
734 * @ignore
735 */
736MarkerClusterer.prototype.onAdd = function () {
737  var cMarkerClusterer = this;
738  this.activeMap_ = this.getMap();
739  this.ready_ = true;
740  this.repaint();
741  this.prevZoom_ = this.getMap().getZoom();
742
743  // Add the map event listeners
744  this.listeners_ = [google.maps.event.addListener(this.getMap(), "zoom_changed", function () {
745    // Fix for bug #407
746    // Determines map type and prevents illegal zoom levels
747    var zoom = this.getMap().getZoom();
748    var minZoom = this.getMap().minZoom || 0;
749    var maxZoom = Math.min(this.getMap().maxZoom || 100, this.getMap().mapTypes[this.getMap().getMapTypeId()].maxZoom);
750    zoom = Math.min(Math.max(zoom, minZoom), maxZoom);
751    if (this.prevZoom_ != zoom) {
752      this.prevZoom_ = zoom;
753      this.resetViewport_(false);
754    }
755  }.bind(this)), google.maps.event.addListener(this.getMap(), "idle", function () {
756    cMarkerClusterer.redraw_();
757  })];
758};
759
760/**
761 * Implementation of the onRemove interface method.
762 * Removes map event listeners and all cluster icons from the DOM.
763 * All managed markers are also put back on the map.
764 * @ignore
765 */
766MarkerClusterer.prototype.onRemove = function () {
767  var i;
768
769  // Put all the managed markers back on the map:
770  for (i = 0; i < this.markers_.length; i++) {
771    if (this.markers_[i].getMap() !== this.activeMap_) {
772      this.markers_[i].setMap(this.activeMap_);
773    }
774  }
775
776  // Remove all clusters:
777  for (i = 0; i < this.clusters_.length; i++) {
778    this.clusters_[i].remove();
779  }
780  this.clusters_ = [];
781
782  // Remove map event listeners:
783  for (i = 0; i < this.listeners_.length; i++) {
784    google.maps.event.removeListener(this.listeners_[i]);
785  }
786  this.listeners_ = [];
787  this.activeMap_ = null;
788  this.ready_ = false;
789};
790
791/**
792 * Implementation of the draw interface method.
793 * @ignore
794 */
795MarkerClusterer.prototype.draw = function () {};
796
797/**
798 * Sets up the styles object.
799 */
800MarkerClusterer.prototype.setupStyles_ = function () {
801  var i, size;
802  if (this.styles_.length > 0) {
803    return;
804  }
805  for (i = 0; i < this.imageSizes_.length; i++) {
806    size = this.imageSizes_[i];
807    this.styles_.push({
808      url: this.imagePath_ + (i + 1) + "." + this.imageExtension_,
809      height: size,
810      width: size
811    });
812  }
813};
814
815/**
816 *  Fits the map to the bounds of the markers managed by the clusterer.
817 */
818MarkerClusterer.prototype.fitMapToMarkers = function () {
819  var i;
820  var markers = this.getMarkers();
821  var bounds = new google.maps.LatLngBounds();
822  for (i = 0; i < markers.length; i++) {
823    // March 3, 2018: Bug fix -- honor the ignoreHidden property
824    if (markers[i].getVisible() || !this.getIgnoreHidden()) {
825      bounds.extend(markers[i].getPosition());
826    }
827  }
828  this.getMap().fitBounds(bounds);
829};
830
831/**
832 * Returns the value of the <code>gridSize</code> property.
833 *
834 * @return {number} The grid size.
835 */
836MarkerClusterer.prototype.getGridSize = function () {
837  return this.gridSize_;
838};
839
840/**
841 * Sets the value of the <code>gridSize</code> property.
842 *
843 * @param {number} gridSize The grid size.
844 */
845MarkerClusterer.prototype.setGridSize = function (gridSize) {
846  this.gridSize_ = gridSize;
847};
848
849/**
850 * Returns the value of the <code>minimumClusterSize</code> property.
851 *
852 * @return {number} The minimum cluster size.
853 */
854MarkerClusterer.prototype.getMinimumClusterSize = function () {
855  return this.minClusterSize_;
856};
857
858/**
859 * Sets the value of the <code>minimumClusterSize</code> property.
860 *
861 * @param {number} minimumClusterSize The minimum cluster size.
862 */
863MarkerClusterer.prototype.setMinimumClusterSize = function (minimumClusterSize) {
864  this.minClusterSize_ = minimumClusterSize;
865};
866
867/**
868 *  Returns the value of the <code>maxZoom</code> property.
869 *
870 *  @return {number} The maximum zoom level.
871 */
872MarkerClusterer.prototype.getMaxZoom = function () {
873  return this.maxZoom_;
874};
875
876/**
877 *  Sets the value of the <code>maxZoom</code> property.
878 *
879 *  @param {number} maxZoom The maximum zoom level.
880 */
881MarkerClusterer.prototype.setMaxZoom = function (maxZoom) {
882  this.maxZoom_ = maxZoom;
883};
884
885/**
886 *  Returns the value of the <code>styles</code> property.
887 *
888 *  @return {Array} The array of styles defining the cluster markers to be used.
889 */
890MarkerClusterer.prototype.getStyles = function () {
891  return this.styles_;
892};
893
894/**
895 *  Sets the value of the <code>styles</code> property.
896 *
897 *  @param {Array.<ClusterIconStyle>} styles The array of styles to use.
898 */
899MarkerClusterer.prototype.setStyles = function (styles) {
900  this.styles_ = styles;
901};
902
903/**
904 * Returns the value of the <code>title</code> property.
905 *
906 * @return {string} The content of the title text.
907 */
908MarkerClusterer.prototype.getTitle = function () {
909  return this.title_;
910};
911
912/**
913 *  Sets the value of the <code>title</code> property.
914 *
915 *  @param {string} title The value of the title property.
916 */
917MarkerClusterer.prototype.setTitle = function (title) {
918  this.title_ = title;
919};
920
921/**
922 * Returns the value of the <code>zoomOnClick</code> property.
923 *
924 * @return {boolean} True if zoomOnClick property is set.
925 */
926MarkerClusterer.prototype.getZoomOnClick = function () {
927  return this.zoomOnClick_;
928};
929
930/**
931 *  Sets the value of the <code>zoomOnClick</code> property.
932 *
933 *  @param {boolean} zoomOnClick The value of the zoomOnClick property.
934 */
935MarkerClusterer.prototype.setZoomOnClick = function (zoomOnClick) {
936  this.zoomOnClick_ = zoomOnClick;
937};
938
939/**
940 * Returns the value of the <code>averageCenter</code> property.
941 *
942 * @return {boolean} True if averageCenter property is set.
943 */
944MarkerClusterer.prototype.getAverageCenter = function () {
945  return this.averageCenter_;
946};
947
948/**
949 *  Sets the value of the <code>averageCenter</code> property.
950 *
951 *  @param {boolean} averageCenter The value of the averageCenter property.
952 */
953MarkerClusterer.prototype.setAverageCenter = function (averageCenter) {
954  this.averageCenter_ = averageCenter;
955};
956
957/**
958 * Returns the value of the <code>ignoreHidden</code> property.
959 *
960 * @return {boolean} True if ignoreHidden property is set.
961 */
962MarkerClusterer.prototype.getIgnoreHidden = function () {
963  return this.ignoreHidden_;
964};
965
966/**
967 *  Sets the value of the <code>ignoreHidden</code> property.
968 *
969 *  @param {boolean} ignoreHidden The value of the ignoreHidden property.
970 */
971MarkerClusterer.prototype.setIgnoreHidden = function (ignoreHidden) {
972  this.ignoreHidden_ = ignoreHidden;
973};
974
975/**
976 * Returns the value of the <code>enableRetinaIcons</code> property.
977 *
978 * @return {boolean} True if enableRetinaIcons property is set.
979 */
980MarkerClusterer.prototype.getEnableRetinaIcons = function () {
981  return this.enableRetinaIcons_;
982};
983
984/**
985 *  Sets the value of the <code>enableRetinaIcons</code> property.
986 *
987 *  @param {boolean} enableRetinaIcons The value of the enableRetinaIcons property.
988 */
989MarkerClusterer.prototype.setEnableRetinaIcons = function (enableRetinaIcons) {
990  this.enableRetinaIcons_ = enableRetinaIcons;
991};
992
993/**
994 * Returns the value of the <code>imageExtension</code> property.
995 *
996 * @return {string} The value of the imageExtension property.
997 */
998MarkerClusterer.prototype.getImageExtension = function () {
999  return this.imageExtension_;
1000};
1001
1002/**
1003 *  Sets the value of the <code>imageExtension</code> property.
1004 *
1005 *  @param {string} imageExtension The value of the imageExtension property.
1006 */
1007MarkerClusterer.prototype.setImageExtension = function (imageExtension) {
1008  this.imageExtension_ = imageExtension;
1009};
1010
1011/**
1012 * Returns the value of the <code>imagePath</code> property.
1013 *
1014 * @return {string} The value of the imagePath property.
1015 */
1016MarkerClusterer.prototype.getImagePath = function () {
1017  return this.imagePath_;
1018};
1019
1020/**
1021 *  Sets the value of the <code>imagePath</code> property.
1022 *
1023 *  @param {string} imagePath The value of the imagePath property.
1024 */
1025MarkerClusterer.prototype.setImagePath = function (imagePath) {
1026  this.imagePath_ = imagePath;
1027};
1028
1029/**
1030 * Returns the value of the <code>imageSizes</code> property.
1031 *
1032 * @return {Array} The value of the imageSizes property.
1033 */
1034MarkerClusterer.prototype.getImageSizes = function () {
1035  return this.imageSizes_;
1036};
1037
1038/**
1039 *  Sets the value of the <code>imageSizes</code> property.
1040 *
1041 *  @param {Array} imageSizes The value of the imageSizes property.
1042 */
1043MarkerClusterer.prototype.setImageSizes = function (imageSizes) {
1044  this.imageSizes_ = imageSizes;
1045};
1046
1047/**
1048 * Returns the value of the <code>calculator</code> property.
1049 *
1050 * @return {function} the value of the calculator property.
1051 */
1052MarkerClusterer.prototype.getCalculator = function () {
1053  return this.calculator_;
1054};
1055
1056/**
1057 * Sets the value of the <code>calculator</code> property.
1058 *
1059 * @param {function(Array.<google.maps.Marker>, number)} calculator The value
1060 *  of the calculator property.
1061 */
1062MarkerClusterer.prototype.setCalculator = function (calculator) {
1063  this.calculator_ = calculator;
1064};
1065
1066/**
1067 * Returns the value of the <code>batchSizeIE</code> property.
1068 *
1069 * @return {number} the value of the batchSizeIE property.
1070 */
1071MarkerClusterer.prototype.getBatchSizeIE = function () {
1072  return this.batchSizeIE_;
1073};
1074
1075/**
1076 * Sets the value of the <code>batchSizeIE</code> property.
1077 *
1078 *  @param {number} batchSizeIE The value of the batchSizeIE property.
1079 */
1080MarkerClusterer.prototype.setBatchSizeIE = function (batchSizeIE) {
1081  this.batchSizeIE_ = batchSizeIE;
1082};
1083
1084/**
1085 * Returns the value of the <code>clusterClass</code> property.
1086 *
1087 * @return {string} the value of the clusterClass property.
1088 */
1089MarkerClusterer.prototype.getClusterClass = function () {
1090  return this.clusterClass_;
1091};
1092
1093/**
1094 * Sets the value of the <code>clusterClass</code> property.
1095 *
1096 *  @param {string} clusterClass The value of the clusterClass property.
1097 */
1098MarkerClusterer.prototype.setClusterClass = function (clusterClass) {
1099  this.clusterClass_ = clusterClass;
1100};
1101
1102/**
1103 *  Returns the array of markers managed by the clusterer.
1104 *
1105 *  @return {Array} The array of markers managed by the clusterer.
1106 */
1107MarkerClusterer.prototype.getMarkers = function () {
1108  return this.markers_;
1109};
1110
1111/**
1112 *  Returns the number of markers managed by the clusterer.
1113 *
1114 *  @return {number} The number of markers.
1115 */
1116MarkerClusterer.prototype.getTotalMarkers = function () {
1117  return this.markers_.length;
1118};
1119
1120/**

1121 * Returns the current array of clusters formed by the clusterer.
1122 *
1123 * @return {Array} The array of clusters formed by the clusterer.
1124 */
1125MarkerClusterer.prototype.getClusters = function () {
1126  return this.clusters_;
1127};
1128
1129/**
1130 * Returns the number of clusters formed by the clusterer.
1131 *
1132 * @return {number} The number of clusters formed by the clusterer.
1133 */
1134MarkerClusterer.prototype.getTotalClusters = function () {
1135  return this.clusters_.length;
1136};
1137
1138/**
1139 * Adds a marker to the clusterer. The clusters are redrawn unless
1140 *  <code>opt_nodraw</code> is set to <code>true</code>.
1141 *
1142 * @param {google.maps.Marker} marker The marker to add.
1143 * @param {boolean} [opt_nodraw] Set to <code>true</code> to prevent redrawing.
1144 */
1145MarkerClusterer.prototype.addMarker = function (marker, opt_nodraw) {
1146  this.pushMarkerTo_(marker);
1147  if (!opt_nodraw) {
1148    this.redraw_();
1149  }
1150};
1151
1152/**
1153 * Adds an array of markers to the clusterer. The clusters are redrawn unless
1154 *  <code>opt_nodraw</code> is set to <code>true</code>.
1155 *
1156 * @param {Array.<google.maps.Marker>} markers The markers to add.
1157 * @param {boolean} [opt_nodraw] Set to <code>true</code> to prevent redrawing.
1158 */
1159MarkerClusterer.prototype.addMarkers = function (markers, opt_nodraw) {
1160  var key;
1161  for (key in markers) {
1162    if (markers.hasOwnProperty(key)) {
1163      this.pushMarkerTo_(markers[key]);
1164    }
1165  }
1166  if (!opt_nodraw) {
1167    this.redraw_();
1168  }
1169};
1170
1171/**
1172 * Pushes a marker to the clusterer.
1173 *
1174 * @param {google.maps.Marker} marker The marker to add.
1175 */
1176MarkerClusterer.prototype.pushMarkerTo_ = function (marker) {
1177  // If the marker is draggable add a listener so we can update the clusters on the dragend:
1178  if (marker.getDraggable()) {
1179    var cMarkerClusterer = this;
1180    google.maps.event.addListener(marker, "dragend", function () {
1181      if (cMarkerClusterer.ready_) {
1182        this.isAdded = false;
1183        cMarkerClusterer.repaint();
1184      }
1185    });
1186  }
1187  marker.isAdded = false;
1188  this.markers_.push(marker);
1189};
1190
1191/**
1192 * Removes a marker from the cluster.  The clusters are redrawn unless
1193 *  <code>opt_nodraw</code> is set to <code>true</code>. Returns <code>true</code> if the
1194 *  marker was removed from the clusterer.
1195 *
1196 * @param {google.maps.Marker} marker The marker to remove.
1197 * @param {boolean} [opt_nodraw] Set to <code>true</code> to prevent redrawing.
1198 * @return {boolean} True if the marker was removed from the clusterer.
1199 */
1200MarkerClusterer.prototype.removeMarker = function (marker, opt_nodraw) {
1201  var removed = this.removeMarker_(marker);
1202  if (!opt_nodraw && removed) {
1203    this.repaint();
1204  }
1205  return removed;
1206};
1207
1208/**
1209 * Removes an array of markers from the cluster. The clusters are redrawn unless
1210 *  <code>opt_nodraw</code> is set to <code>true</code>. Returns <code>true</code> if markers
1211 *  were removed from the clusterer.
1212 *
1213 * @param {Array.<google.maps.Marker>} markers The markers to remove.
1214 * @param {boolean} [opt_nodraw] Set to <code>true</code> to prevent redrawing.
1215 * @return {boolean} True if markers were removed from the clusterer.
1216 */
1217MarkerClusterer.prototype.removeMarkers = function (markers, opt_nodraw) {
1218  var i, r;
1219  var removed = false;
1220  for (i = 0; i < markers.length; i++) {
1221    r = this.removeMarker_(markers[i]);
1222    removed = removed || r;
1223  }
1224  if (!opt_nodraw && removed) {
1225    this.repaint();
1226  }
1227  return removed;
1228};
1229
1230/**
1231 * Removes a marker and returns true if removed, false if not.
1232 *
1233 * @param {google.maps.Marker} marker The marker to remove
1234 * @return {boolean} Whether the marker was removed or not
1235 */
1236MarkerClusterer.prototype.removeMarker_ = function (marker) {
1237  var i;
1238  var index = -1;
1239  if (this.markers_.indexOf) {
1240    index = this.markers_.indexOf(marker);
1241  } else {
1242    for (i = 0; i < this.markers_.length; i++) {
1243      if (marker === this.markers_[i]) {
1244        index = i;
1245        break;
1246      }
1247    }
1248  }
1249  if (index === -1) {
1250    // Marker is not in our list of markers, so do nothing:
1251    return false;
1252  }
1253  marker.setMap(null);
1254  this.markers_.splice(index, 1); // Remove the marker from the list of managed markers
1255  return true;
1256};
1257
1258/**

1259 * Removes all clusters and markers from the map and also removes all markers
1260 *  managed by the clusterer.
1261 */
1262MarkerClusterer.prototype.clearMarkers = function () {
1263  this.resetViewport_(true);
1264  this.markers_ = [];
1265};
1266
1267/**
1268 * Recalculates and redraws all the marker clusters from scratch.
1269 *  Call this after changing any properties.
1270 */
1271MarkerClusterer.prototype.repaint = function () {
1272  var oldClusters = this.clusters_.slice();
1273  this.clusters_ = [];
1274  this.resetViewport_(false);
1275  this.redraw_();
1276
1277  // Remove the old clusters.
1278  // Do it in a timeout to prevent blinking effect.
1279  setTimeout(function () {
1280    var i;
1281    for (i = 0; i < oldClusters.length; i++) {
1282      oldClusters[i].remove();
1283    }
1284  }, 0);
1285};
1286
1287/**
1288 * Returns the current bounds extended by the grid size.
1289 *
1290 * @param {google.maps.LatLngBounds} bounds The bounds to extend.
1291 * @return {google.maps.LatLngBounds} The extended bounds.
1292 * @ignore
1293 */
1294MarkerClusterer.prototype.getExtendedBounds = function (bounds) {
1295  var projection = this.getProjection();
1296
1297  // Turn the bounds into latlng.
1298  var tr = new google.maps.LatLng(bounds.getNorthEast().lat(), bounds.getNorthEast().lng());

1299  var bl = new google.maps.LatLng(bounds.getSouthWest().lat(), bounds.getSouthWest().lng());
1300
1301  // Convert the points to pixels and the extend out by the grid size.
1302  var trPix = projection.fromLatLngToDivPixel(tr);
1303  trPix.x += this.gridSize_;
1304  trPix.y -= this.gridSize_;
1305  var blPix = projection.fromLatLngToDivPixel(bl);
1306  blPix.x -= this.gridSize_;
1307  blPix.y += this.gridSize_;
1308
1309  // Convert the pixel points back to LatLng
1310  var ne = projection.fromDivPixelToLatLng(trPix);
1311  var sw = projection.fromDivPixelToLatLng(blPix);
1312
1313  // Extend the bounds to contain the new bounds.
1314  bounds.extend(ne);
1315  bounds.extend(sw);
1316  return bounds;
1317};
1318
1319/**
1320 * Redraws all the clusters.
1321 */
1322MarkerClusterer.prototype.redraw_ = function () {
1323  this.createClusters_(0);
1324};
1325
1326/**
1327 * Removes all clusters from the map. The markers are also removed from the map
1328 *  if <code>opt_hide</code> is set to <code>true</code>.
1329 *
1330 * @param {boolean} [opt_hide] Set to <code>true</code> to also remove the markers
1331 *  from the map.
1332 */
1333MarkerClusterer.prototype.resetViewport_ = function (opt_hide) {
1334  var i, marker;
1335  // Remove all the clusters
1336  for (i = 0; i < this.clusters_.length; i++) {
1337    this.clusters_[i].remove();
1338  }
1339  this.clusters_ = [];
1340
1341  // Reset the markers to not be added and to be removed from the map.
1342  for (i = 0; i < this.markers_.length; i++) {
1343    marker = this.markers_[i];
1344    marker.isAdded = false;
1345    if (opt_hide) {
1346      marker.setMap(null);
1347    }
1348  }
1349};
1350
1351/**
1352 * Calculates the distance between two latlng locations in km.
1353 *
1354 * @param {google.maps.LatLng} p1 The first lat lng point.
1355 * @param {google.maps.LatLng} p2 The second lat lng point.
1356 * @return {number} The distance between the two points in km.
1357 * @see http://www.movable-type.co.uk/scripts/latlong.html
1358*/
1359MarkerClusterer.prototype.distanceBetweenPoints_ = function (p1, p2) {
1360  var R = 6371; // Radius of the Earth in km
1361  var dLat = (p2.lat() - p1.lat()) * Math.PI / 180;
1362  var dLon = (p2.lng() - p1.lng()) * Math.PI / 180;
1363  var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(p1.lat() * Math.PI / 180) * Math.cos(p2.lat() * Math.PI / 180) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
1364  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
1365  var d = R * c;
1366  return d;
1367};
1368
1369/**
1370 * Determines if a marker is contained in a bounds.
1371 *
1372 * @param {google.maps.Marker} marker The marker to check.
1373 * @param {google.maps.LatLngBounds} bounds The bounds to check against.
1374 * @return {boolean} True if the marker is in the bounds.
1375 */
1376MarkerClusterer.prototype.isMarkerInBounds_ = function (marker, bounds) {
1377  return bounds.contains(marker.getPosition());
1378};
1379
1380/**
1381 * Adds a marker to a cluster, or creates a new cluster.
1382 *
1383 * @param {google.maps.Marker} marker The marker to add.
1384 */
1385MarkerClusterer.prototype.addToClosestCluster_ = function (marker) {
1386  var i, d, cluster, center;
1387  var distance = 40000; // Some large number
1388  var clusterToAddTo = null;
1389  for (i = 0; i < this.clusters_.length; i++) {
1390    cluster = this.clusters_[i];
1391    center = cluster.getCenter();
1392    if (center) {
1393      d = this.distanceBetweenPoints_(center, marker.getPosition());
1394      if (d < distance) {
1395        distance = d;
1396        clusterToAddTo = cluster;
1397      }
1398    }
1399  }
1400  if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)) {
1401    clusterToAddTo.addMarker(marker);
1402  } else {
1403    cluster = new Cluster(this);
1404    cluster.addMarker(marker);
1405    this.clusters_.push(cluster);
1406  }
1407};
1408
1409/**
1410 * Creates the clusters. This is done in batches to avoid timeout errors
1411 *  in some browsers when there is a huge number of markers.
1412 *
1413 * @param {number} iFirst The index of the first marker in the batch of
1414 *  markers to be added to clusters.
1415 */
1416MarkerClusterer.prototype.createClusters_ = function (iFirst) {
1417  var i, marker;
1418  var mapBounds;
1419  var cMarkerClusterer = this;
1420  if (!this.ready_) {
1421    return;
1422  }
1423
1424  // Cancel previous batch processing if we're working on the first batch:
1425  if (iFirst === 0) {
1426    /**
1427     * This event is fired when the <code>MarkerClusterer</code> begins
1428     *  clustering markers.
1429     * @name MarkerClusterer#clusteringbegin
1430     * @param {MarkerClusterer} mc The MarkerClusterer whose markers are being clustered.
1431     * @event
1432     */
1433    google.maps.event.trigger(this, "clusteringbegin", this);
1434    if (typeof this.timerRefStatic !== "undefined") {
1435      clearTimeout(this.timerRefStatic);
1436      delete this.timerRefStatic;
1437    }
1438  }
1439
1440  // Get our current map view bounds.
1441  // Create a new bounds object so we don't affect the map.
1442  //
1443  // See Comments 9 & 11 on Issue 3651 relating to this workaround for a Google Maps bug:
1444  if (this.getMap().getZoom() > 3) {
1445    mapBounds = new google.maps.LatLngBounds(this.getMap().getBounds().getSouthWest

1445(), this.getMap().getBounds().getNorthEast());
1446  } else {
1447    mapBounds = new google.maps.LatLngBounds(new google.maps.LatLng(85.02070771743472, -178.48388434375), new google.maps.LatLng(-85.08136444384544, 178.00048865625));
1448  }
1449  var bounds = this.getExtendedBounds(mapBounds);
1450  var iLast = Math.min(iFirst + this.batchSize_, this.markers_.length);
1451  for (i = iFirst; i < iLast; i++) {
1452    marker = this.markers_[i];
1453    if (!marker.isAdded && this.isMarkerInBounds_(marker, bounds)) {
1454      if (!this.ignoreHidden_ || this.ignoreHidden_ && marker.getVisible()) {
1455        this.addToClosestCluster_(marker);
1456      }
1457    }
1458  }
1459  if (iLast < this.markers_.length) {
1460    this.timerRefStatic = setTimeout(function () {
1461      cMarkerClusterer.createClusters_(iLast);
1462    }, 0);
1463  } else {
1464    delete this.timerRefStatic;
1465
1466    /**
1467     * This event is fired when the <code>MarkerClusterer</code> stops
1468     *  clustering markers.
1469     * @name MarkerClusterer#clusteringend
1470     * @param {MarkerClusterer} mc The MarkerClusterer whose markers are being clustered.
1471     * @event
1472     */
1473    google.maps.event.trigger(this, "clusteringend", this);
1474  }
1475};
1476
1477/**
1478 * Extends an object's prototype by another's.
1479 *
1480 * @param {Object} obj1 The object to be extended.
1481 * @param {Object} obj2 The object to extend with.
1482 * @return {Object} The new extended object.
1483 * @ignore
1484 */
1485MarkerClusterer.prototype.extend = function (obj1, obj2) {
1486  return function (object) {
1487    var property;
1488    for (property in object.prototype) {
1489      this.prototype[property] = object.prototype[property];
1490    }
1491    return this;
1492  }.apply(obj1, [obj2]);
1493};
1494
1495/**
1496 * The default function for determining the label text and style
1497 * for a cluster icon.
1498 *
1499 * @param {Array.<google.maps.Marker>} markers The array of markers represented by the cluster.
1500 * @param {number} numStyles The number of marker styles available.
1501 * @return {ClusterIconInfo} The information resource for the cluster.
1502 * @constant
1503 * @ignore
1504 */
1505MarkerClusterer.CALCULATOR = function (markers, numStyles) {
1506  var index = 0;
1507  var title = "";
1508  var count = markers.length.toString();
1509  var dv = count;
1510  while (dv !== 0) {
1511    dv = parseInt(dv / 10, 10);
1512    index++;
1513  }
1514  index = Math.min(index, numStyles);
1515  return {
1516    text: count,
1517    index: index,
1518    title: title
1519  };
1520};
1521
1522/**
1523 * The number of markers to process in one batch.
1524 *
1525 * @type {number}
1526 * @constant
1527 */
1528MarkerClusterer.BATCH_SIZE = 2000;
1529
1530/**
1531 * The number of markers to process in one batch (IE only).
1532 *
1533 * @type {number}
1534 * @constant
1535 */
1536MarkerClusterer.BATCH_SIZE_IE = 500;
1537
1538/**
1539 * The default root name for the marker cluster images.
1540 *
1541 * @type {string}
1542 * @constant
1543 */
1544MarkerClusterer.IMAGE_PATH = "https://cdn.rawgit.com/googlemaps/js-marker-clusterer/gh-pages/images/m";
1545
1546/**
1547 * The default extension name for the marker cluster images.
1548 *
1549 * @type {string}
1550 * @constant
1551 */
1552MarkerClusterer.IMAGE_EXTENSION = "png";
1553
1554/**
1555 * The default array of sizes for the marker cluster images.
1556 *
1557 * @type {Array.<number>}
1558 * @constant
1559 */
1560MarkerClusterer.IMAGE_SIZES = [53, 56, 66, 78, 90];
1561if ((typeof module === "undefined" ? "undefined" : _typeof(module)) == 'object') {
1562  module.exports = MarkerClusterer;
1563}
1564
1565},{}],3:[function(require,module,exports){
1566(function (global){(function (){
1567function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
1568/*
1569 * jQuery File Upload Plugin
1570 * https://github.com/blueimp/jQuery-File-Upload
1571 *
1572 * Copyright 2010, Sebastian Tschan
1573 * https://blueimp.net
1574 *
1575 * Licensed under the MIT license:
1576 * https://opensource.org/licenses/MIT
1577 */
1578
1579/* global define, require */
1580/* eslint-disable new-cap */
1581
1582(function (factory) {
1583  'use strict';
1584
1585  if (typeof define === 'function' && define.amd) {
1586    // Register as an anonymous AMD module:
1587    define(['jquery', 'jquery-ui/ui/widget'], factory);
1588  } else if ((typeof exports === "undefined" ? "undefined" : _typeof(exports)) === 'object') {
1589    // Node/CommonJS:
1590    factory((typeof window !== "undefined" ? window['$'] : typeof global !== "undefined" ? global['$'] : null), require('./vendor/jquery.ui.widget'));
1591  } else {
1592    // Browser globals:
1593    factory(window.jQuery);
1594  }
1595})(function ($) {
1596  'use strict';
1597
1598  // Detect file input support, based on
1599  // https://viljamis.com/2012/file-upload-support-on-mobile/
1600  $.support.fileInput = !(new RegExp(
1601  // Handle devices which give false positives for the feature detection:
1602  '(Android (1\\.[0156]|2\\.[01]))' + '|(Windows Phone (OS 7|8\\.0))|(XBLWP)|(ZuneWP)|(WPDesktop)' + '|(w(eb)?OSBrowser)|(webOS)' + '|(Kindle/(1\\.0|2\\.[05]|3\\.0))').test(window.navigator.userAgent) ||
1603  // Feature detection for all other devices:
1604  $('<input type="file"/>').prop('disabled'));
1605
1606  // The FileReader API is not actually used, but works as feature detection,

1607  // as some Safari versions (5?) support XHR file uploads via the FormData API,
1608  // but not non-multipart XHR file uploads.
1609  // window.XMLHttpRequestUpload is not available on IE10, so we check for
1610  // window.ProgressEvent instead to detect XHR2 file upload capability:
1611  $.support.xhrFileUpload = !!(window.ProgressEvent && window.FileReader);
1612  $.support.xhrFormDataFileUpload = !!window.FormData;
1613
1614  // Detect support for Blob slicing (required for chunked uploads):
1615  $.support.blobSlice = window.Blob && (Blob.prototype.slice || Blob.prototype.webkitSlice || Blob.prototype.mozSlice);
1616
1617  /**
1618   * Helper function to create drag handlers for dragover/dragenter/dragleave
1619   *
1620   * @param {string} type Event type
1621   * @returns {Function} Drag handler
1622   */
1623  function getDragHandler(type) {
1624    var isDragOver = type === 'dragover';
1625    return function (e) {
1626      e.dataTransfer = e.originalEvent && e.originalEvent.dataTransfer;
1627      var dataTransfer = e.dataTransfer;
1628      if (dataTransfer && $.inArray('Files', dataTransfer.types) !== -1 && this._trigger(type, $.Event(type, {
1629        delegatedEvent: e
1630      })) !== false) {
1631        e.preventDefault();
1632        if (isDragOver) {
1633          dataTransfer.dropEffect = 'copy';
1634        }
1635      }
1636    };
1637  }
1638
1639  // The fileupload widget listens for change events on file input fields defined
1640  // via fileInput setting and paste or drop events of the given dropZone.
1641  // In addition to the default jQuery Widget methods, the fileupload widget
1642  // exposes the "add" and "send" methods, to add or directly send files using
1643  // the fileupload API.
1644  // By default, files added via file input selection, paste, drag & drop or
1645  // "add" method are uploaded immediately, but it is possible to override
1646  // the "add" callback option to queue file uploads.
1647  $.widget('blueimp.fileupload', {
1648    options: {
1649      // The drop target element(s), by the default the complete document.
1650      // Set to null to disable drag & drop support:
1651      dropZone: $(document),
1652      // The paste target element(s), by the default undefined.
1653      // Set to a DOM node or jQuery object to enable file pasting:
1654      pasteZone: undefined,
1655      // The file input field(s), that are listened to for change events.
1656      // If undefined, it is set to the file input fields inside
1657      // of the widget element on plugin initialization.
1658      // Set to null to disable the change listener.
1659      fileInput: undefined,
1660      // By default, the file input field is replaced with a clone after
1661      // each input field change event. This is required for iframe transport
1662      // queues and allows change events to be fired for the same file
1663      // selection, but can be disabled by setting the following option to false:
1664      replaceFileInput: true,
1665      // The parameter name for the file form data (the request argument name).
1666      // If undefined or empty, the name property of the file input field is
1667      // used, or "files[]" if the file input name property is also empty,
1668      // can be a string or an array of strings:
1669      paramName: undefined,
1670      // By default, each file of a selection is uploaded using an individual
1671      // request for XHR type uploads. Set to false to upload file
1672      // selections in one request each:
1673      singleFileUploads: true,
1674      // To limit the number of files uploaded with one XHR request,
1675      // set the following option to an integer greater than 0:
1676      limitMultiFileUploads: undefined,
1677      // The following option limits the number of files uploaded with one
1678      // XHR request to keep the request size under or equal to the defined
1679      // limit in bytes:
1680      limitMultiFileUploadSize: undefined,
1681      // Multipart file uploads add a number of bytes to each uploaded file,
1682      // therefore the following option adds an overhead for each file used
1683      // in the limitMultiFileUploadSize configuration:
1684      limitMultiFileUploadSizeOverhead: 512,
1685      // Set the following option to true to issue all file upload requests
1686      // in a sequential order:
1687      sequentialUploads: false,
1688      // To limit the number of concurrent uploads,
1689      // set the following option to an integer greater than 0:
1690      limitConcurrentUploads: undefined,
1691      // Set the following option to true to force iframe transport uploads:
1692      forceIframeTransport: false,
1693      // Set the following option to the location of a redirect url on the
1694      // origin server, for cross-domain iframe transport uploads:
1695      redirect: undefined,
1696      // The parameter name for the redirect url, sent as part of the form
1697      // data and set to 'redirect' if this option is empty:
1698      redirectParamName: undefined,
1699      // Set the following option to the location of a postMessage window,
1700      // to enable postMessage transport uploads:
1701      postMessage: undefined,
1702      // By default, XHR file uploads are sent as multipart/form-data.
1703      // The iframe transport is always using multipart/form-data.
1704      // Set to false to enable non-multipart XHR uploads:
1705      multipart: true,
1706      // To upload large files in smaller chunks, set the following option
1707      // to a preferred maximum chunk size. If set to 0, null or undefined,
1708      // or the browser does not support the required Blob API, files will
1709      // be uploaded as a whole.
1710      maxChunkSize: undefined,
1711      // When a non-multipart upload or a chunked multipart upload has been
1712      // aborted, this option can be used to resume the upload by setting
1713      // it to the size of the already uploaded bytes. This option is most
1714      // useful when modifying the options object inside of the "add" or
1715      // "send" callbacks, as the options are cloned for each file upload.
1716      uploadedBytes: undefined,
1717      // By default, failed (abort or error) file uploads are removed from the
1718      // global progress calculation. Set the following option to fal

1718se to
1719      // prevent recalculating the global progress data:
1720      recalculateProgress: true,
1721      // Interval in milliseconds to calculate and trigger progress events:
1722      progressInterval: 100,
1723      // Interval in milliseconds to calculate progress bitrate:
1724      bitrateInterval: 500,
1725      // By default, uploads are started automatically when adding files:
1726      autoUpload: true,
1727      // By default, duplicate file names are expected to be handled on
1728      // the server-side. If this is not possible (e.g. when uploading
1729      // files directly to Amazon S3), the following option can be set to
1730      // an empty object or an object mapping existing filenames, e.g.:
1731      // { "image.jpg": true, "image (1).jpg": true }
1732      // If it is set, all files will be uploaded with unique filenames,
1733      // adding increasing number suffixes if necessary, e.g.:
1734      // "image (2).jpg"
1735      uniqueFilenames: undefined,
1736      // Error and info messages:
1737      messages: {
1738        uploadedBytes: 'Uploaded bytes exceed file size'
1739      },
1740      // Translation function, gets the message key to be translated
1741      // and an object with context specific data as arguments:
1742      i18n: function i18n(message, context) {
1743        // eslint-disable-next-line no-param-reassign
1744        message = this.messages[message] || message.toString();
1745        if (context) {
1746          $.each(context, function (key, value) {
1747            // eslint-disable-next-line no-param-reassign
1748            message = message.replace('{' + key + '}', value);
1749          });
1750        }
1751        return message;
1752      },
1753      // Additional form data to be sent along with the file uploads can be set
1754      // using this option, which accepts an array of objects with name and
1755      // value properties, a function returning such an array, a FormData
1756      // object (for XHR file uploads), or a simple object.
1757      // The form of the first fileInput is given as parameter to the function:
1758      formData: function formData(form) {
1759        return form.serializeArray();
1760      },
1761      // The add callback is invoked as soon as files are added to the fileupload
1762      // widget (via file input selection, drag & drop, paste or add API call).
1763      // If the singleFileUploads option is enabled, this callback will be
1764      // called once for each file in the selection for XHR file uploads, else
1765      // once for each file selection.
1766      //
1767      // The upload starts when the submit method is invoked on the data parameter.
1768      // The data object contains a files property holding the added files
1769      // and allows you to override plugin options as well as define ajax settings.
1770      //
1771      // Listeners for this callback can also be bound the following way:
1772      // .on('fileuploadadd', func);
1773      //
1774      // data.submit() returns a Promise object and allows to attach additional
1775      // handlers using jQuery's Deferred callbacks:
1776      // data.submit().done(func).fail(func).always(func);
1777      add: function add(e, data) {
1778        if (e.isDefaultPrevented()) {
1779          return false;
1780        }
1781        if (data.autoUpload || data.autoUpload !== false && $(this).fileupload('option', 'autoUpload')) {
1782          data.process().done(function () {
1783            data.submit();
1784          });
1785        }
1786      },
1787      // Other callbacks:
1788
1789      // Callback for the submit event of each file upload:
1790      // submit: function (e, data) {}, // .on('fileuploadsubmit', func);
1791
1792      // Callback for the start of each file upload request:
1793      // send: function (e, data) {}, // .on('fileuploadsend', func);
1794
1795      // Callback for successful uploads:
1796      // done: function (e, data) {}, // .on('fileuploaddone', func);
1797
1798      // Callback for failed (abort or error) uploads:
1799      // fail: function (e, data) {}, // .on('fileuploadfail', func);
1800
1801      // Callback for completed (success, abort or error) requests:
1802      // always: function (e, data) {}, // .on('fileuploadalways', func);
1803
1804      // Callback for upload progress events:
1805      // progress: function (e, data) {}, // .on('fileuploadprogress', func);
1806
1807      // Callback for global upload progress events:
1808      // progressall: function (e, data) {}, // .on('fileuploadprogressall', func);
1809
1810      // Callback for uploads start, equivalent to the global ajaxStart event:
1811      // start: function (e) {}, // .on('fileuploadstart', func);
1812
1813      // Callback for uploads stop, equivalent to the global ajaxStop event:
1814      // stop: function (e) {}, // .on('fileuploadstop', func);
1815
1816      // Callback for change events of the fileInput(s):
1817      // change: function (e, data) {}, // .on('fileuploadchange', func);
1818
1819      // Callback for paste events to the pasteZone(s):
1820      // paste: function (e, data) {}, // .on('fileuploadpaste', func);
1821
1822      // Callback for drop events of the dropZone(s):
1823      // drop: function (e, data) {}, // .on('fileuploaddrop', func);
1824
1825      // Callback for dragover events of the dropZone(s):
1826      // dragover: function (e) {}, // .on('fileuploaddragover', func);
1827
1828      // Callback before the start of each chunk upload request (before form data initialization):
1829      // chunkbeforesend: function (e, data) {}, // .on('fileuploadchunkbeforesend', func);
1830
1831      // Callback for the start of each chunk upload request:
1832      // chunksend: function (e, data) {}, // .on('fileuploadchunksend', func);
1833
1834      // Callback for successful chunk uploads:
1835      // chunkdone: function (e, data) {}, // .on('fileuploadchunkdone', func);
1836
1837      // Callback for failed (abort or error) chunk uploads:
1838      // chunkfail: function (e, data) {}, // .on('fileuploadchunkfail', func);
1839
1840      // Callback for completed (success, abort or error) chunk upload requests:
1841      // chunkalways: function (e, data) {}, // .on('fileuploadchunkalways', func);
1842
1843      // The plugin options are used as settings object for the ajax calls.
1844      // The following are jQuery ajax settings required for the file uploads:
1845      processData: false,
1846      contentType: false,
1847      cache: false,
1848      timeout: 0
1849    },
1850    // jQuery versions before 1.8 require promise.pipe if the return value is
1851    // used, as promise.then in older versions has a different behavior, see:
1852    // https://blog.jquery.com/2012/08/09/jquery-1-8-released/
1853    // https://bugs.jquery.com/ticket/11010
1854    // https://github.com/blueimp/jQuery-File-Upload/pull/3435
1855    _promisePipe: function () {
1856      var parts = $.fn.jquery.split('.');
1857      return Number(parts[0]) > 1 || Number(parts[1]) > 7 ? 'then' : 'pipe';
1858    }(),
1859    // A list of options that require reinitializing event listeners and/or
1860    // special initialization code:
1861    _specialOptions: ['fileInput', 'dropZone', 'pasteZone', 'multipart', 'forceIframeTransport'],
1862    _blobSlice: $.support.blobSlice && function () {
1863      var slice = this.slice || this.webkitSlice || this.mozSlice;
1864      return slice.apply(this, arguments);
1865    },
1866    _BitrateTimer: function _BitrateTimer() {
1867      this.timestamp = Date.now ? Date.now() : new Date().getTime();
1868      this.loaded = 0;
1869      this.bitrate = 0;
1870      this.getBitrate = function (now, loaded, interval) {
1871        var timeDiff = now - this.timestamp;
1872        if (!this.bitrate || !interval || timeDiff > interval) {
1873          this.bitrate = (loaded - this.loaded) * (1000 / timeDiff) * 8;
1874          this.loaded = loaded;
1875          this.timestamp = now;
1876        }
1877        return this.bitrate;
1878      };
1879    },
1880    _isXHRUpload: function _isXHRUpload(options) {
1881      return !options.forceIframeTransport && (!options.multipart && $.support.xhrFileUpload || $.support.xhrFormDataFileUpload);
1882    },
1883    _getFormData: function _getFormData(options) {
1884      var formData;
1885      if ($.type(options.formData) === 'function') {
1886        return options.formData(options.form);
1887      }
1888      if ($.isArray(options.formData)) {
1889        return options.formData;
1890      }
1891      if ($.type(options.formData) === 'object') {
1892        formData = [];
1893        $.each(options.formData, function (name, value) {
1894          formData.push({
1895            name: name,
1896            value: value
1897          });
1898        });
1899        return formData;
1900      }
1901      return [];
1902    },
1903    _getTotal: function _getTotal(files) {
1904      var total = 0;
1905      $.each(files, function (index, file) {
1906        total += file.size || 1;
1907      });
1908      return total;
1909    },
1910    _initProgressObject: function _initProgressObject(obj) {
1911      var progress = {
1912        loaded: 0,
1913        total: 0,
1914        bitrate: 0
1915      };
1916      if (obj._progress) {
1917        $.extend(obj._progress, progress);
1918      } else {
1919        obj._progress = progress;
1920      }
1921    },
1922    _initResponseObject: function _initResponseObject(obj) {
1923      var prop;
1924      if (obj._response) {
1925        for (prop in obj._response) {
1926          if (Object.prototype.hasOwnProperty.call(obj._response, prop)) {
1927            delete obj._response[prop];
1928          }
1929        }
1930      } else {
1931        obj._response = {};
1932      }
1933    },
1934    _onProgress: function _onProgress(e, data) {
1935      if (e.lengthComputable) {
1936        var now = Date.now ? Date.now() : new Date().getTime(),
1937          loaded;
1938        if (data._time && data.progressInterval && now - data._time < data.progressInterval && e.loaded !== e.total) {
1939          return;
1940        }
1941        data._time = now;
1942        loaded = Math.floor(e.loaded / e.total * (data.chunkSize || data._progress.total)) + (data.uploadedBytes || 0);
1943        // Add the difference from the previously loaded state
1944        // to the global loaded counter:
1945        this._progress.loaded += loaded - data._progress.loaded;
1946        this._progress.bitrate = this._bitrateTimer.getBitrate(now, this._progress.loaded, data.bitrateInterval);
1947        data._progress.loaded = data.loaded = loaded;
1948        data._progress.bitrate = data.bitrate = data._bitrateTimer.getBitrate(now, loaded, data.bitrateInterval);
1949        // Trigger a custom progress event with a total data property set
1950        // to the file size(s) of the current upload and a loaded data
1951        // property calculated accordingly:
1952        this._trigger('progress', $.Event('progress', {
1953          delegatedEvent: e
1954        }), data);
1955        // Trigger a global progress event for all current file uploads,
1956        // including ajax calls queued for sequential file uploads:
1957        this._trigger('progressall', $.Event('progressall', {
1958          delegatedEvent: e
1959        }), this._progress);
1960      }
1961    },
1962    _initProgressListener: function _initProgressListener(options) {
1963      var that = this,
1964        xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();
1965      // Access to the native XHR object is required to add event listeners
1966      // for the upload progress event:
1967      if (xhr.upload) {
1968        $(xhr.upload).on('progress', function (e) {
1969          var oe = e.originalEvent;
1970          // Make sure the progress event properties get copied over:
1971          e.lengthComputable = oe.lengthComputable;
1972          e.loaded = oe.loaded;
1973          e.total = oe.total;
1974          that._onProgress(e, options);
1975        });
1976        options.xhr = function () {
1977          return xhr;
1978        };
1979      }
1980    },
1981    _deinitProgressListener: function _deinitProgressListener(options) {
1982      var xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();
1983      if (xhr.upload) {
1984        $(xhr.upload).off('progress');
1985      }
1986    },
1987    _isInstanceOf: function _isInstanceOf(type, obj) {
1988      // Cross-frame instanceof check
1989      return Object.prototype.toString.call(obj) === '[object ' + type + ']';
1990    },
1991    _getUniqueFilename: function _getUniqueFilename(name, map) {
1992      // eslint-disable-next-line no-param-reassign
1993      name = String(name);
1994      if (map[name]) {
1995        // eslint-disable-next-line no-param-reassign
1996        name = name.replace(/(?: \(([\d]+)\))?(\.[^.]+)?$/, function (_, p1, p2) {
1997          var index = p1 ? Number(p1) + 1 : 1;
1998          var ext = p2 || '';
1999          return ' (' + index + ')' + ext;
2000        });
2001        return this._getUniqueFilename(name, map);
2002      }
2003      map[name] = true;
2004      return name;
2005    },
2006    _initXHRData: function _initXHRData(options) {
2007      var that = this,
2008        formData,
2009        file = options.files[0],
2010        // Ignore non-multipart setting if not supported:

2011        multipart = options.multipart || !$.support.xhrFileUpload,
2012        paramName = $.type(options.paramName) === 'array' ? options.paramName[0] : options.paramName;
2013      options.headers = $.extend({}, options.headers);
2014      if (options.contentRange) {
2015        options.headers['Content-Range'] = options.contentRange;
2016      }
2017      if (!multipart || options.blob || !this._isInstanceOf('File', file)) {
2018        options.headers['Content-Disposition'] = 'attachment; filename="' + encodeURI(file.uploadName || file.name) + '"';
2019      }
2020      if (!multipart) {
2021        options.contentType = file.type || 'application/octet-stream';
2022        options.data = options.blob || file;
2023      } else if ($.support.xhrFormDataFileUpload) {
2024        if (options.postMessage) {
2025          // window.postMessage does not allow sending FormData
2026          // objects, so we just add the File/Blob objects to
2027          // the formData array and let the postMessage window
2028          // create the FormData object out of this array:
2029          formData = this._getFormData(options);
2030          if (options.blob) {
2031            formData.push({
2032              name: paramName,
2033              value: options.blob
2034            });
2035          } else {
2036            $.each(options.files, function (index, file) {
2037              formData.push({
2038                name: $.type(options.paramName) === 'array' && options.paramName[index] || paramName,
2039                value: file
2040              });
2041            });
2042          }
2043        } else {
2044          if (that._isInstanceOf('FormData', options.formData)) {
2045            formData = options.formData;
2046          } else {
2047            formData = new FormData();
2048            $.each(this._getFormData(options), function (index, field) {
2049              formData.append(field.name, field.value);
2050            });
2051          }
2052          if (options.blob) {
2053            formData.append(paramName, options.blob, file.uploadName || file.name);
2054          } else {
2055            $.each(options.files, function (index, file) {
2056              // This check allows the tests to run with
2057              // dummy objects:
2058              if (that._isInstanceOf('File', file) || that._isInstanceOf('Blob', file)) {
2059                var fileName = file.uploadName || file.name;
2060                if (options.uniqueFilenames) {
2061                  fileName = that._getUniqueFilename(fileName, options.uniqueFilenames);
2062                }
2063                formData.append($.type(options.paramName) === 'array' && options.paramName[index] || paramName, file, fileName);
2064              }
2065            });
2066          }
2067        }
2068        options.data = formData;
2069      }
2070      // Blob reference is not needed anymore, free memory:
2071      options.blob = null;
2072    },
2073    _initIframeSettings: function _initIframeSettings(options) {
2074      var targetHost = $('<a></a>').prop('href', options.url).prop('host');
2075      // Setting the dataType to iframe enables the iframe transport:
2076      options.dataType = 'iframe ' + (options.dataType || '');
2077      // The iframe transport accepts a serialized array as form data:
2078      options.formData = this._getFormData(options);
2079      // Add redirect url to form data on cross-domain uploads:
2080      if (options.redirect && targetHost && targetHost !== location.host) {
2081        options.formData.push({
2082          name: options.redirectParamName || 'redirect',
2083          value: options.redirect
2084        });
2085      }
2086    },
2087    _initDataSettings: function _initDataSettings(options) {
2088      if (this._isXHRUpload(options)) {
2089        if (!this._chunkedUpload(options, true)) {
2090          if (!options.data) {
2091            this._initXHRData(options);
2092          }
2093          this._initProgressListener(options);
2094        }
2095        if (options.postMessage) {
2096          // Setting the dataType to postmessage enables the
2097          // postMessage transport:
2098          options.dataType = 'postmessage ' + (options.dataType || '');
2099        }
2100      } else {
2101        this._initIframeSettings(options);
2102      }
2103    },
2104    _getParamName: function _getParamName(options) {
2105      var fileInput = $(options.fileInput),
2106        paramName = options.paramName;
2107      if (!paramName) {
2108        paramName = [];
2109        fileInput.each(function () {
2110          var input = $(this),
2111            name = input.prop('name') || 'files[]',
2112            i = (input.prop('files') || [1]).length;
2113          while (i) {
2114            paramName.push(name);
2115            i -= 1;
2116          }
2117        });
2118        if (!paramName.length) {
2119          paramName = [fileInput.prop('name') || 'files[]'];
2120        }
2121      } else if (!$.isArray(paramName)) {
2122        paramName = [paramName];
2123      }
2124      return paramName;
2125    },
2126    _initFormSettings: function _initFormSettings(options) {
2127      // Retrieve missing options from the input field and the
2128      // associated form, if available:
2129      if (!options.form || !options.form.length) {
2130        options.form = $(options.fileInput.prop('form'));
2131        // If the given file input doesn't have an associated form,
2132        // use the default widget file input's form:
2133        if (!options.form.length) {
2134          options.form = $(this.options.fileInput.prop('form'));
2135        }
2136      }
2137      options.paramName = this._getParamName(options);
2138      if (!options.url) {
2139        options.url = options.form.prop('action') || location.href;
2140      }
2141      // The HTTP request method must be "POST" or "PUT":
2142      options.type = (options.type || $.type(options.form.prop('method')) === 'string' && options.form.prop('method') || '').toUpperCase();
2143      if (options.type !== 'POST' && options.type !== 'PUT' && options.type !== 'PATCH') {
2144        options.type = 'POST';
2145      }
2146      if (!options.formAcceptCharset) {
2147        options.formAcceptCharset = options.form.attr('accept-charset');
2148      }
2149    },
2150    _getAJAXSettings: function _getAJAXSettings(data) {
2151      var options = $.extend({}, this.options, data);
2152      this._initFormSettings(options);
2153      this._initDataSettings(options);
2154      return options;
2155    },
2156    // jQuery 1.6 doesn't provide .state(),
2157    // while jQuery 1.8+ removed .isRejected() and .isResolved():
2158    _getDeferredState: function _getDeferredState(deferred) {
2159      if (deferred.state) {
2160        return deferred.state();
2161      }
2162      if (deferred.isResolved()) {
2163        return 'resolved';
2164      }
2165      if (deferred.isRejected()) {
2166        return 'rejected';
2167      }
2168      return 'pending';
2169    },
2170    // Maps jqXHR callbacks to the equivalent
2171    // methods of the given Promise object:
2172    _enhancePromise: function _enhancePromise(promise) {
2173      promise.success = promise.done;
2174      promise.error = promise.fail;
2175      promise.complete = promise.always;
2176      return promise;
2177    },
2178    // Creates and returns a Promise object enhanced with
2179    // the jqXHR methods abort, success, error and complete:
2180    _getXHRPromise: function _getXHRPromise(resolveOrReject, context, args

2180) {
2181      var dfd = $.Deferred(),
2182        promise = dfd.promise();
2183      // eslint-disable-next-line no-param-reassign
2184      context = context || this.options.context || promise;
2185      if (resolveOrReject === true) {
2186        dfd.resolveWith(context, args);
2187      } else if (resolveOrReject === false) {
2188        dfd.rejectWith(context, args);
2189      }
2190      promise.abort = dfd.promise;
2191      return this._enhancePromise(promise);
2192    },
2193    // Adds convenience methods to the data callback argument:
2194    _addConvenienceMethods: function _addConvenienceMethods(e, data) {
2195      var that = this,
2196        getPromise = function getPromise(args) {
2197          return $.Deferred().resolveWith(that, args).promise();
2198        };
2199      data.process = function (resolveFunc, rejectFunc) {
2200        if (resolveFunc || rejectFunc) {
2201          data._processQueue = this._processQueue = (this._processQueue || getPromise([this]))[that._promisePipe](function () {
2202            if (data.errorThrown) {
2203              return $.Deferred().rejectWith(that, [data]).promise();
2204            }
2205            return getPromise(arguments);
2206          })[that._promisePipe](resolveFunc, rejectFunc);
2207        }
2208        return this._processQueue || getPromise([this]);
2209      };
2210      data.submit = function () {
2211        if (this.state() !== 'pending') {
2212          data.jqXHR = this.jqXHR = that._trigger('submit', $.Event('submit', {
2213            delegatedEvent: e
2214          }), this) !== false && that._onSend(e, this);
2215        }
2216        return this.jqXHR || that._getXHRPromise();
2217      };
2218      data.abort = function () {
2219        if (this.jqXHR) {
2220          return this.jqXHR.abort();
2221        }
2222        this.errorThrown = 'abort';
2223        that._trigger('fail', null, this);
2224        return that._getXHRPromise(false);
2225      };
2226      data.state = function () {
2227        if (this.jqXHR) {
2228          return that._getDeferredState(this.jqXHR);
2229        }
2230        if (this._processQueue) {
2231          return that._getDeferredState(this._processQueue);
2232        }
2233      };
2234      data.processing = function () {
2235        return !this.jqXHR && this._processQueue && that._getDeferredState(this._processQueue) === 'pending';
2236      };
2237      data.progress = function () {
2238        return this._progress;
2239      };
2240      data.response = function () {
2241        return this._response;
2242      };
2243    },
2244    // Parses the Range header from the server response
2245    // and returns the uploaded bytes:
2246    _getUploadedBytes: function _getUploadedBytes(jqXHR) {
2247      var range = jqXHR.getResponseHeader('Range'),
2248        parts = range && range.split('-'),
2249        upperBytesPos = parts && parts.length > 1 && parseInt(parts[1], 10);
2250      return upperBytesPos && upperBytesPos + 1;
2251    },
2252    // Uploads a file in multiple, sequential requests
2253    // by splitting the file up in multiple blob chunks.
2254    // If the second parameter is true, only tests if the file
2255    // should be uploaded in chunks, but does not invoke any
2256    // upload requests:
2257    _chunkedUpload: function _chunkedUpload(options, testOnly) {
2258      options.uploadedBytes = options.uploadedBytes || 0;
2259      var that = this,
2260        file = options.files[0],
2261        fs = file.size,
2262        ub = options.uploadedBytes,
2263        mcs = options.maxChunkSize || fs,
2264        slice = this._blobSlice,
2265        dfd = $.Deferred(),
2266        promise = dfd.promise(),
2267        jqXHR,
2268        _upload;
2269      if (!(this._isXHRUpload(options) && slice && (ub || ($.type(mcs) === 'function' ? mcs(options) : mcs) < fs)) || options.data) {
2270        return false;
2271      }
2272      if (testOnly) {
2273        return true;
2274      }
2275      if (ub >= fs) {
2276        file.error = options.i18n('uploadedBytes');
2277        return this._getXHRPromise(false, options.context, [null, 'error', file.error]);
2278      }
2279      // The chunk upload method:
2280      _upload = function upload() {
2281        // Clone the options object for each chunk upload:
2282        var o = $.extend({}, options),
2283          currentLoaded = o._progress.loaded;
2284        o.blob = slice.call(file, ub, ub + ($.type(mcs) === 'function' ? mcs(o) : mcs), file.type);
2285        // Store the current chunk size, as the blob itself
2286        // will be dereferenced after data processing:
2287        o.chunkSize = o.blob.size;
2288        // Expose the chunk bytes position range:
2289        o.contentRange = 'bytes ' + ub + '-' + (ub + o.chunkSize - 1) + '/' + fs;
2290        // Trigger chunkbeforesend to allow form data to be updated for this chunk
2291        that._trigger('chunkbeforesend', null, o);
2292        // Process the upload data (the blob and potential form data):
2293        that._initXHRData(o);
2294        // Add progress listeners for this chunk upload:
2295        that._initProgressListener(o);

2296        jqXHR = (that._trigger('chunksend', null, o) !== false && $.ajax(o) || that._getXHRPromise(false, o.context)).done(function (result, textStatus, jqXHR) {
2297          ub = that._getUploadedBytes(jqXHR) || ub + o.chunkSize;
2298          // Create a progress event if no final progress event
2299          // with loaded equaling total has been triggered
2300          // for this chunk:
2301          if (currentLoaded + o.chunkSize - o._progress.loaded) {
2302            that._onProgress($.Event('progress', {
2303              lengthComputable: true,
2304              loaded: ub - o.uploadedBytes,
2305              total: ub - o.uploadedBytes
2306            }), o);
2307          }
2308          options.uploadedBytes = o.uploadedBytes = ub;
2309          o.result = result;
2310          o.textStatus = textStatus;
2311          o.jqXHR = jqXHR;
2312          that._trigger('chunkdone', null, o);
2313          that._trigger('chunkalways', null, o);
2314          if (ub < fs) {
2315            // File upload not yet complete,
2316            // continue with the next chunk:
2317            _upload();
2318          } else {
2319            dfd.resolveWith(o.context, [result, textStatus, jqXHR]);
2320          }
2321        }).fail(function (jqXHR, textStatus, errorThrown) {
2322          o.jqXHR = jqXHR;
2323          o.textStatus = textStatus;
2324          o.errorThrown = errorThrown;
2325          that._trigger('chunkfail', null, o);
2326          that._trigger('chunkalways', null, o);
2327          dfd.rejectWith(o.context, [jqXHR, textStatus, errorThrown]);
2328        }).always(function () {
2329          that._deinitProgressListener(o);
2330        });
2331      };
2332      this._enhancePromise(promise);
2333      promise.abort = function () {
2334        return jqXHR.abort();
2335      };
2336      _upload();
2337      return promise;
2338    },
2339    _beforeSend: function _beforeSend(e, data) {
2340      if (this._active === 0) {
2341        // the start callback is triggered when an upload starts
2342        // and no other uploads are currently running,
2343        // equivalent to the global ajaxStart event:
2344        this._trigger('start');
2345        // Set timer for global bitrate progress calculation:
2346        this._bitrateTimer = new this._BitrateTimer();
2347        // Reset the global progress values:
2348        this._progress.loaded = this._progress.total = 0;
2349        this._progress.bitrate = 0;
2350      }
2351      // Make sure the container objects for the .response() and
2352      // .progress() methods on the data object are available
2353      // and reset to their initial state:
2354      this._initResponseObject(data);
2355      this._initProgressObject(data);
2356      data._progress.loaded = data.loaded = data.uploadedBytes || 0;
2357      data._progress.total = data.total = this._getTotal(data.files) || 1;
2358      data._progress.bitrate = data.bitrate = 0;
2359      this._active += 1;
2360      // Initialize the global progress values:
2361      this._progress.loaded += data.loaded;
2362      this._progress.total += data.total;
2363    },
2364    _onDone: function _onDone(result, textStatus, jqXHR, options) {
2365      var total = options._progress.total,
2366        response = options._response;
2367      if (options._progress.loaded < total) {
2368        // Create a progress event if no final progress event
2369        // with loaded equaling total has been triggered:
2370        this._onProgress($.Event('progress', {
2371          lengthComputable: true,
2372          loaded: total,
2373          total: total
2374        }), options);
2375      }
2376      response.result = options.result = result;
2377      response.textStatus = options.textStatus = textStatus;
2378      response.jqXHR = options.jqXHR = jqXHR;
2379      this._trigger('done', null, options);
2380    },
2381    _onFail: function _onFail(jqXHR, textStatus, errorThrown, options) {
2382      var response = options._response;
2383      if (options.recalculateProgress) {
2384        // Remove the failed (error or abort) file upload from
2385        // the global progress calculation:
2386        this._progress.loaded -= options._progress.loaded;
2387        this._progress.total -= options._progress.total;
2388      }
2389      response.jqXHR = options.jqXHR = jqXHR;
2390      response.textStatus = options.textStatus = textStatus;
2391      response.errorThrown = options.errorThrown = errorThrown;
2392      this._trigger('fail', null, options);
2393    },
2394    _onAlways: function _onAlways(jqXHRorResult, textStatus, jqXHR

2394orError, options) {
2395      // jqXHRorResult, textStatus and jqXHRorError are added to the
2396      // options object via done and fail callbacks
2397      this._trigger('always', null, options);
2398    },
2399    _onSend: function _onSend(e, data) {
2400      if (!data.submit) {
2401        this._addConvenienceMethods(e, data);
2402      }
2403      var that = this,
2404        jqXHR,
2405        aborted,
2406        slot,
2407        pipe,
2408        options = that._getAJAXSettings(data),
2409        send = function send() {
2410          that._sending += 1;
2411          // Set timer for bitrate progress calculation:
2412          options._bitrateTimer = new that._BitrateTimer();
2413          jqXHR = jqXHR || ((aborted || that._trigger('send', $.Event('send', {
2414            delegatedEvent: e
2415          }), options) === false) && that._getXHRPromise(false, options.context, aborted) || that._chunkedUpload(options) || $.ajax(options)).done(function (result, textStatus, jqXHR) {
2416            that._onDone(result, textStatus, jqXHR, options);
2417          }).fail(function (jqXHR, textStatus, errorThrown) {
2418            that._onFail(jqXHR, textStatus, errorThrown, options);
2419          }).always(function (jqXHRorResult, textStatus, jqXHRorError) {
2420            that._deinitProgressListener(options);
2421            that._onAlways(jqXHRorResult, textStatus, jqXHRorError, options);
2422            that._sending -= 1;
2423            that._active -= 1;
2424            if (options.limitConcurrentUploads && options.limitConcurrentUploads > that._sending) {
2425              // Start the next queued upload,
2426              // that has not been aborted:
2427              var nextSlot = that._slots.shift();
2428              while (nextSlot) {
2429                if (that._getDeferredState(nextSlot) === 'pending') {
2430                  nextSlot.resolve();
2431                  break;
2432                }
2433                nextSlot = that._slots.shift();
2434              }
2435            }
2436            if (that._active === 0) {
2437              // The stop callback is triggered when all uploads have
2438              // been completed, equivalent to the global ajaxStop event:
2439              that._trigger('stop');
2440            }
2441          });
2442          return jqXHR;
2443        };
2444      this._beforeSend(e, options);
2445      if (this.options.sequentialUploads || this.options.limitConcurrentUploads && this.options.limitConcurrentUploads <= this._sending) {
2446        if (this.options.limitConcurrentUploads > 1) {
2447          slot = $.Deferred();
2448          this._slots.push(slot);
2449          pipe = slot[that._promisePipe](send);
2450        } else {
2451          this._sequence = this._sequence[that._promisePipe](send, send);
2452          pipe = this._sequence;
2453        }
2454        // Return the piped Promise object, enhanced with an abort method,
2455        // which is delegated to the jqXHR object of the current upload,
2456        // and jqXHR callbacks mapped to the equivalent Promise methods:
2457        pipe.abort = function () {
2458          aborted = [undefined, 'abort', 'abort'];
2459          if (!jqXHR) {
2460            if (slot) {
2461              slot.rejectWith(options.context, aborted);
2462            }
2463            return send();
2464          }
2465          return jqXHR.abort();
2466        };
2467        return this._enhancePromise(pipe);
2468      }
2469      return send();
2470    },
2471    _onAdd: function _onAdd(e, data) {
2472      var that = this,
2473        result = true,
2474        options = $.extend({}, this.options, data),
2475        files = data.files,
2476        filesLength = files.length,
2477        limit = options.limitMultiFileUploads,
2478        limitSize = options.limitMultiFileUploadSize,
2479        overhead = options.limitMultiFileUploadSizeOverhead,
2480        batchSize = 0,
2481        paramName = this._getParamName(options),
2482        paramNameSet,
2483        paramNameSlice,
2484        fileSet,
2485        i,
2486        j = 0;
2487      if (!filesLength) {
2488        return false;
2489      }
2490      if (limitSize && files[0].size === undefined) {
2491        limitSize = undefined;
2492      }
2493      if (!(options.singleFileUploads || limit || limitSize) || !this._isXHRUpload(options)) {
2494        fileSet = [files];
2495        paramNameSet = [paramName];
2496      } else if (!(options.singleFileUploads || limitSize) && limit) {
2497        fileSet = [];
2498        paramNameSet = [];
2499        for (i = 0; i < filesLength; i += limit) {
2500          fileSet.push(files.slice(i, i + limit));
2501          paramNameSlice = paramName.slice(i, i + limit);
2502          if (!paramNameSlice.length) {
2503            paramNameSlice = paramName;
2504          }
2505          paramNameSet.push(paramNameSlice);
2506        }
2507      } else if (!options.singleFileUploads && limitSize) {
2508        fileSet = [];
2509        paramNameSet = [];
2510        for (i = 0; i < filesLength; i = i + 1) {

2511          batchSize += files[i].size + overhead;
2512          if (i + 1 === filesLength || batchSize + files[i + 1].size + overhead > limitSize || limit && i + 1 - j >= limit) {
2513            fileSet.push(files.slice(j, i + 1));
2514            paramNameSlice = paramName.slice(j, i + 1);
2515            if (!paramNameSlice.length) {
2516              paramNameSlice = paramName;
2517            }
2518            paramNameSet.push(paramNameSlice);
2519            j = i + 1;
2520            batchSize = 0;
2521          }
2522        }
2523      } else {
2524        paramNameSet = paramName;
2525      }
2526      data.originalFiles = files;
2527      $.each(fileSet || files, function (index, element) {
2528        var newData = $.extend({}, data);
2529        newData.files = fileSet ? element : [element];
2530        newData.paramName = paramNameSet[index];
2531        that._initResponseObject(newData);
2532        that._initProgressObject(newData);
2533        that._addConvenienceMethods(e, newData);
2534        result = that._trigger('add', $.Event('add', {
2535          delegatedEvent: e
2536        }), newData);
2537        return result;
2538      });
2539      return result;
2540    },
2541    _replaceFileInput: function _replaceFileInput(data) {
2542      var input = data.fileInput,
2543        inputClone = input.clone(true),
2544        restoreFocus = input.is(document.activeElement);
2545      // Add a reference for the new cloned file input to the data argument:
2546      data.fileInputClone = inputClone;
2547      $('<form></form>').append(inputClone)[0].reset();
2548      // Detaching allows to insert the fileInput on another form
2549      // without losing the file input value:
2550      input.after(inputClone).detach();
2551      // If the fileInput had focus before it was detached,
2552      // restore focus to the inputClone.
2553      if (restoreFocus) {
2554        inputClone.trigger('focus');
2555      }
2556      // Avoid memory leaks with the detached file input:
2557      $.cleanData(input.off('remove'));
2558      // Replace the original file input element in the fileInput
2559      // elements set with the clone, which has been copied including
2560      // event handlers:
2561      this.options.fileInput = this.options.fileInput.map(function (i, el) {
2562        if (el === input[0]) {
2563          return inputClone[0];
2564        }
2565        return el;
2566      });
2567      // If the widget has been initialized on the file input itself,
2568      // override this.element with the file input clone:
2569      if (input[0] === this.element[0]) {
2570        this.element = inputClone;
2571      }
2572    },
2573    _handleFileTreeEntry: function _handleFileTreeEntry(entry, path) {
2574      var that = this,
2575        dfd = $.Deferred(),
2576        entries = [],
2577        dirReader,
2578        errorHandler = function errorHandler(e) {
2579          if (e && !e.entry) {
2580            e.entry = entry;
2581          }
2582          // Since $.when returns immediately if one
2583          // Deferred is rejected, we use resolve instead.
2584          // This allows valid files and invalid items
2585          // to be returned together in one set:
2586          dfd.resolve([e]);
2587        },
2588        successHandler = function successHandler(entries) {
2589          that._handleFileTreeEntries(entries, path + entry.name + '/').done(function (files) {
2590            dfd.resolve(files);
2591          }).fail(errorHandler);
2592        },
2593        _readEntries = function readEntries() {
2594          dirReader.readEntries(function (results) {
2595            if (!results.length) {
2596              successHandler(entries);
2597            } else {
2598              entries = entries.concat(results);
2599              _readEntries();
2600            }
2601          }, errorHandler);
2602        };
2603      // eslint-disable-next-line no-param-reassign
2604      path = path || '';
2605      if (entry.isFile) {
2606        if (entry._file) {
2607          // Workaround for Chrome bug #149735
2608          entry._file.relativePath = path;
2609          dfd.resolve(entry._file);
2610        } else {
2611          entry.file(function (file) {
2612            file.relativePath = path;
2613            dfd.resolve(file);
2614          }, errorHandler);
2615        }
2616      } else if (entry.isDirectory) {
2617        dirReader = entry.createReader();
2618        _readEntries();
2619      } else {
2620        // Return an empty list for file system items
2621        // other than files or directories:
2622        dfd.resolve([]);
2623      }
2624      return dfd.promise();
2625    },
2626    _handleFileTreeEntries: function _handleFileTreeEntries(entries, path) {
2627      var that = this;
2628      return $.when.apply($, $.map(entries, function (entry) {
2629        return that._handleFileTreeEntry(entry, path);
2630      }))[this._promisePipe](function () {
2631        return Array.prototype.concat.apply([], arguments);
2632      });
2633    },
2634    _getDroppedFiles: function _getDroppedFiles(dataTransfer) {
2635      // eslint-disable-next-line no-param-reassign
2636      dataTransfer = dataTransfer || {};
2637      var items = dataTransfer.items;
2638      if (items && items.length && (items[0].webkitGetAsEntry || items[0].getAsEntry)) {
2639        return this._handleFileTreeEntries($.map(items, function (item) {
2640          var entry;
2641          if (item.webkitGetAsEntry) {
2642            entry = item.webkitGetAsEntry();
2643            if (entry) {
2644              // Workaround for Chrome bug #149735:
2645              entry._file = item.getAsFile();
2646            }
2647            return entry;
2648          }
2649          return item.getAsEntry();
2650        }));
2651      }
2652      return $.Deferred().resolve($.makeArray(dataTransfer.files)).promise();
2653    },
2654    _getSingleFileInputFiles: function _getSingleFileInputFiles(fileInput) {
2655      // eslint-disable-next-line no-param-reassign
2656      fileInput = $(fileInput);
2657      var entries = fileInput.prop('entries'),
2658        files,
2659        value;