leaflet-heatmap-layer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 leaflet-heatmap-layer contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# leaflet-heatmap-layer
+
+A modern heatmap layer plugin for [Leaflet](https://leafletjs.com/).
+
+This Plugin is inspired by [Leaflet.heat](https://github.com/Leaflet/Leaflet.heat), built from scratch under the MIT license. It fixes some long-standing bugs and ships as a proper ES module with TypeScript declarations.
+
+## Installation
+
+```bash
+npm install leaflet-heatmap-layer
+```
+
+Or include via script tag (UMD build):
+
+```html
+<script src="https://unpkg.com/leaflet-heatmap-layer/dist/leaflet-heatmap-layer.umd.js"></script>
+```
+
+## Quick Start
+
+```js
+import L from 'leaflet';
+import 'leaflet-heatmap-layer';
+
+const map = L.map('map').setView([51.505, -0.09], 13);
+L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(map);
+
+const points = [
+  [51.5, -0.09, 0.8],
+  [51.51, -0.1, 0.5],
+  [51.49, -0.08, 1.0],
+  // ...
+];
+
+L.heatLayer(points, { radius: 25 }).addTo(map);
+```
+
+You can also use named exports directly:
+
+```js
+import { HeatLayer, heatLayer } from 'leaflet-heatmap-layer';
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `radius` | `number` | `25` | Radius of each heat point in pixels |
+| `blur` | `number` | `15` | Amount of blur in pixels |
+| `minOpacity` | `number` | `0.05` | Minimum opacity of the heatmap |
+| `maxZoom` | `number` | map's maxZoom | Zoom level where points reach full intensity |
+| `max` | `number` | *auto* | Manual intensity cap. When omitted, computed automatically per redraw |
+| `gradient` | `object` | `{0.4:'blue', 0.6:'cyan', 0.7:'lime', 0.8:'yellow', 1:'red'}` | Color gradient stops |
+| `zoomCrossfadeDuration` | `number` | `250` | Duration in ms to crossfade between zoom levels (0 to disable) |
+
+## Methods
+
+| Method | Returns | Description |
+|---|---|---|
+| `setLatLngs(points)` | `this` | Replace all data points and redraw |
+| `addLatLng(point)` | `this` | Add a single point and redraw |
+| `setOptions(options)` | `this` | Update options and redraw |
+| `getBounds()` | `L.LatLngBounds` | Return bounds covering all points |
+| `redraw()` | `this` | Force a redraw |
+
+## Point Format
+
+Each point can be:
+- `[lat, lng]` — intensity defaults to 1.0
+- `[lat, lng, intensity]` — intensity between 0.0 and 1.0
+- `L.latLng(lat, lng)` — use `.alt` property for intensity
+
+## Migration from Leaflet.heat
+
+The API is intentionally compatible. For most users:
+
+1. Replace `leaflet.heat` with `leaflet-heatmap-layer` in `package.json`
+2. Update your import/script tag
+
+Key differences from Leaflet.heat:
+- Intensity is automatically normalized across **all** data points per redraw, fixing the [intensity scaling bug](https://github.com/Leaflet/Leaflet.heat/issues/78)
+- Full TypeScript support with exported types
+- ES module, CommonJS, and UMD builds
+
+## License
+
+MIT

package/dist/HeatLayer.d.ts

@@ -0,0 +1,55 @@
+import * as L from 'leaflet';
+export interface HeatLayerOptions extends L.LayerOptions {
+    /** Radius of each heat point in pixels (default: 25). */
+    radius?: number;
+    /** Additional blur in pixels (default: 15). */
+    blur?: number;
+    /** Minimum opacity of the heatmap (default: 0.05). */
+    minOpacity?: number;
+    /** Zoom level at which points reach maximum intensity (default: map maxZoom or 18). */
+    maxZoom?: number;
+    /**
+     * Manual maximum intensity cap. When omitted, computed automatically
+     * per redraw from all data points — this is the core fix over Leaflet.heat.
+     */
+    max?: number;
+    /** Color gradient stops (default: blue -> cyan -> lime -> yellow -> red). */
+    gradient?: Record<number, string>;
+    /** Duration in ms to crossfade between old and new heatmap on zoom (default: 250, 0 to disable). */
+    zoomCrossfadeDuration?: number;
+}
+/** Input point: [lat, lng] or [lat, lng, intensity], or L.LatLng (with optional .alt for intensity). */
+export type HeatLatLng = [number, number] | [number, number, number] | L.LatLng;
+export declare class HeatLayer extends L.Layer {
+    private _latlngs;
+    private _options;
+    private _canvas;
+    private _renderer;
+    private _frame;
+    private _snapshotCanvas;
+    private _zooming;
+    private _crossfadeTimer;
+    constructor(latlngs: HeatLatLng[], options?: HeatLayerOptions);
+    onAdd(map: L.Map): this;
+    onRemove(map: L.Map): this;
+    /** Replace all data points and redraw. */
+    setLatLngs(latlngs: HeatLatLng[]): this;
+    /** Add a single data point and redraw. */
+    addLatLng(latlng: HeatLatLng): this;
+    /** Update options and redraw. */
+    setOptions(options: Partial<HeatLayerOptions>): this;
+    /** Return a LatLngBounds covering all data points, or an invalid bounds if empty. */
+    getBounds(): L.LatLngBounds;
+    /** Schedule a redraw on the next animation frame. */
+    redraw(): this;
+    private _createCanvas;
+    private _onMoveEnd;
+    /** Apply CSS transform during zoom animation (same approach as Leaflet's ImageOverlay). */
+    private _onZoomAnim;
+    private _takeSnapshot;
+    private _startCrossfade;
+    private _clearCrossfade;
+    private _redraw;
+    private _getIntensity;
+    private _toLatLng;
+}

package/dist/HeatRenderer.d.ts

@@ -0,0 +1,34 @@
+export interface HeatRendererOptions {
+    /** Radius of each heat point in pixels. */
+    radius: number;
+    /** Additional blur applied to each point in pixels. */
+    blur: number;
+    /** Minimum opacity of the heatmap output (0–1). */
+    minOpacity: number;
+    /** Color gradient stops, keyed by position (0–1). */
+    gradient: Record<number, string>;
+}
+/** A pixel-space data point: [x, y, intensity]. */
+export type HeatPoint = [number, number, number];
+export declare class HeatRenderer {
+    private _canvas;
+    private _ctx;
+    private _circle;
+    private _palette;
+    private _radius;
+    private _blur;
+    private _minOpacity;
+    private _gradient;
+    constructor(canvas: HTMLCanvasElement, options?: Partial<HeatRendererOptions>);
+    setOptions(options: Partial<HeatRendererOptions>): void;
+    get radius(): number;
+    get blur(): number;
+    resize(width: number, height: number): void;
+    clear(): void;
+    /** Draw the heatmap. Intensity values should be pre-normalized to 0–1. */
+    draw(points: HeatPoint[]): void;
+    private _getCircle;
+    private _getPalette;
+    /** Map alpha channel (greyscale intensity) to gradient colors. */
+    private _colorize;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { HeatLayer, type HeatLayerOptions, type HeatLatLng } from './HeatLayer';
+import { HeatRenderer, type HeatRendererOptions, type HeatPoint } from './HeatRenderer';
+declare function heatLayer(latlngs: HeatLatLng[], options?: HeatLayerOptions): HeatLayer;
+declare module 'leaflet' {
+    function heatLayer(latlngs: HeatLatLng[], options?: HeatLayerOptions): HeatLayer;
+}
+export { HeatLayer, HeatRenderer, heatLayer, type HeatLayerOptions, type HeatLatLng, type HeatRendererOptions, type HeatPoint, };

package/dist/leaflet-heatmap-layer.cjs.js

@@ -0,0 +1,422 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HeatLayer: () => HeatLayer,
+  HeatRenderer: () => HeatRenderer,
+  heatLayer: () => heatLayer
+});
+module.exports = __toCommonJS(index_exports);
+var import_leaflet = __toESM(require("leaflet"));
+
+// src/HeatLayer.ts
+var L = __toESM(require("leaflet"));
+
+// src/HeatRenderer.ts
+var DEFAULT_GRADIENT = {
+  0.4: "blue",
+  0.6: "cyan",
+  0.7: "lime",
+  0.8: "yellow",
+  1: "red"
+};
+var HeatRenderer = class {
+  constructor(canvas, options) {
+    this._circle = null;
+    this._palette = null;
+    this._canvas = canvas;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Could not get 2d context from canvas");
+    this._ctx = ctx;
+    this._radius = options?.radius ?? 25;
+    this._blur = options?.blur ?? 15;
+    this._minOpacity = options?.minOpacity ?? 0.05;
+    this._gradient = options?.gradient ?? DEFAULT_GRADIENT;
+  }
+  setOptions(options) {
+    if (options.radius !== void 0 || options.blur !== void 0) {
+      this._radius = options.radius ?? this._radius;
+      this._blur = options.blur ?? this._blur;
+      this._circle = null;
+    }
+    if (options.gradient !== void 0) {
+      this._gradient = options.gradient;
+      this._palette = null;
+    }
+    if (options.minOpacity !== void 0) {
+      this._minOpacity = options.minOpacity;
+    }
+  }
+  get radius() {
+    return this._radius;
+  }
+  get blur() {
+    return this._blur;
+  }
+  resize(width, height) {
+    this._canvas.width = width;
+    this._canvas.height = height;
+  }
+  clear() {
+    this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+  }
+  /** Draw the heatmap. Intensity values should be pre-normalized to 0–1. */
+  draw(points) {
+    if (points.length === 0) {
+      this.clear();
+      return;
+    }
+    const circle = this._getCircle();
+    const fullRadius = this._radius + this._blur;
+    this.clear();
+    for (const [x, y, intensity] of points) {
+      this._ctx.globalAlpha = Math.max(intensity, this._minOpacity);
+      this._ctx.drawImage(circle, x - fullRadius, y - fullRadius);
+    }
+    this._colorize();
+  }
+  _getCircle() {
+    if (this._circle) return this._circle;
+    const r = this._radius;
+    const blur = this._blur;
+    const fullRadius = r + blur;
+    const diameter = fullRadius * 2;
+    const circle = document.createElement("canvas");
+    circle.width = diameter;
+    circle.height = diameter;
+    const ctx = circle.getContext("2d");
+    ctx.shadowOffsetX = diameter;
+    ctx.shadowOffsetY = diameter;
+    ctx.shadowBlur = blur;
+    ctx.shadowColor = "black";
+    ctx.beginPath();
+    ctx.arc(fullRadius - diameter, fullRadius - diameter, r, 0, Math.PI * 2, true);
+    ctx.closePath();
+    ctx.fill();
+    this._circle = circle;
+    return circle;
+  }
+  _getPalette() {
+    if (this._palette) return this._palette;
+    const paletteCanvas = document.createElement("canvas");
+    paletteCanvas.width = 256;
+    paletteCanvas.height = 1;
+    const ctx = paletteCanvas.getContext("2d");
+    const grad = ctx.createLinearGradient(0, 0, 256, 0);
+    for (const [stop, color] of Object.entries(this._gradient)) {
+      grad.addColorStop(Number(stop), color);
+    }
+    ctx.fillStyle = grad;
+    ctx.fillRect(0, 0, 256, 1);
+    this._palette = ctx.getImageData(0, 0, 256, 1).data;
+    return this._palette;
+  }
+  /** Map alpha channel (greyscale intensity) to gradient colors. */
+  _colorize() {
+    const w = this._canvas.width;
+    const h = this._canvas.height;
+    if (w === 0 || h === 0) return;
+    const imageData = this._ctx.getImageData(0, 0, w, h);
+    const pixels = imageData.data;
+    const palette = this._getPalette();
+    for (let i = 0, len = pixels.length; i < len; i += 4) {
+      const alpha = pixels[i + 3];
+      if (alpha === 0) continue;
+      const paletteOffset = alpha * 4;
+      pixels[i] = palette[paletteOffset];
+      pixels[i + 1] = palette[paletteOffset + 1];
+      pixels[i + 2] = palette[paletteOffset + 2];
+    }
+    this._ctx.putImageData(imageData, 0, 0);
+  }
+};
+
+// src/HeatLayer.ts
+var HeatLayer = class extends L.Layer {
+  constructor(latlngs, options) {
+    super(options);
+    this._canvas = null;
+    this._renderer = null;
+    this._frame = null;
+    this._snapshotCanvas = null;
+    this._zooming = false;
+    this._crossfadeTimer = null;
+    this._latlngs = latlngs;
+    this._options = {
+      radius: 25,
+      blur: 15,
+      minOpacity: 0.05,
+      ...options
+    };
+  }
+  onAdd(map) {
+    this._map = map;
+    if (!this._canvas) {
+      this._createCanvas();
+    }
+    const pane = this.getPane();
+    if (pane && this._canvas) {
+      pane.appendChild(this._canvas);
+    }
+    map.on("moveend", this._onMoveEnd, this);
+    map.on("zoomanim", this._onZoomAnim, this);
+    this._onMoveEnd();
+    return this;
+  }
+  onRemove(map) {
+    if (this._frame !== null) {
+      cancelAnimationFrame(this._frame);
+      this._frame = null;
+    }
+    this._clearCrossfade();
+    if (this._snapshotCanvas && this._snapshotCanvas.parentNode) {
+      this._snapshotCanvas.parentNode.removeChild(this._snapshotCanvas);
+    }
+    this._snapshotCanvas = null;
+    const pane = this.getPane();
+    if (pane && this._canvas) {
+      pane.removeChild(this._canvas);
+    }
+    map.off("moveend", this._onMoveEnd, this);
+    map.off("zoomanim", this._onZoomAnim, this);
+    return this;
+  }
+  /** Replace all data points and redraw. */
+  setLatLngs(latlngs) {
+    this._latlngs = latlngs;
+    return this.redraw();
+  }
+  /** Add a single data point and redraw. */
+  addLatLng(latlng) {
+    this._latlngs.push(latlng);
+    return this.redraw();
+  }
+  /** Update options and redraw. */
+  setOptions(options) {
+    Object.assign(this._options, options);
+    if (this._renderer) {
+      this._renderer.setOptions({
+        radius: this._options.radius,
+        blur: this._options.blur,
+        minOpacity: this._options.minOpacity,
+        gradient: this._options.gradient
+      });
+    }
+    return this.redraw();
+  }
+  /** Return a LatLngBounds covering all data points, or an invalid bounds if empty. */
+  getBounds() {
+    if (this._latlngs.length === 0) return L.latLngBounds([]);
+    return L.latLngBounds(this._latlngs.map((p) => this._toLatLng(p)));
+  }
+  /** Schedule a redraw on the next animation frame. */
+  redraw() {
+    if (this._map && this._frame === null) {
+      this._frame = requestAnimationFrame(() => {
+        this._frame = null;
+        this._redraw();
+      });
+    }
+    return this;
+  }
+  _createCanvas() {
+    this._canvas = document.createElement("canvas");
+    this._canvas.style.position = "absolute";
+    this._canvas.style.pointerEvents = "none";
+    this._canvas.style.willChange = "transform";
+    this._canvas.style.transformOrigin = "0 0";
+    const animated = this._map.options.zoomAnimation && L.Browser.any3d;
+    L.DomUtil.addClass(
+      this._canvas,
+      "leaflet-zoom-" + (animated ? "animated" : "hide")
+    );
+    this._renderer = new HeatRenderer(this._canvas, {
+      radius: this._options.radius,
+      blur: this._options.blur,
+      minOpacity: this._options.minOpacity,
+      gradient: this._options.gradient
+    });
+  }
+  _onMoveEnd() {
+    if (!this._map || !this._canvas) return;
+    const wasZooming = this._zooming;
+    this._zooming = false;
+    const duration = this._options.zoomCrossfadeDuration ?? 250;
+    if (wasZooming && duration > 0) {
+      this._takeSnapshot();
+    }
+    const size = this._map.getSize();
+    const topLeft = this._map.containerPointToLayerPoint([0, 0]);
+    L.DomUtil.setPosition(this._canvas, topLeft);
+    this._renderer.resize(size.x, size.y);
+    this._redraw();
+    if (wasZooming && duration > 0) {
+      this._startCrossfade(duration);
+    }
+  }
+  /** Apply CSS transform during zoom animation (same approach as Leaflet's ImageOverlay). */
+  _onZoomAnim(e) {
+    if (!this._map || !this._canvas) return;
+    this._zooming = true;
+    const map = this._map;
+    const scale = map.getZoomScale(e.zoom);
+    const canvasPos = L.DomUtil.getPosition(this._canvas);
+    const topLeftLatLng = map.layerPointToLatLng(canvasPos);
+    const layerTopLeft = map.containerPointToLayerPoint([0, 0]);
+    const newPos = map.project(topLeftLatLng, e.zoom).subtract(map.project(e.center, e.zoom)).add(map.getSize().divideBy(2)).add(layerTopLeft).round();
+    L.DomUtil.setTransform(this._canvas, newPos, scale);
+  }
+  _takeSnapshot() {
+    if (!this._canvas) return;
+    this._clearCrossfade();
+    const canvas = this._canvas;
+    if (!this._snapshotCanvas) {
+      this._snapshotCanvas = document.createElement("canvas");
+      this._snapshotCanvas.style.position = "absolute";
+      this._snapshotCanvas.style.pointerEvents = "none";
+    }
+    const snap = this._snapshotCanvas;
+    snap.width = canvas.width;
+    snap.height = canvas.height;
+    snap.getContext("2d").drawImage(canvas, 0, 0);
+    snap.style.transform = canvas.style.transform;
+    snap.style.transformOrigin = canvas.style.transformOrigin;
+    snap.style.opacity = "1";
+    snap.style.transition = "";
+    if (canvas.parentNode) {
+      canvas.after(snap);
+    }
+  }
+  _startCrossfade(duration) {
+    const snap = this._snapshotCanvas;
+    if (!snap) return;
+    snap.style.transition = `opacity ${duration}ms ease-out`;
+    snap.offsetHeight;
+    snap.style.opacity = "0";
+    this._crossfadeTimer = window.setTimeout(() => {
+      this._crossfadeTimer = null;
+      if (snap) {
+        snap.style.transition = "";
+      }
+    }, duration);
+  }
+  _clearCrossfade() {
+    if (this._crossfadeTimer !== null) {
+      clearTimeout(this._crossfadeTimer);
+      this._crossfadeTimer = null;
+    }
+    if (this._snapshotCanvas) {
+      this._snapshotCanvas.style.transition = "";
+      this._snapshotCanvas.style.opacity = "0";
+    }
+  }
+  _redraw() {
+    if (!this._map || !this._renderer || !this._canvas) return;
+    const map = this._map;
+    const size = map.getSize();
+    if (size.x === 0 || size.y === 0) return;
+    const renderer = this._renderer;
+    const r = renderer.radius + renderer.blur;
+    const cellSize = Math.max(1, Math.floor(renderer.radius / 2));
+    const maxZoom = this._options.maxZoom ?? map.getMaxZoom();
+    const zoom = map.getZoom();
+    const v = 1 / Math.pow(2, Math.max(0, Math.min(maxZoom - zoom, 12)));
+    const bounds = map.getBounds();
+    const padLat = r / size.y * (bounds.getNorth() - bounds.getSouth());
+    const padLng = r / size.x * (bounds.getEast() - bounds.getWest());
+    const paddedBounds = L.latLngBounds(
+      [bounds.getSouth() - padLat, bounds.getWest() - padLng],
+      [bounds.getNorth() + padLat, bounds.getEast() + padLng]
+    );
+    let autoMax = 0;
+    if (this._options.max === void 0) {
+      for (const p of this._latlngs) {
+        const scaled = this._getIntensity(p) * v;
+        if (scaled > autoMax) autoMax = scaled;
+      }
+    }
+    const effectiveMax = this._options.max ?? Math.max(autoMax, 1e-10);
+    const topLeft = map.containerPointToLayerPoint([0, 0]);
+    const grid = {};
+    const pixelPoints = [];
+    for (const p of this._latlngs) {
+      const latlng = this._toLatLng(p);
+      if (!paddedBounds.contains(latlng)) continue;
+      const lp = map.latLngToLayerPoint(latlng);
+      const x = lp.x - topLeft.x;
+      const y = lp.y - topLeft.y;
+      const intensity = this._getIntensity(p) * v;
+      const gx = Math.floor(lp.x / cellSize);
+      const gy = Math.floor(lp.y / cellSize);
+      const key = `${gx}:${gy}`;
+      const cell = grid[key];
+      if (cell) {
+        cell[0] += x * intensity;
+        cell[1] += y * intensity;
+        cell[2] += intensity;
+        cell[3]++;
+      } else {
+        grid[key] = [x * intensity, y * intensity, intensity, 1];
+      }
+    }
+    for (const key in grid) {
+      const cell = grid[key];
+      const totalIntensity = cell[2];
+      if (totalIntensity === 0) continue;
+      pixelPoints.push([
+        cell[0] / totalIntensity,
+        cell[1] / totalIntensity,
+        totalIntensity / effectiveMax
+      ]);
+    }
+    renderer.draw(pixelPoints);
+  }
+  _getIntensity(p) {
+    if (p instanceof L.LatLng) {
+      return p.alt ?? 1;
+    }
+    if (Array.isArray(p) && p.length >= 3) {
+      return p[2];
+    }
+    return 1;
+  }
+  _toLatLng(p) {
+    if (p instanceof L.LatLng) return p;
+    return L.latLng(p[0], p[1]);
+  }
+};
+
+// src/index.ts
+function heatLayer(latlngs, options) {
+  return new HeatLayer(latlngs, options);
+}
+import_leaflet.default.heatLayer = heatLayer;
+//# sourceMappingURL=leaflet-heatmap-layer.cjs.js.map