gis-leaflet-helper 3.2.21 → 3.2.23

package/dist/gis-leaflet-helper.es.js

@@ -19350,7 +19350,7 @@ function parse(code) {
     return code;
   }
 }
-function extend$1(destination, source) {
+function extend(destination, source) {
   destination = destination || {};
   var value, property;
   if (!source) {
@@ -21325,8 +21325,8 @@ function Projection(srsCode, callback) {
     ecc.ep2,
     nadgrids
   );
-  extend$1(this, json);
-  extend$1(this, ourProj);
+  extend(this, json);
+  extend(this, ourProj);
   this.a = sphere_.a;
   this.b = sphere_.b;
   this.rf = sphere_.rf;
@@ -26560,582 +26560,6 @@ const CanvasMarker = leafletSrcExports.Layer.extend({
     }
   }
 });
-function quickselect(arr, k, left, right, compare) {
-  quickselectStep(arr, k, left || 0, right || arr.length - 1, compare || defaultCompare);
-}
-function quickselectStep(arr, k, left, right, compare) {
-  while (right > left) {
-    if (right - left > 600) {
-      var n = right - left + 1;
-      var m = k - left + 1;
-      var z = Math.log(n);
-      var s = 0.5 * Math.exp(2 * z / 3);
-      var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
-      var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
-      var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
-      quickselectStep(arr, k, newLeft, newRight, compare);
-    }
-    var t = arr[k];
-    var i = left;
-    var j = right;
-    swap(arr, left, k);
-    if (compare(arr[right], t) > 0) swap(arr, left, right);
-    while (i < j) {
-      swap(arr, i, j);
-      i++;
-      j--;
-      while (compare(arr[i], t) < 0) i++;
-      while (compare(arr[j], t) > 0) j--;
-    }
-    if (compare(arr[left], t) === 0) swap(arr, left, j);
-    else {
-      j++;
-      swap(arr, j, right);
-    }
-    if (j <= k) left = j + 1;
-    if (k <= j) right = j - 1;
-  }
-}
-function swap(arr, i, j) {
-  var tmp = arr[i];
-  arr[i] = arr[j];
-  arr[j] = tmp;
-}
-function defaultCompare(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-class RBush {
-  constructor(maxEntries = 9) {
-    this._maxEntries = Math.max(4, maxEntries);
-    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
-    this.clear();
-  }
-  all() {
-    return this._all(this.data, []);
-  }
-  search(bbox) {
-    let node = this.data;
-    const result = [];
-    if (!intersects(bbox, node)) return result;
-    const toBBox = this.toBBox;
-    const nodesToSearch = [];
-    while (node) {
-      for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-        const childBBox = node.leaf ? toBBox(child) : child;
-        if (intersects(bbox, childBBox)) {
-          if (node.leaf) result.push(child);
-          else if (contains(bbox, childBBox)) this._all(child, result);
-          else nodesToSearch.push(child);
-        }
-      }
-      node = nodesToSearch.pop();
-    }
-    return result;
-  }
-  collides(bbox) {
-    let node = this.data;
-    if (!intersects(bbox, node)) return false;
-    const nodesToSearch = [];
-    while (node) {
-      for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-        const childBBox = node.leaf ? this.toBBox(child) : child;
-        if (intersects(bbox, childBBox)) {
-          if (node.leaf || contains(bbox, childBBox)) return true;
-          nodesToSearch.push(child);
-        }
-      }
-      node = nodesToSearch.pop();
-    }
-    return false;
-  }
-  load(data) {
-    if (!(data && data.length)) return this;
-    if (data.length < this._minEntries) {
-      for (let i = 0; i < data.length; i++) {
-        this.insert(data[i]);
-      }
-      return this;
-    }
-    let node = this._build(data.slice(), 0, data.length - 1, 0);
-    if (!this.data.children.length) {
-      this.data = node;
-    } else if (this.data.height === node.height) {
-      this._splitRoot(this.data, node);
-    } else {
-      if (this.data.height < node.height) {
-        const tmpNode = this.data;
-        this.data = node;
-        node = tmpNode;
-      }
-      this._insert(node, this.data.height - node.height - 1, true);
-    }
-    return this;
-  }
-  insert(item) {
-    if (item) this._insert(item, this.data.height - 1);
-    return this;
-  }
-  clear() {
-    this.data = createNode([]);
-    return this;
-  }
-  remove(item, equalsFn) {
-    if (!item) return this;
-    let node = this.data;
-    const bbox = this.toBBox(item);
-    const path = [];
-    const indexes = [];
-    let i, parent, goingUp;
-    while (node || path.length) {
-      if (!node) {
-        node = path.pop();
-        parent = path[path.length - 1];
-        i = indexes.pop();
-        goingUp = true;
-      }
-      if (node.leaf) {
-        const index = findItem(item, node.children, equalsFn);
-        if (index !== -1) {
-          node.children.splice(index, 1);
-          path.push(node);
-          this._condense(path);
-          return this;
-        }
-      }
-      if (!goingUp && !node.leaf && contains(node, bbox)) {
-        path.push(node);
-        indexes.push(i);
-        i = 0;
-        parent = node;
-        node = node.children[0];
-      } else if (parent) {
-        i++;
-        node = parent.children[i];
-        goingUp = false;
-      } else node = null;
-    }
-    return this;
-  }
-  toBBox(item) {
-    return item;
-  }
-  compareMinX(a, b) {
-    return a.minX - b.minX;
-  }
-  compareMinY(a, b) {
-    return a.minY - b.minY;
-  }
-  toJSON() {
-    return this.data;
-  }
-  fromJSON(data) {
-    this.data = data;
-    return this;
-  }
-  _all(node, result) {
-    const nodesToSearch = [];
-    while (node) {
-      if (node.leaf) result.push(...node.children);
-      else nodesToSearch.push(...node.children);
-      node = nodesToSearch.pop();
-    }
-    return result;
-  }
-  _build(items, left, right, height) {
-    const N = right - left + 1;
-    let M2 = this._maxEntries;
-    let node;
-    if (N <= M2) {
-      node = createNode(items.slice(left, right + 1));
-      calcBBox(node, this.toBBox);
-      return node;
-    }
-    if (!height) {
-      height = Math.ceil(Math.log(N) / Math.log(M2));
-      M2 = Math.ceil(N / Math.pow(M2, height - 1));
-    }
-    node = createNode([]);
-    node.leaf = false;
-    node.height = height;
-    const N2 = Math.ceil(N / M2);
-    const N1 = N2 * Math.ceil(Math.sqrt(M2));
-    multiSelect(items, left, right, N1, this.compareMinX);
-    for (let i = left; i <= right; i += N1) {
-      const right2 = Math.min(i + N1 - 1, right);
-      multiSelect(items, i, right2, N2, this.compareMinY);
-      for (let j = i; j <= right2; j += N2) {
-        const right3 = Math.min(j + N2 - 1, right2);
-        node.children.push(this._build(items, j, right3, height - 1));
-      }
-    }
-    calcBBox(node, this.toBBox);
-    return node;
-  }
-  _chooseSubtree(bbox, node, level, path) {
-    while (true) {
-      path.push(node);
-      if (node.leaf || path.length - 1 === level) break;
-      let minArea = Infinity;
-      let minEnlargement = Infinity;
-      let targetNode;
-      for (let i = 0; i < node.children.length; i++) {
-        const child = node.children[i];
-        const area = bboxArea(child);
-        const enlargement = enlargedArea(bbox, child) - area;
-        if (enlargement < minEnlargement) {
-          minEnlargement = enlargement;
-          minArea = area < minArea ? area : minArea;
-          targetNode = child;
-        } else if (enlargement === minEnlargement) {
-          if (area < minArea) {
-            minArea = area;
-            targetNode = child;
-          }
-        }
-      }
-      node = targetNode || node.children[0];
-    }
-    return node;
-  }
-  _insert(item, level, isNode) {
-    const bbox = isNode ? item : this.toBBox(item);
-    const insertPath = [];
-    const node = this._chooseSubtree(bbox, this.data, level, insertPath);
-    node.children.push(item);
-    extend(node, bbox);
-    while (level >= 0) {
-      if (insertPath[level].children.length > this._maxEntries) {
-        this._split(insertPath, level);
-        level--;
-      } else break;
-    }
-    this._adjustParentBBoxes(bbox, insertPath, level);
-  }
-  // split overflowed node into two
-  _split(insertPath, level) {
-    const node = insertPath[level];
-    const M2 = node.children.length;
-    const m = this._minEntries;
-    this._chooseSplitAxis(node, m, M2);
-    const splitIndex = this._chooseSplitIndex(node, m, M2);
-    const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
-    newNode.height = node.height;
-    newNode.leaf = node.leaf;
-    calcBBox(node, this.toBBox);
-    calcBBox(newNode, this.toBBox);
-    if (level) insertPath[level - 1].children.push(newNode);
-    else this._splitRoot(node, newNode);
-  }
-  _splitRoot(node, newNode) {
-    this.data = createNode([node, newNode]);
-    this.data.height = node.height + 1;
-    this.data.leaf = false;
-    calcBBox(this.data, this.toBBox);
-  }
-  _chooseSplitIndex(node, m, M2) {
-    let index;
-    let minOverlap = Infinity;
-    let minArea = Infinity;
-    for (let i = m; i <= M2 - m; i++) {
-      const bbox1 = distBBox(node, 0, i, this.toBBox);
-      const bbox2 = distBBox(node, i, M2, this.toBBox);
-      const overlap = intersectionArea(bbox1, bbox2);
-      const area = bboxArea(bbox1) + bboxArea(bbox2);
-      if (overlap < minOverlap) {
-        minOverlap = overlap;
-        index = i;
-        minArea = area < minArea ? area : minArea;
-      } else if (overlap === minOverlap) {
-        if (area < minArea) {
-          minArea = area;
-          index = i;
-        }
-      }
-    }
-    return index || M2 - m;
-  }
-  // sorts node children by the best axis for split
-  _chooseSplitAxis(node, m, M2) {
-    const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
-    const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
-    const xMargin = this._allDistMargin(node, m, M2, compareMinX);
-    const yMargin = this._allDistMargin(node, m, M2, compareMinY);
-    if (xMargin < yMargin) node.children.sort(compareMinX);
-  }
-  // total margin of all possible split distributions where each node is at least m full
-  _allDistMargin(node, m, M2, compare) {
-    node.children.sort(compare);
-    const toBBox = this.toBBox;
-    const leftBBox = distBBox(node, 0, m, toBBox);
-    const rightBBox = distBBox(node, M2 - m, M2, toBBox);
-    let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
-    for (let i = m; i < M2 - m; i++) {
-      const child = node.children[i];
-      extend(leftBBox, node.leaf ? toBBox(child) : child);
-      margin += bboxMargin(leftBBox);
-    }
-    for (let i = M2 - m - 1; i >= m; i--) {
-      const child = node.children[i];
-      extend(rightBBox, node.leaf ? toBBox(child) : child);
-      margin += bboxMargin(rightBBox);
-    }
-    return margin;
-  }
-  _adjustParentBBoxes(bbox, path, level) {
-    for (let i = level; i >= 0; i--) {
-      extend(path[i], bbox);
-    }
-  }
-  _condense(path) {
-    for (let i = path.length - 1, siblings; i >= 0; i--) {
-      if (path[i].children.length === 0) {
-        if (i > 0) {
-          siblings = path[i - 1].children;
-          siblings.splice(siblings.indexOf(path[i]), 1);
-        } else this.clear();
-      } else calcBBox(path[i], this.toBBox);
-    }
-  }
-}
-function findItem(item, items, equalsFn) {
-  if (!equalsFn) return items.indexOf(item);
-  for (let i = 0; i < items.length; i++) {
-    if (equalsFn(item, items[i])) return i;
-  }
-  return -1;
-}
-function calcBBox(node, toBBox) {
-  distBBox(node, 0, node.children.length, toBBox, node);
-}
-function distBBox(node, k, p, toBBox, destNode) {
-  if (!destNode) destNode = createNode(null);
-  destNode.minX = Infinity;
-  destNode.minY = Infinity;
-  destNode.maxX = -Infinity;
-  destNode.maxY = -Infinity;
-  for (let i = k; i < p; i++) {
-    const child = node.children[i];
-    extend(destNode, node.leaf ? toBBox(child) : child);
-  }
-  return destNode;
-}
-function extend(a, b) {
-  a.minX = Math.min(a.minX, b.minX);
-  a.minY = Math.min(a.minY, b.minY);
-  a.maxX = Math.max(a.maxX, b.maxX);
-  a.maxY = Math.max(a.maxY, b.maxY);
-  return a;
-}
-function compareNodeMinX(a, b) {
-  return a.minX - b.minX;
-}
-function compareNodeMinY(a, b) {
-  return a.minY - b.minY;
-}
-function bboxArea(a) {
-  return (a.maxX - a.minX) * (a.maxY - a.minY);
-}
-function bboxMargin(a) {
-  return a.maxX - a.minX + (a.maxY - a.minY);
-}
-function enlargedArea(a, b) {
-  return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) * (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
-}
-function intersectionArea(a, b) {
-  const minX = Math.max(a.minX, b.minX);
-  const minY = Math.max(a.minY, b.minY);
-  const maxX = Math.min(a.maxX, b.maxX);
-  const maxY = Math.min(a.maxY, b.maxY);
-  return Math.max(0, maxX - minX) * Math.max(0, maxY - minY);
-}
-function contains(a, b) {
-  return a.minX <= b.minX && a.minY <= b.minY && b.maxX <= a.maxX && b.maxY <= a.maxY;
-}
-function intersects(a, b) {
-  return b.minX <= a.maxX && b.minY <= a.maxY && b.maxX >= a.minX && b.maxY >= a.minY;
-}
-function createNode(children) {
-  return {
-    children,
-    height: 1,
-    leaf: true,
-    minX: Infinity,
-    minY: Infinity,
-    maxX: -Infinity,
-    maxY: -Infinity
-  };
-}
-function multiSelect(arr, left, right, n, compare) {
-  const stack = [left, right];
-  while (stack.length) {
-    right = stack.pop();
-    left = stack.pop();
-    if (right - left <= n) continue;
-    const mid = left + Math.ceil((right - left) / n / 2) * n;
-    quickselect(arr, mid, left, right, compare);
-    stack.push(left, mid, mid, right);
-  }
-}
-var isMSIE8 = !("getComputedStyle" in window && typeof window.getComputedStyle === "function");
-function extensions(parentClass) {
-  return {
-    initialize: function(options) {
-      parentClass.prototype.initialize.call(this, options);
-      this._originalLayers = [];
-      this._visibleLayers = [];
-      this._staticLayers = [];
-      this._rbush = [];
-      this._cachedRelativeBoxes = [];
-      this._margin = options.margin || 0;
-      this._rbush = null;
-    },
-    addLayer: function(layer) {
-      if (!("options" in layer) || !("icon" in layer.options)) {
-        this._staticLayers.push(layer);
-        parentClass.prototype.addLayer.call(this, layer);
-        return;
-      }
-      this._originalLayers.push(layer);
-      if (this._map) {
-        this._maybeAddLayerToRBush(layer);
-      }
-    },
-    removeLayer: function(layer) {
-      this._rbush.remove(this._cachedRelativeBoxes[layer._leaflet_id]);
-      delete this._cachedRelativeBoxes[layer._leaflet_id];
-      parentClass.prototype.removeLayer.call(this, layer);
-      var i;
-      i = this._originalLayers.indexOf(layer);
-      if (i !== -1) {
-        this._originalLayers.splice(i, 1);
-      }
-      i = this._visibleLayers.indexOf(layer);
-      if (i !== -1) {
-        this._visibleLayers.splice(i, 1);
-      }
-      i = this._staticLayers.indexOf(layer);
-      if (i !== -1) {
-        this._staticLayers.splice(i, 1);
-      }
-    },
-    clearLayers: function() {
-      this._rbush = RBush();
-      this._originalLayers = [];
-      this._visibleLayers = [];
-      this._staticLayers = [];
-      this._cachedRelativeBoxes = [];
-      parentClass.prototype.clearLayers.call(this);
-    },
-    onAdd: function(map) {
-      this._map = map;
-      for (let i = 0, l = this._staticLayers.length; i < l; i++) {
-        map.addLayer(this._staticLayers[i]);
-      }
-      this._onZoomEnd();
-      map.on("zoomend", this._onZoomEnd, this);
-    },
-    onRemove: function(map) {
-      for (let i = 0, l = this._staticLayers.length; i < l; i++) {
-        map.removeLayer(this._staticLayers[i]);
-      }
-      map.off("zoomend", this._onZoomEnd, this);
-      parentClass.prototype.onRemove.call(this, map);
-    },
-    _maybeAddLayerToRBush: function(layer) {
-      this._map.getZoom();
-      var bush = this._rbush;
-      var boxes = this._cachedRelativeBoxes[layer._leaflet_id];
-      var visible = false;
-      if (!boxes) {
-        parentClass.prototype.addLayer.call(this, layer);
-        var visible = true;
-        var box = this._getIconBox(layer._icon);
-        boxes = this._getRelativeBoxes(layer._icon.children, box);
-        boxes.push(box);
-        this._cachedRelativeBoxes[layer._leaflet_id] = boxes;
-      }
-      boxes = this._positionBoxes(this._map.latLngToLayerPoint(layer.getLatLng()), boxes);
-      var collision = false;
-      for (var i = 0; i < boxes.length && !collision; i++) {
-        collision = bush.search(boxes[i]).length > 0;
-      }
-      if (!collision) {
-        if (!visible) {
-          parentClass.prototype.addLayer.call(this, layer);
-        }
-        this._visibleLayers.push(layer);
-        bush.load(boxes);
-      } else {
-        parentClass.prototype.removeLayer.call(this, layer);
-      }
-    },
-    // Returns a plain array with the relative dimensions of a L.Icon, based
-    //   on the computed values from iconSize and iconAnchor.
-    _getIconBox: function(el) {
-      if (isMSIE8) {
-        return [0, 0, el.offsetWidth, el.offsetHeight];
-      }
-      var styles = window.getComputedStyle(el);
-      return [
-        parseInt(styles.marginLeft),
-        parseInt(styles.marginTop),
-        parseInt(styles.marginLeft) + parseInt(styles.width),
-        parseInt(styles.marginTop) + parseInt(styles.height)
-      ];
-    },
-    // Much like _getIconBox, but works for positioned HTML elements, based on offsetWidth/offsetHeight.
-    _getRelativeBoxes: function(els, baseBox) {
-      var boxes = [];
-      for (var i = 0; i < els.length; i++) {
-        var el = els[i];
-        var box = [el.offsetLeft, el.offsetTop, el.offsetLeft + el.offsetWidth, el.offsetTop + el.offsetHeight];
-        box = this._offsetBoxes(box, baseBox);
-        boxes.push(box);
-        if (el.children.length) {
-          var parentBox = baseBox;
-          if (!isMSIE8) {
-            var positionStyle = window.getComputedStyle(el).position;
-            if (positionStyle === "absolute" || positionStyle === "relative") {
-              parentBox = box;
-            }
-          }
-          boxes = boxes.concat(this._getRelativeBoxes(el.children, parentBox));
-        }
-      }
-      return boxes;
-    },
-    _offsetBoxes: function(a, b) {
-      return [a[0] + b[0], a[1] + b[1], a[2] + b[0], a[3] + b[1]];
-    },
-    // Adds the coordinate of the layer (in pixels / map canvas units) to each box coordinate.
-    _positionBoxes: function(offset, boxes) {
-      var newBoxes = [];
-      for (var i = 0; i < boxes.length; i++) {
-        newBoxes.push(this._positionBox(offset, boxes[i]));
-      }
-      return newBoxes;
-    },
-    _positionBox: function(offset, box) {
-      return [box[0] + offset.x - this._margin, box[1] + offset.y - this._margin, box[2] + offset.x + this._margin, box[3] + offset.y + this._margin];
-    },
-    _onZoomEnd: function() {
-      for (var i = 0; i < this._visibleLayers.length; i++) {
-        parentClass.prototype.removeLayer.call(this, this._visibleLayers[i]);
-      }
-      this._rbush = RBush();
-      for (var i = 0; i < this._originalLayers.length; i++) {
-        this._maybeAddLayerToRBush(this._originalLayers[i]);
-      }
-    }
-  };
-}
-const Collision = {
-  LayerGroup: leafletSrcExports.LayerGroup.extend(extensions(leafletSrcExports.LayerGroup)),
-  FeatureGroup: leafletSrcExports.FeatureGroup.extend(extensions(leafletSrcExports.FeatureGroup)),
-  GeoJSON: leafletSrcExports.GeoJSON.extend(extensions(leafletSrcExports.GeoJSON))
-};
 const WebMercatorTiledLayer = leafletSrcExports.Layer.extend({
   provide: {
     TDT: "tdt",
@@ -27541,17 +26965,17 @@ var heatmap = { exports: {} };
       plugins: {}
     };
     var Store = function StoreClosure() {
-      var Store2 = function Store3(config2) {
+      var Store2 = function Store3(config) {
         this._coordinator = {};
         this._data = [];
         this._radi = [];
         this._min = 10;
         this._max = 1;
-        this._xField = config2["xField"] || config2.defaultXField;
-        this._yField = config2["yField"] || config2.defaultYField;
-        this._valueField = config2["valueField"] || config2.defaultValueField;
-        if (config2["radius"]) {
-          this._cfgRadius = config2["radius"];
+        this._xField = config["xField"] || config.defaultXField;
+        this._yField = config["yField"] || config.defaultYField;
+        this._valueField = config["valueField"] || config.defaultValueField;
+        if (config["radius"]) {
+          this._cfgRadius = config["radius"];
         }
       };
       var defaultRadius = HeatmapConfig.defaultRadius;
@@ -27735,8 +27159,8 @@ var heatmap = { exports: {} };
       return Store2;
     }();
     var Canvas2dRenderer = function Canvas2dRendererClosure() {
-      var _getColorPalette = function(config2) {
-        var gradientConfig = config2.gradient || config2.defaultGradient;
+      var _getColorPalette = function(config) {
+        var gradientConfig = config.gradient || config.defaultGradient;
         var paletteCanvas = document.createElement("canvas");
         var paletteCtx = paletteCanvas.getContext("2d");
         paletteCanvas.width = 256;
@@ -27799,23 +27223,23 @@ var heatmap = { exports: {} };
           data: renderData
         };
       };
-      function Canvas2dRenderer2(config2) {
-        var container = config2.container;
+      function Canvas2dRenderer2(config) {
+        var container = config.container;
         var shadowCanvas = this.shadowCanvas = document.createElement("canvas");
-        var canvas = this.canvas = config2.canvas || document.createElement("canvas");
+        var canvas = this.canvas = config.canvas || document.createElement("canvas");
         this._renderBoundaries = [1e4, 1e4, 0, 0];
-        var computed = getComputedStyle(config2.container) || {};
+        var computed = getComputedStyle(config.container) || {};
         canvas.className = "heatmap-canvas";
-        this._width = canvas.width = shadowCanvas.width = config2.width || +computed.width.replace(/px/, "");
-        this._height = canvas.height = shadowCanvas.height = config2.height || +computed.height.replace(/px/, "");
+        this._width = canvas.width = shadowCanvas.width = config.width || +computed.width.replace(/px/, "");
+        this._height = canvas.height = shadowCanvas.height = config.height || +computed.height.replace(/px/, "");
         this.shadowCtx = shadowCanvas.getContext("2d");
         this.ctx = canvas.getContext("2d");
         canvas.style.cssText = shadowCanvas.style.cssText = "position:absolute;left:0;top:0;";
         container.style.position = "relative";
         container.appendChild(canvas);
-        this._palette = _getColorPalette(config2);
+        this._palette = _getColorPalette(config);
         this._templates = {};
-        this._setStyles(config2);
+        this._setStyles(config);
       }
       Canvas2dRenderer2.prototype = {
         renderPartial: function(data) {
@@ -27831,14 +27255,14 @@ var heatmap = { exports: {} };
             this._colorize();
           }
         },
-        _updateGradient: function(config2) {
-          this._palette = _getColorPalette(config2);
+        _updateGradient: function(config) {
+          this._palette = _getColorPalette(config);
         },
-        updateConfig: function(config2) {
-          if (config2["gradient"]) {
-            this._updateGradient(config2);
+        updateConfig: function(config) {
+          if (config["gradient"]) {
+            this._updateGradient(config);
           }
-          this._setStyles(config2);
+          this._setStyles(config);
         },
         setDimensions: function(width, height) {
           this._width = width;
@@ -27850,17 +27274,17 @@ var heatmap = { exports: {} };
           this.shadowCtx.clearRect(0, 0, this._width, this._height);
           this.ctx.clearRect(0, 0, this._width, this._height);
         },
-        _setStyles: function(config2) {
-          this._blur = config2.blur == 0 ? 0 : config2.blur || config2.defaultBlur;
-          if (config2.backgroundColor) {
-            this.canvas.style.backgroundColor = config2.backgroundColor;
+        _setStyles: function(config) {
+          this._blur = config.blur == 0 ? 0 : config.blur || config.defaultBlur;
+          if (config.backgroundColor) {
+            this.canvas.style.backgroundColor = config.backgroundColor;
           }
-          this._width = this.canvas.width = this.shadowCanvas.width = config2.width || this._width;
-          this._height = this.canvas.height = this.shadowCanvas.height = config2.height || this._height;
-          this._opacity = (config2.opacity || 0) * 255;
-          this._maxOpacity = (config2.maxOpacity || config2.defaultMaxOpacity) * 255;
-          this._minOpacity = (config2.minOpacity || config2.defaultMinOpacity) * 255;
-          this._useGradientOpacity = !!config2.useGradientOpacity;
+          this._width = this.canvas.width = this.shadowCanvas.width = config.width || this._width;
+          this._height = this.canvas.height = this.shadowCanvas.height = config.height || this._height;
+          this._opacity = (config.opacity || 0) * 255;
+          this._maxOpacity = (config.maxOpacity || config.defaultMaxOpacity) * 255;
+          this._minOpacity = (config.minOpacity || config.defaultMinOpacity) * 255;
+          this._useGradientOpacity = !!config.useGradientOpacity;
         },
         _drawAlpha: function(data) {
           var min = this._min = data.min;
@@ -28036,20 +27460,20 @@ var heatmap = { exports: {} };
         store.setCoordinator(coordinator);
       };
       function Heatmap2() {
-        var config2 = this._config = Util2.merge(HeatmapConfig, arguments[0] || {});
+        var config = this._config = Util2.merge(HeatmapConfig, arguments[0] || {});
         this._coordinator = new Coordinator();
-        if (config2["plugin"]) {
-          var pluginToLoad = config2["plugin"];
+        if (config["plugin"]) {
+          var pluginToLoad = config["plugin"];
           if (!HeatmapConfig.plugins[pluginToLoad]) {
             throw new Error("Plugin '" + pluginToLoad + "' not found. Maybe it was not registered.");
           } else {
             var plugin = HeatmapConfig.plugins[pluginToLoad];
-            this._renderer = new plugin.renderer(config2);
-            this._store = new plugin.store(config2);
+            this._renderer = new plugin.renderer(config);
+            this._store = new plugin.store(config);
           }
         } else {
-          this._renderer = new Renderer(config2);
-          this._store = new Store(config2);
+          this._renderer = new Renderer(config);
+          this._store = new Store(config);
         }
         _connect(this);
       }
@@ -28074,8 +27498,8 @@ var heatmap = { exports: {} };
           this._store.setDataMin.apply(this._store, arguments);
           return this;
         },
-        configure: function(config2) {
-          this._config = Util2.merge(this._config, config2);
+        configure: function(config) {
+          this._config = Util2.merge(this._config, config);
           this._renderer.updateConfig(this._config);
           this._coordinator.emit("renderall", this._store._getInternalData());
           return this;
@@ -28103,8 +27527,8 @@ var heatmap = { exports: {} };
       return Heatmap2;
     }();
     var heatmapFactory = {
-      create: function(config2) {
-        return new Heatmap(config2);
+      create: function(config) {
+        return new Heatmap(config);
       },
       register: function(pluginKey, plugin) {
         HeatmapConfig.plugins[pluginKey] = plugin;
@@ -28116,8 +27540,8 @@ var heatmap = { exports: {} };
 var heatmapExports = heatmap.exports;
 const h337 = /* @__PURE__ */ getDefaultExportFromCjs(heatmapExports);
 var HeatLayer = L.Layer.extend({
-  initialize: function(config2) {
-    this.cfg = config2;
+  initialize: function(config) {
+    this.cfg = config;
     this._el = L.DomUtil.create("div", "leaflet-zoom-hide");
     this._data = [];
     this._max = 1;
@@ -30044,7 +29468,7 @@ function injectCss(cls) {
     getLayers() {
       return Object.values(this._layers);
     },
-    openWidget(name, options = {}, events = {}) {
+    openWidget(name, options = {}, events = {}, config = {}) {
       this.fire("widget-mount", {
         name,
         options,
@@ -30077,7 +29501,6 @@ function injectCss(cls) {
   _L.Text = TextMarker;
   _L.VertexMarkers = VertexMarker;
   _L.Measurement = MeasureMent;
-  _L.Collision = Collision;
   _L.Symbol = Symbol$1;
   _L.PolylineDecorator = PolylineDecorator;
   return _this.L = _L;