@hybridcore/ui 1.6.13 → 1.6.16

package/dist/components/heat-map/logic.js

@@ -1,98 +1,1945 @@
-import { useThemeProps as F, useTheme as _ } from "@mui/material";
-import { uniqueId as j, values as C } from "lodash";
-import { WKT as O } from "ol/format";
-import U from "ol/layer/Heatmap";
-import { transformExtent as V } from "ol/proj";
-import A from "ol/source/Vector";
-import { useRef as u, useState as K, useEffect as h } from "react";
-import { DEFAULT_VIRIDIS_COOL as W } from "../charts/_common/utils.js";
-import { createMapboxLayer as J } from "../map/helpers/mapbox.js";
-import { parse as N } from "../map/helpers/wkt.js";
-const ae = (v) => {
-  const d = F({ props: v, name: "HCHeatMap" }), {
-    data: i,
-    payload: s,
-    onPayloadUpdate: E,
-    accessToken: P,
-    gradient: x = W,
-    sx: w,
-    ...R
-  } = d, p = _(), g = u(j("map-")), r = u(null), c = u(null), m = u(null), a = u(null), l = u(), [b, I] = K(!1), L = () => {
-    if (!b || !r.current || !i || !m.current) return;
-    const e = new O(), t = i.map((n) => C(n.variables.geometry)[0]).filter((n) => {
+import { useThemeProps as Ie, useTheme as De } from "@mui/material";
+import { uniqueId as Be, values as Me } from "lodash";
+import { L as Ne, R as Y, a as G, B as ve, V as Oe } from "../../Vector-DfTqQEln.js";
+import { W as C, X as ae, Y as Ge, Z as ze, _ as Ee, $ as Ze, a0 as U, y as He, a1 as We, a2 as Xe, a3 as ue, R as ke, a4 as Ve, a5 as he, a6 as je, a7 as Ye, t as Ke } from "../../Source-BSZST_GH.js";
+import { S as qe, a as me, g as L, D as $e, j as Je, k as Qe, l as z, u as et, m as tt } from "../../math-Bvt2Ubuz.js";
+import { d as rt } from "../../Text-ChJRuaD8.js";
+import { useRef as w, useState as nt, useEffect as ce } from "react";
+import { DEFAULT_VIRIDIS_COOL as it } from "../charts/_common/utils.js";
+import { createMapboxLayer as st } from "../map/helpers/mapbox.js";
+import { parse as ot } from "../map/helpers/wkt.js";
+import { W as at } from "../../WKT-2wsDT-nq.js";
+const te = 34962, re = 34963, ut = 35040, ht = 35044, $ = 35048, ct = 5121, ft = 5123, lt = 5125, Te = 5126, fe = ["experimental-webgl", "webgl", "webkit-3d", "moz-webgl"];
+function dt(n, t) {
+  t = Object.assign(
+    {
+      preserveDrawingBuffer: !0,
+      antialias: !qe
+      // https://bugs.webkit.org/show_bug.cgi?id=237906
+    },
+    t
+  );
+  const e = fe.length;
+  for (let r = 0; r < e; ++r)
+    try {
+      const i = n.getContext(fe[r], t);
+      if (i)
+        return (
+          /** @type {!WebGLRenderingContext} */
+          i
+        );
+    } catch {
+    }
+  return null;
+}
+const xt = {
+  STATIC_DRAW: ht,
+  STREAM_DRAW: ut,
+  DYNAMIC_DRAW: $
+};
+class le {
+  /**
+   * @param {number} type Buffer type, either ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER.
+   * @param {number} [usage] Intended usage, either `STATIC_DRAW`, `STREAM_DRAW` or `DYNAMIC_DRAW`.
+   * Default is `DYNAMIC_DRAW`.
+   */
+  constructor(t, e) {
+    this.array = null, this.type = t, me(t === te || t === re, 62), this.usage = e !== void 0 ? e : xt.STATIC_DRAW;
+  }
+  /**
+   * Populates the buffer with an array of the given size (all values will be zeroes).
+   * @param {number} size Array size
+   * @return {WebGLArrayBuffer} This
+   */
+  ofSize(t) {
+    return this.array = new (K(this.type))(t), this;
+  }
+  /**
+   * Populates the buffer with an array of the given size.
+   * @param {Array<number>} array Numerical array
+   * @return {WebGLArrayBuffer} This
+   */
+  fromArray(t) {
+    return this.array = K(this.type).from(t), this;
+  }
+  /**
+   * Populates the buffer with a raw binary array buffer.
+   * @param {ArrayBuffer} buffer Raw binary buffer to populate the array with. Note that this buffer must have been
+   * initialized for the same typed array class.
+   * @return {WebGLArrayBuffer} This
+   */
+  fromArrayBuffer(t) {
+    return this.array = new (K(this.type))(t), this;
+  }
+  /**
+   * @return {number} Buffer type.
+   */
+  getType() {
+    return this.type;
+  }
+  /**
+   * Will return null if the buffer was not initialized
+   * @return {Float32Array|Uint32Array} Array.
+   */
+  getArray() {
+    return this.array;
+  }
+  /**
+   * @return {number} Usage.
+   */
+  getUsage() {
+    return this.usage;
+  }
+  /**
+   * Will return 0 if the buffer is not initialized
+   * @return {number} Array size
+   */
+  getSize() {
+    return this.array ? this.array.length : 0;
+  }
+}
+function K(n) {
+  switch (n) {
+    case te:
+      return Float32Array;
+    case re:
+      return Uint32Array;
+    default:
+      return Float32Array;
+  }
+}
+const Z = {
+  LOST: "webglcontextlost",
+  RESTORED: "webglcontextrestored"
+}, _t = `
+  precision mediump float;
+  
+  attribute vec2 a_position;
+  varying vec2 v_texCoord;
+  varying vec2 v_screenCoord;
+  
+  uniform vec2 u_screenSize;
+   
+  void main() {
+    v_texCoord = a_position * 0.5 + 0.5;
+    v_screenCoord = v_texCoord * u_screenSize;
+    gl_Position = vec4(a_position, 0.0, 1.0);
+  }
+`, gt = `
+  precision mediump float;
+   
+  uniform sampler2D u_image;
+  uniform float u_opacity;
+   
+  varying vec2 v_texCoord;
+   
+  void main() {
+    gl_FragColor = texture2D(u_image, v_texCoord) * u_opacity;
+  }
+`;
+class de {
+  /**
+   * @param {Options} options Options.
+   */
+  constructor(t) {
+    this.gl_ = t.webGlContext;
+    const e = this.gl_;
+    this.scaleRatio_ = t.scaleRatio || 1, this.renderTargetTexture_ = e.createTexture(), this.renderTargetTextureSize_ = null, this.frameBuffer_ = e.createFramebuffer(), this.depthBuffer_ = e.createRenderbuffer();
+    const r = e.createShader(e.VERTEX_SHADER);
+    e.shaderSource(
+      r,
+      t.vertexShader || _t
+    ), e.compileShader(r);
+    const i = e.createShader(e.FRAGMENT_SHADER);
+    e.shaderSource(
+      i,
+      t.fragmentShader || gt
+    ), e.compileShader(i), this.renderTargetProgram_ = e.createProgram(), e.attachShader(this.renderTargetProgram_, r), e.attachShader(this.renderTargetProgram_, i), e.linkProgram(this.renderTargetProgram_), this.renderTargetVerticesBuffer_ = e.createBuffer();
+    const s = [-1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1];
+    e.bindBuffer(e.ARRAY_BUFFER, this.renderTargetVerticesBuffer_), e.bufferData(
+      e.ARRAY_BUFFER,
+      new Float32Array(s),
+      e.STATIC_DRAW
+    ), this.renderTargetAttribLocation_ = e.getAttribLocation(
+      this.renderTargetProgram_,
+      "a_position"
+    ), this.renderTargetUniformLocation_ = e.getUniformLocation(
+      this.renderTargetProgram_,
+      "u_screenSize"
+    ), this.renderTargetOpacityLocation_ = e.getUniformLocation(
+      this.renderTargetProgram_,
+      "u_opacity"
+    ), this.renderTargetTextureLocation_ = e.getUniformLocation(
+      this.renderTargetProgram_,
+      "u_image"
+    ), this.uniforms_ = [], t.uniforms && Object.keys(t.uniforms).forEach((o) => {
+      this.uniforms_.push({
+        value: t.uniforms[o],
+        location: e.getUniformLocation(this.renderTargetProgram_, o)
+      });
+    });
+  }
+  /**
+   * Get the WebGL rendering context
+   * @return {WebGLRenderingContext} The rendering context.
+   * @api
+   */
+  getGL() {
+    return this.gl_;
+  }
+  /**
+   * Initialize the render target texture of the post process, make sure it is at the
+   * right size and bind it as a render target for the next draw calls.
+   * The last step to be initialized will be the one where the primitives are rendered.
+   * @param {import("../Map.js").FrameState} frameState current frame state
+   * @api
+   */
+  init(t) {
+    const e = this.getGL(), r = [
+      e.drawingBufferWidth * this.scaleRatio_,
+      e.drawingBufferHeight * this.scaleRatio_
+    ];
+    if (e.bindFramebuffer(e.FRAMEBUFFER, this.getFrameBuffer()), e.bindRenderbuffer(e.RENDERBUFFER, this.getDepthBuffer()), e.viewport(0, 0, r[0], r[1]), !this.renderTargetTextureSize_ || this.renderTargetTextureSize_[0] !== r[0] || this.renderTargetTextureSize_[1] !== r[1]) {
+      this.renderTargetTextureSize_ = r;
+      const i = 0, s = e.RGBA, o = 0, a = e.RGBA, u = e.UNSIGNED_BYTE, h = null;
+      e.bindTexture(e.TEXTURE_2D, this.renderTargetTexture_), e.texImage2D(
+        e.TEXTURE_2D,
+        i,
+        s,
+        r[0],
+        r[1],
+        o,
+        a,
+        u,
+        h
+      ), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.framebufferTexture2D(
+        e.FRAMEBUFFER,
+        e.COLOR_ATTACHMENT0,
+        e.TEXTURE_2D,
+        this.renderTargetTexture_,
+        0
+      ), e.renderbufferStorage(
+        e.RENDERBUFFER,
+        e.DEPTH_COMPONENT16,
+        r[0],
+        r[1]
+      ), e.framebufferRenderbuffer(
+        e.FRAMEBUFFER,
+        e.DEPTH_ATTACHMENT,
+        e.RENDERBUFFER,
+        this.depthBuffer_
+      );
+    }
+  }
+  /**
+   * Render to the next postprocessing pass (or to the canvas if final pass).
+   * @param {import("../Map.js").FrameState} frameState current frame state
+   * @param {WebGLPostProcessingPass} [nextPass] Next pass, optional
+   * @param {function(WebGLRenderingContext, import("../Map.js").FrameState):void} [preCompose] Called before composing.
+   * @param {function(WebGLRenderingContext, import("../Map.js").FrameState):void} [postCompose] Called before composing.
+   * @api
+   */
+  apply(t, e, r, i) {
+    const s = this.getGL(), o = t.size;
+    if (s.bindFramebuffer(
+      s.FRAMEBUFFER,
+      e ? e.getFrameBuffer() : null
+    ), s.activeTexture(s.TEXTURE0), s.bindTexture(s.TEXTURE_2D, this.renderTargetTexture_), !e) {
+      const u = L(s.canvas);
+      if (!t.renderTargets[u]) {
+        const h = s.getContextAttributes();
+        h && h.preserveDrawingBuffer && (s.clearColor(0, 0, 0, 0), s.clearDepth(1), s.clear(s.COLOR_BUFFER_BIT | s.DEPTH_BUFFER_BIT)), t.renderTargets[u] = !0;
+      }
+    }
+    s.disable(s.DEPTH_TEST), s.enable(s.BLEND), s.blendFunc(s.ONE, s.ONE_MINUS_SRC_ALPHA), s.viewport(0, 0, s.drawingBufferWidth, s.drawingBufferHeight), s.bindBuffer(s.ARRAY_BUFFER, this.renderTargetVerticesBuffer_), s.useProgram(this.renderTargetProgram_), s.enableVertexAttribArray(this.renderTargetAttribLocation_), s.vertexAttribPointer(
+      this.renderTargetAttribLocation_,
+      2,
+      s.FLOAT,
+      !1,
+      0,
+      0
+    ), s.uniform2f(this.renderTargetUniformLocation_, o[0], o[1]), s.uniform1i(this.renderTargetTextureLocation_, 0);
+    const a = t.layerStatesArray[t.layerIndex].opacity;
+    s.uniform1f(this.renderTargetOpacityLocation_, a), this.applyUniforms(t), r && r(s, t), s.drawArrays(s.TRIANGLES, 0, 6), i && i(s, t);
+  }
+  /**
+   * @return {WebGLFramebuffer} Frame buffer
+   * @api
+   */
+  getFrameBuffer() {
+    return this.frameBuffer_;
+  }
+  /**
+   * @return {WebGLRenderbuffer} Depth buffer
+   * @api
+   */
+  getDepthBuffer() {
+    return this.depthBuffer_;
+  }
+  /**
+   * Sets the custom uniforms based on what was given in the constructor.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @private
+   */
+  applyUniforms(t) {
+    const e = this.getGL();
+    let r, i = 1;
+    this.uniforms_.forEach(function(s) {
+      if (r = typeof s.value == "function" ? s.value(t) : s.value, r instanceof HTMLCanvasElement || r instanceof ImageData)
+        s.texture || (s.texture = e.createTexture()), e.activeTexture(e[`TEXTURE${i}`]), e.bindTexture(e.TEXTURE_2D, s.texture), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), r instanceof ImageData ? e.texImage2D(
+          e.TEXTURE_2D,
+          0,
+          e.RGBA,
+          e.RGBA,
+          r.width,
+          r.height,
+          0,
+          e.UNSIGNED_BYTE,
+          new Uint8Array(r.data)
+        ) : e.texImage2D(
+          e.TEXTURE_2D,
+          0,
+          e.RGBA,
+          e.RGBA,
+          e.UNSIGNED_BYTE,
+          r
+        ), e.uniform1i(s.location, i++);
+      else if (Array.isArray(r))
+        switch (r.length) {
+          case 2:
+            e.uniform2f(s.location, r[0], r[1]);
+            return;
+          case 3:
+            e.uniform3f(s.location, r[0], r[1], r[2]);
+            return;
+          case 4:
+            e.uniform4f(
+              s.location,
+              r[0],
+              r[1],
+              r[2],
+              r[3]
+            );
+            return;
+          default:
+            return;
+        }
+      else typeof r == "number" && e.uniform1f(s.location, r);
+    });
+  }
+}
+function pt() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function q(n, t) {
+  return n[0] = t[0], n[1] = t[1], n[4] = t[2], n[5] = t[3], n[12] = t[4], n[13] = t[5], n;
+}
+const A = {
+  PROJECTION_MATRIX: "u_projectionMatrix",
+  OFFSET_SCALE_MATRIX: "u_offsetScaleMatrix",
+  OFFSET_ROTATION_MATRIX: "u_offsetRotateMatrix",
+  TIME: "u_time",
+  ZOOM: "u_zoom",
+  RESOLUTION: "u_resolution",
+  VIEWPORT_SIZE_PX: "u_viewportSizePx",
+  PIXEL_RATIO: "u_pixelRatio",
+  HIT_DETECTION: "u_hitDetection"
+}, F = {
+  UNSIGNED_BYTE: ct,
+  UNSIGNED_SHORT: ft,
+  UNSIGNED_INT: lt,
+  FLOAT: Te
+}, X = {};
+function xe(n) {
+  return "shared/" + n;
+}
+let _e = 0;
+function vt() {
+  const n = "unique/" + _e;
+  return _e += 1, n;
+}
+function Et(n) {
+  let t = X[n];
+  if (!t) {
+    const e = document.createElement("canvas");
+    e.width = 1, e.height = 1, e.style.position = "absolute", e.style.left = "0", t = { users: 0, context: dt(e) }, X[n] = t;
+  }
+  return t.users += 1, t.context;
+}
+function mt(n) {
+  const t = X[n];
+  if (!t || (t.users -= 1, t.users > 0))
+    return;
+  const e = t.context, r = e.getExtension("WEBGL_lose_context");
+  r && r.loseContext();
+  const i = e.canvas;
+  i.width = 1, i.height = 1, delete X[n];
+}
+class Tt extends $e {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    super(), t = t || {}, this.boundHandleWebGLContextLost_ = this.handleWebGLContextLost.bind(this), this.boundHandleWebGLContextRestored_ = this.handleWebGLContextRestored.bind(this), this.canvasCacheKey_ = t.canvasCacheKey ? xe(t.canvasCacheKey) : vt(), this.gl_ = Et(this.canvasCacheKey_), this.bufferCache_ = {}, this.extensionCache_ = {}, this.currentProgram_ = null;
+    const e = this.gl_.canvas;
+    e.addEventListener(
+      Z.LOST,
+      this.boundHandleWebGLContextLost_
+    ), e.addEventListener(
+      Z.RESTORED,
+      this.boundHandleWebGLContextRestored_
+    ), this.offsetRotateMatrix_ = C(), this.offsetScaleMatrix_ = C(), this.tmpMat4_ = pt(), this.uniformLocationsByProgram_ = {}, this.attribLocationsByProgram_ = {}, this.uniforms_ = [], t.uniforms && this.setUniforms(t.uniforms), this.postProcessPasses_ = t.postProcesses ? t.postProcesses.map(
+      (r) => new de({
+        webGlContext: this.gl_,
+        scaleRatio: r.scaleRatio,
+        vertexShader: r.vertexShader,
+        fragmentShader: r.fragmentShader,
+        uniforms: r.uniforms
+      })
+    ) : [new de({ webGlContext: this.gl_ })], this.shaderCompileErrors_ = null, this.startTime_ = Date.now();
+  }
+  /**
+   * @param {Object<string, UniformValue>} uniforms Uniform definitions.
+   */
+  setUniforms(t) {
+    this.uniforms_ = [];
+    for (const e in t)
+      this.uniforms_.push({
+        name: e,
+        value: t[e]
+      });
+  }
+  /**
+   * @param {string} canvasCacheKey The canvas cache key.
+   * @return {boolean} The provided key matches the one this helper was constructed with.
+   */
+  canvasCacheKeyMatches(t) {
+    return this.canvasCacheKey_ === xe(t);
+  }
+  /**
+   * Get a WebGL extension.  If the extension is not supported, null is returned.
+   * Extensions are cached after they are enabled for the first time.
+   * @param {string} name The extension name.
+   * @return {Object|null} The extension or null if not supported.
+   */
+  getExtension(t) {
+    if (t in this.extensionCache_)
+      return this.extensionCache_[t];
+    const e = this.gl_.getExtension(t);
+    return this.extensionCache_[t] = e, e;
+  }
+  /**
+   * Just bind the buffer if it's in the cache. Otherwise create
+   * the WebGL buffer, bind it, populate it, and add an entry to
+   * the cache.
+   * @param {import("./Buffer").default} buffer Buffer.
+   */
+  bindBuffer(t) {
+    const e = this.gl_, r = L(t);
+    let i = this.bufferCache_[r];
+    if (!i) {
+      const s = e.createBuffer();
+      i = {
+        buffer: t,
+        webGlBuffer: s
+      }, this.bufferCache_[r] = i;
+    }
+    e.bindBuffer(t.getType(), i.webGlBuffer);
+  }
+  /**
+   * Update the data contained in the buffer array; this is required for the
+   * new data to be rendered
+   * @param {import("./Buffer").default} buffer Buffer.
+   */
+  flushBufferData(t) {
+    const e = this.gl_;
+    this.bindBuffer(t), e.bufferData(t.getType(), t.getArray(), t.getUsage());
+  }
+  /**
+   * @param {import("./Buffer.js").default} buf Buffer.
+   */
+  deleteBuffer(t) {
+    const e = this.gl_, r = L(t), i = this.bufferCache_[r];
+    i && !e.isContextLost() && e.deleteBuffer(i.webGlBuffer), delete this.bufferCache_[r];
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    const t = this.gl_.canvas;
+    t.removeEventListener(
+      Z.LOST,
+      this.boundHandleWebGLContextLost_
+    ), t.removeEventListener(
+      Z.RESTORED,
+      this.boundHandleWebGLContextRestored_
+    ), mt(this.canvasCacheKey_), delete this.gl_;
+  }
+  /**
+   * Clear the buffer & set the viewport to draw.
+   * Post process passes will be initialized here, the first one being bound as a render target for
+   * subsequent draw calls.
+   * @param {import("../Map.js").FrameState} frameState current frame state
+   * @param {boolean} [disableAlphaBlend] If true, no alpha blending will happen.
+   * @param {boolean} [enableDepth] If true, enables depth testing.
+   */
+  prepareDraw(t, e, r) {
+    const i = this.gl_, s = this.getCanvas(), o = t.size, a = t.pixelRatio;
+    (s.width !== o[0] * a || s.height !== o[1] * a) && (s.width = o[0] * a, s.height = o[1] * a, s.style.width = o[0] + "px", s.style.height = o[1] + "px");
+    for (let u = this.postProcessPasses_.length - 1; u >= 0; u--)
+      this.postProcessPasses_[u].init(t);
+    i.bindTexture(i.TEXTURE_2D, null), i.clearColor(0, 0, 0, 0), i.depthRange(0, 1), i.clearDepth(1), i.clear(i.COLOR_BUFFER_BIT | i.DEPTH_BUFFER_BIT), i.enable(i.BLEND), i.blendFunc(i.ONE, e ? i.ZERO : i.ONE_MINUS_SRC_ALPHA), r ? (i.enable(i.DEPTH_TEST), i.depthFunc(i.LEQUAL)) : i.disable(i.DEPTH_TEST);
+  }
+  /**
+   * Prepare a program to use a texture.
+   * @param {WebGLTexture} texture The texture.
+   * @param {number} slot The texture slot.
+   * @param {string} uniformName The corresponding uniform name.
+   */
+  bindTexture(t, e, r) {
+    const i = this.gl_;
+    i.activeTexture(i.TEXTURE0 + e), i.bindTexture(i.TEXTURE_2D, t), i.uniform1i(this.getUniformLocation(r), e);
+  }
+  /**
+   * Clear the render target & bind it for future draw operations.
+   * This is similar to `prepareDraw`, only post processes will not be applied.
+   * Note: the whole viewport will be drawn to the render target, regardless of its size.
+   * @param {import("../Map.js").FrameState} frameState current frame state
+   * @param {import("./RenderTarget.js").default} renderTarget Render target to draw to
+   * @param {boolean} [disableAlphaBlend] If true, no alpha blending will happen.
+   * @param {boolean} [enableDepth] If true, enables depth testing.
+   */
+  prepareDrawToRenderTarget(t, e, r, i) {
+    const s = this.gl_, o = e.getSize();
+    s.bindFramebuffer(s.FRAMEBUFFER, e.getFramebuffer()), s.bindRenderbuffer(s.RENDERBUFFER, e.getDepthbuffer()), s.viewport(0, 0, o[0], o[1]), s.bindTexture(s.TEXTURE_2D, e.getTexture()), s.clearColor(0, 0, 0, 0), s.depthRange(0, 1), s.clearDepth(1), s.clear(s.COLOR_BUFFER_BIT | s.DEPTH_BUFFER_BIT), s.enable(s.BLEND), s.blendFunc(s.ONE, r ? s.ZERO : s.ONE_MINUS_SRC_ALPHA), i ? (s.enable(s.DEPTH_TEST), s.depthFunc(s.LEQUAL)) : s.disable(s.DEPTH_TEST);
+  }
+  /**
+   * Execute a draw call based on the currently bound program, texture, buffers, attributes.
+   * @param {number} start Start index.
+   * @param {number} end End index.
+   */
+  drawElements(t, e) {
+    const r = this.gl_;
+    this.getExtension("OES_element_index_uint");
+    const i = r.UNSIGNED_INT, s = 4, o = e - t, a = t * s;
+    r.drawElements(r.TRIANGLES, o, i, a);
+  }
+  /**
+   * Apply the successive post process passes which will eventually render to the actual canvas.
+   * @param {import("../Map.js").FrameState} frameState current frame state
+   * @param {function(WebGLRenderingContext, import("../Map.js").FrameState):void} [preCompose] Called before composing.
+   * @param {function(WebGLRenderingContext, import("../Map.js").FrameState):void} [postCompose] Called before composing.
+   */
+  finalizeDraw(t, e, r) {
+    for (let i = 0, s = this.postProcessPasses_.length; i < s; i++)
+      i === s - 1 ? this.postProcessPasses_[i].apply(
+        t,
+        null,
+        e,
+        r
+      ) : this.postProcessPasses_[i].apply(
+        t,
+        this.postProcessPasses_[i + 1]
+      );
+  }
+  /**
+   * @return {HTMLCanvasElement} Canvas.
+   */
+  getCanvas() {
+    return (
+      /** @type {HTMLCanvasElement} */
+      this.gl_.canvas
+    );
+  }
+  /**
+   * Get the WebGL rendering context
+   * @return {WebGLRenderingContext} The rendering context.
+   */
+  getGL() {
+    return this.gl_;
+  }
+  /**
+   * Sets the default matrix uniforms for a given frame state. This is called internally in `prepareDraw`.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  applyFrameState(t) {
+    const e = t.size, r = t.viewState.rotation, i = t.pixelRatio, s = ae(this.offsetScaleMatrix_);
+    Ge(s, 2 / e[0], 2 / e[1]);
+    const o = ae(this.offsetRotateMatrix_);
+    r !== 0 && ze(o, -r), this.setUniformMatrixValue(
+      A.OFFSET_SCALE_MATRIX,
+      q(this.tmpMat4_, s)
+    ), this.setUniformMatrixValue(
+      A.OFFSET_ROTATION_MATRIX,
+      q(this.tmpMat4_, o)
+    ), this.setUniformFloatValue(
+      A.TIME,
+      (Date.now() - this.startTime_) * 1e-3
+    ), this.setUniformFloatValue(A.ZOOM, t.viewState.zoom), this.setUniformFloatValue(
+      A.RESOLUTION,
+      t.viewState.resolution
+    ), this.setUniformFloatValue(A.PIXEL_RATIO, i), this.setUniformFloatVec2(A.VIEWPORT_SIZE_PX, [
+      e[0],
+      e[1]
+    ]);
+  }
+  /**
+   * Sets the `u_hitDetection` uniform.
+   * @param {boolean} enabled Whether to enable the hit detection code path
+   */
+  applyHitDetectionUniform(t) {
+    const e = this.getUniformLocation(A.HIT_DETECTION);
+    this.getGL().uniform1i(e, t ? 1 : 0);
+  }
+  /**
+   * Sets the custom uniforms based on what was given in the constructor. This is called internally in `prepareDraw`.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  applyUniforms(t) {
+    const e = this.gl_;
+    let r, i = 0;
+    this.uniforms_.forEach((s) => {
+      if (r = typeof s.value == "function" ? s.value(t) : s.value, r instanceof HTMLCanvasElement || r instanceof HTMLImageElement || r instanceof ImageData)
+        s.texture || (s.prevValue = void 0, s.texture = e.createTexture()), e.activeTexture(e[`TEXTURE${i}`]), e.bindTexture(e.TEXTURE_2D, s.texture), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), (!(r instanceof HTMLImageElement) || /** @type {HTMLImageElement} */
+        r.complete) && s.prevValue !== r && (s.prevValue = r, e.texImage2D(
+          e.TEXTURE_2D,
+          0,
+          e.RGBA,
+          e.RGBA,
+          e.UNSIGNED_BYTE,
+          r
+        )), e.uniform1i(this.getUniformLocation(s.name), i++);
+      else if (Array.isArray(r) && r.length === 6)
+        this.setUniformMatrixValue(
+          s.name,
+          q(this.tmpMat4_, r)
+        );
+      else if (Array.isArray(r) && r.length <= 4)
+        switch (r.length) {
+          case 2:
+            e.uniform2f(
+              this.getUniformLocation(s.name),
+              r[0],
+              r[1]
+            );
+            return;
+          case 3:
+            e.uniform3f(
+              this.getUniformLocation(s.name),
+              r[0],
+              r[1],
+              r[2]
+            );
+            return;
+          case 4:
+            e.uniform4f(
+              this.getUniformLocation(s.name),
+              r[0],
+              r[1],
+              r[2],
+              r[3]
+            );
+            return;
+          default:
+            return;
+        }
+      else typeof r == "number" && e.uniform1f(this.getUniformLocation(s.name), r);
+    });
+  }
+  /**
+   * Set up a program for use. The program will be set as the current one. Then, the uniforms used
+   * in the program will be set based on the current frame state and the helper configuration.
+   * @param {WebGLProgram} program Program.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  useProgram(t, e) {
+    this.gl_.useProgram(t), this.currentProgram_ = t, this.applyFrameState(e), this.applyUniforms(e);
+  }
+  /**
+   * Will attempt to compile a vertex or fragment shader based on source
+   * On error, the shader will be returned but
+   * `gl.getShaderParameter(shader, gl.COMPILE_STATUS)` will return `true`
+   * Use `gl.getShaderInfoLog(shader)` to have details
+   * @param {string} source Shader source
+   * @param {ShaderType} type VERTEX_SHADER or FRAGMENT_SHADER
+   * @return {WebGLShader} Shader object
+   */
+  compileShader(t, e) {
+    const r = this.gl_, i = r.createShader(e);
+    return r.shaderSource(i, t), r.compileShader(i), i;
+  }
+  /**
+   * Create a program for a vertex and fragment shader.  Throws if shader compilation fails.
+   * @param {string} fragmentShaderSource Fragment shader source.
+   * @param {string} vertexShaderSource Vertex shader source.
+   * @return {WebGLProgram} Program
+   */
+  getProgram(t, e) {
+    const r = this.gl_, i = this.compileShader(
+      t,
+      r.FRAGMENT_SHADER
+    ), s = this.compileShader(
+      e,
+      r.VERTEX_SHADER
+    ), o = r.createProgram();
+    if (r.attachShader(o, i), r.attachShader(o, s), r.linkProgram(o), !r.getShaderParameter(i, r.COMPILE_STATUS)) {
+      const a = `Fragment shader compilation failed: ${r.getShaderInfoLog(
+        i
+      )}`;
+      throw new Error(a);
+    }
+    if (r.deleteShader(i), !r.getShaderParameter(s, r.COMPILE_STATUS)) {
+      const a = `Vertex shader compilation failed: ${r.getShaderInfoLog(
+        s
+      )}`;
+      throw new Error(a);
+    }
+    if (r.deleteShader(s), !r.getProgramParameter(o, r.LINK_STATUS)) {
+      const a = `GL program linking failed: ${r.getProgramInfoLog(
+        o
+      )}`;
+      throw new Error(a);
+    }
+    return o;
+  }
+  /**
+   * Will get the location from the shader or the cache
+   * @param {string} name Uniform name
+   * @return {WebGLUniformLocation} uniformLocation
+   */
+  getUniformLocation(t) {
+    const e = L(this.currentProgram_);
+    return this.uniformLocationsByProgram_[e] === void 0 && (this.uniformLocationsByProgram_[e] = {}), this.uniformLocationsByProgram_[e][t] === void 0 && (this.uniformLocationsByProgram_[e][t] = this.gl_.getUniformLocation(this.currentProgram_, t)), this.uniformLocationsByProgram_[e][t];
+  }
+  /**
+   * Will get the location from the shader or the cache
+   * @param {string} name Attribute name
+   * @return {number} attribLocation
+   */
+  getAttributeLocation(t) {
+    const e = L(this.currentProgram_);
+    return this.attribLocationsByProgram_[e] === void 0 && (this.attribLocationsByProgram_[e] = {}), this.attribLocationsByProgram_[e][t] === void 0 && (this.attribLocationsByProgram_[e][t] = this.gl_.getAttribLocation(this.currentProgram_, t)), this.attribLocationsByProgram_[e][t];
+  }
+  /**
+   * Sets the given transform to apply the rotation/translation/scaling of the given frame state.
+   * The resulting transform can be used to convert world space coordinates to view coordinates in the [-1, 1] range.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {import("../transform").Transform} transform Transform to update.
+   * @return {import("../transform").Transform} The updated transform object.
+   */
+  makeProjectionTransform(t, e) {
+    const r = t.size, i = t.viewState.rotation, s = t.viewState.resolution, o = t.viewState.center;
+    return Ee(
+      e,
+      0,
+      0,
+      2 / (s * r[0]),
+      2 / (s * r[1]),
+      -i,
+      -o[0],
+      -o[1]
+    ), e;
+  }
+  /**
+   * Give a value for a standard float uniform
+   * @param {string} uniform Uniform name
+   * @param {number} value Value
+   */
+  setUniformFloatValue(t, e) {
+    this.gl_.uniform1f(this.getUniformLocation(t), e);
+  }
+  /**
+   * Give a value for a vec2 uniform
+   * @param {string} uniform Uniform name
+   * @param {Array<number>} value Array of length 4.
+   */
+  setUniformFloatVec2(t, e) {
+    this.gl_.uniform2fv(this.getUniformLocation(t), e);
+  }
+  /**
+   * Give a value for a vec4 uniform
+   * @param {string} uniform Uniform name
+   * @param {Array<number>} value Array of length 4.
+   */
+  setUniformFloatVec4(t, e) {
+    this.gl_.uniform4fv(this.getUniformLocation(t), e);
+  }
+  /**
+   * Give a value for a standard matrix4 uniform
+   * @param {string} uniform Uniform name
+   * @param {Array<number>} value Matrix value
+   */
+  setUniformMatrixValue(t, e) {
+    this.gl_.uniformMatrix4fv(this.getUniformLocation(t), !1, e);
+  }
+  /**
+   * Will set the currently bound buffer to an attribute of the shader program. Used by `#enableAttributes`
+   * internally.
+   * @param {string} attribName Attribute name
+   * @param {number} size Number of components per attributes
+   * @param {number} type UNSIGNED_INT, UNSIGNED_BYTE, UNSIGNED_SHORT or FLOAT
+   * @param {number} stride Stride in bytes (0 means attribs are packed)
+   * @param {number} offset Offset in bytes
+   * @private
+   */
+  enableAttributeArray_(t, e, r, i, s) {
+    const o = this.getAttributeLocation(t);
+    o < 0 || (this.gl_.enableVertexAttribArray(o), this.gl_.vertexAttribPointer(o, e, r, !1, i, s));
+  }
+  /**
+   * Will enable the following attributes to be read from the currently bound buffer,
+   * i.e. tell the GPU where to read the different attributes in the buffer. An error in the
+   * size/type/order of attributes will most likely break the rendering and throw a WebGL exception.
+   * @param {Array<AttributeDescription>} attributes Ordered list of attributes to read from the buffer
+   */
+  enableAttributes(t) {
+    const e = yt(t);
+    let r = 0;
+    for (let i = 0; i < t.length; i++) {
+      const s = t[i];
+      this.enableAttributeArray_(
+        s.name,
+        s.size,
+        s.type || Te,
+        e,
+        r
+      ), r += s.size * ye(s.type);
+    }
+  }
+  /**
+   * WebGL context was lost
+   * @private
+   */
+  handleWebGLContextLost() {
+    Je(this.bufferCache_), this.currentProgram_ = null;
+  }
+  /**
+   * WebGL context was restored
+   * @private
+   */
+  handleWebGLContextRestored() {
+  }
+  /**
+   * Will create or reuse a given webgl texture and apply the given size. If no image data
+   * specified, the texture will be empty, otherwise image data will be used and the `size`
+   * parameter will be ignored.
+   * Note: wrap parameters are set to clamp to edge, min filter is set to linear.
+   * @param {Array<number>} size Expected size of the texture
+   * @param {ImageData|HTMLImageElement|HTMLCanvasElement} [data] Image data/object to bind to the texture
+   * @param {WebGLTexture} [texture] Existing texture to reuse
+   * @return {WebGLTexture} The generated texture
+   */
+  createTexture(t, e, r) {
+    const i = this.gl_;
+    r = r || i.createTexture();
+    const s = 0, o = i.RGBA, a = 0, u = i.RGBA, h = i.UNSIGNED_BYTE;
+    return i.bindTexture(i.TEXTURE_2D, r), e ? i.texImage2D(i.TEXTURE_2D, s, o, u, h, e) : i.texImage2D(
+      i.TEXTURE_2D,
+      s,
+      o,
+      t[0],
+      t[1],
+      a,
+      u,
+      h,
+      null
+    ), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), r;
+  }
+}
+function yt(n) {
+  let t = 0;
+  for (let e = 0; e < n.length; e++) {
+    const r = n[e];
+    t += r.size * ye(r.type);
+  }
+  return t;
+}
+function ye(n) {
+  switch (n) {
+    case F.UNSIGNED_BYTE:
+      return Uint8Array.BYTES_PER_ELEMENT;
+    case F.UNSIGNED_SHORT:
+      return Uint16Array.BYTES_PER_ELEMENT;
+    case F.UNSIGNED_INT:
+      return Uint32Array.BYTES_PER_ELEMENT;
+    case F.FLOAT:
+    default:
+      return Float32Array.BYTES_PER_ELEMENT;
+  }
+}
+class ne extends Ne {
+  /**
+   * @param {LayerType} layer Layer.
+   * @param {Options} [options] Options.
+   */
+  constructor(t, e) {
+    super(t), e = e || {}, this.inversePixelTransform_ = C(), this.pixelContext_ = null, this.postProcesses_ = e.postProcesses, this.uniforms_ = e.uniforms, this.helper, t.addChangeListener(Ze.MAP, this.removeHelper.bind(this)), this.dispatchPreComposeEvent = this.dispatchPreComposeEvent.bind(this), this.dispatchPostComposeEvent = this.dispatchPostComposeEvent.bind(this);
+  }
+  /**
+   * @param {WebGLRenderingContext} context The WebGL rendering context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  dispatchPreComposeEvent(t, e) {
+    const r = this.getLayer();
+    if (r.hasListener(U.PRECOMPOSE)) {
+      const i = new Y(
+        U.PRECOMPOSE,
+        void 0,
+        e,
+        t
+      );
+      r.dispatchEvent(i);
+    }
+  }
+  /**
+   * @param {WebGLRenderingContext} context The WebGL rendering context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  dispatchPostComposeEvent(t, e) {
+    const r = this.getLayer();
+    if (r.hasListener(U.POSTCOMPOSE)) {
+      const i = new Y(
+        U.POSTCOMPOSE,
+        void 0,
+        e,
+        t
+      );
+      r.dispatchEvent(i);
+    }
+  }
+  /**
+   * Reset options (only handles uniforms).
+   * @param {Options} options Options.
+   */
+  reset(t) {
+    this.uniforms_ = t.uniforms, this.helper && this.helper.setUniforms(this.uniforms_);
+  }
+  /**
+   * @protected
+   */
+  removeHelper() {
+    this.helper && (this.helper.dispose(), delete this.helper);
+  }
+  /**
+   * Determine whether renderFrame should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrame(t) {
+    if (this.getLayer().getRenderSource()) {
+      let e = !0, r = -1, i;
+      for (let o = 0, a = t.layerStatesArray.length; o < a; o++) {
+        const u = t.layerStatesArray[o].layer, h = u.getRenderer();
+        if (!(h instanceof ne)) {
+          e = !0;
+          continue;
+        }
+        const f = u.getClassName();
+        if ((e || f !== i) && (r += 1, e = !1), i = f, h === this)
+          break;
+      }
+      const s = "map/" + t.mapId + "/group/" + r;
+      (!this.helper || !this.helper.canvasCacheKeyMatches(s)) && (this.removeHelper(), this.helper = new Tt({
+        postProcesses: this.postProcesses_,
+        uniforms: this.uniforms_,
+        canvasCacheKey: s
+      }), i && (this.helper.getCanvas().className = i), this.afterHelperCreated());
+    }
+    return this.prepareFrameInternal(t);
+  }
+  /**
+   * @protected
+   */
+  afterHelperCreated() {
+  }
+  /**
+   * Determine whether renderFrame should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   * @protected
+   */
+  prepareFrameInternal(t) {
+    return !0;
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.removeHelper(), super.disposeInternal();
+  }
+  /**
+   * @param {import("../../render/EventType.js").default} type Event type.
+   * @param {WebGLRenderingContext} context The rendering context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @private
+   */
+  dispatchRenderEvent_(t, e, r) {
+    const i = this.getLayer();
+    if (i.hasListener(t)) {
+      Ee(
+        this.inversePixelTransform_,
+        0,
+        0,
+        r.pixelRatio,
+        -r.pixelRatio,
+        0,
+        0,
+        -r.size[1]
+      );
+      const s = new Y(
+        t,
+        this.inversePixelTransform_,
+        r,
+        e
+      );
+      i.dispatchEvent(s);
+    }
+  }
+  /**
+   * @param {WebGLRenderingContext} context The rendering context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  preRender(t, e) {
+    this.dispatchRenderEvent_(U.PRERENDER, t, e);
+  }
+  /**
+   * @param {WebGLRenderingContext} context The rendering context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  postRender(t, e) {
+    this.dispatchRenderEvent_(U.POSTRENDER, t, e);
+  }
+}
+const R = new Uint8Array(4);
+class Rt {
+  /**
+   * @param {import("./Helper.js").default} helper WebGL helper; mandatory.
+   * @param {Array<number>} [size] Expected size of the render target texture; note: this can be changed later on.
+   */
+  constructor(t, e) {
+    this.helper_ = t;
+    const r = t.getGL();
+    this.texture_ = r.createTexture(), this.framebuffer_ = r.createFramebuffer(), this.depthbuffer_ = r.createRenderbuffer(), this.size_ = e || [1, 1], this.data_ = new Uint8Array(0), this.dataCacheDirty_ = !0, this.updateSize_();
+  }
+  /**
+   * Changes the size of the render target texture. Note: will do nothing if the size
+   * is already the same.
+   * @param {Array<number>} size Expected size of the render target texture
+   * @api
+   */
+  setSize(t) {
+    Qe(t, this.size_) || (this.size_[0] = t[0], this.size_[1] = t[1], this.updateSize_());
+  }
+  /**
+   * Returns the size of the render target texture
+   * @return {Array<number>} Size of the render target texture
+   * @api
+   */
+  getSize() {
+    return this.size_;
+  }
+  /**
+   * This will cause following calls to `#readAll` or `#readPixel` to download the content of the
+   * render target into memory, which is an expensive operation.
+   * This content will be kept in cache but should be cleared after each new render.
+   * @api
+   */
+  clearCachedData() {
+    this.dataCacheDirty_ = !0;
+  }
+  /**
+   * Returns the full content of the frame buffer as a series of r, g, b, a components
+   * in the 0-255 range (unsigned byte).
+   * @return {Uint8Array} Integer array of color values
+   * @api
+   */
+  readAll() {
+    if (this.dataCacheDirty_) {
+      const t = this.size_, e = this.helper_.getGL();
+      e.bindFramebuffer(e.FRAMEBUFFER, this.framebuffer_), e.readPixels(
+        0,
+        0,
+        t[0],
+        t[1],
+        e.RGBA,
+        e.UNSIGNED_BYTE,
+        this.data_
+      ), this.dataCacheDirty_ = !1;
+    }
+    return this.data_;
+  }
+  /**
+   * Reads one pixel of the frame buffer as an array of r, g, b, a components
+   * in the 0-255 range (unsigned byte).
+   * If x and/or y are outside of existing data, an array filled with 0 is returned.
+   * @param {number} x Pixel coordinate
+   * @param {number} y Pixel coordinate
+   * @return {Uint8Array} Integer array with one color value (4 components)
+   * @api
+   */
+  readPixel(t, e) {
+    if (t < 0 || e < 0 || t > this.size_[0] || e >= this.size_[1])
+      return R[0] = 0, R[1] = 0, R[2] = 0, R[3] = 0, R;
+    this.readAll();
+    const r = Math.floor(t) + (this.size_[1] - Math.floor(e) - 1) * this.size_[0];
+    return R[0] = this.data_[r * 4], R[1] = this.data_[r * 4 + 1], R[2] = this.data_[r * 4 + 2], R[3] = this.data_[r * 4 + 3], R;
+  }
+  /**
+   * @return {WebGLTexture} Texture to render to
+   */
+  getTexture() {
+    return this.texture_;
+  }
+  /**
+   * @return {WebGLFramebuffer} Frame buffer of the render target
+   */
+  getFramebuffer() {
+    return this.framebuffer_;
+  }
+  /**
+   * @return {WebGLRenderbuffer} Depth buffer of the render target
+   */
+  getDepthbuffer() {
+    return this.depthbuffer_;
+  }
+  /**
+   * @private
+   */
+  updateSize_() {
+    const t = this.size_, e = this.helper_.getGL();
+    this.texture_ = this.helper_.createTexture(t, null, this.texture_), e.bindFramebuffer(e.FRAMEBUFFER, this.framebuffer_), e.viewport(0, 0, t[0], t[1]), e.framebufferTexture2D(
+      e.FRAMEBUFFER,
+      e.COLOR_ATTACHMENT0,
+      e.TEXTURE_2D,
+      this.texture_,
+      0
+    ), e.bindRenderbuffer(e.RENDERBUFFER, this.depthbuffer_), e.renderbufferStorage(
+      e.RENDERBUFFER,
+      e.DEPTH_COMPONENT16,
+      t[0],
+      t[1]
+    ), e.framebufferRenderbuffer(
+      e.FRAMEBUFFER,
+      e.DEPTH_ATTACHMENT,
+      e.RENDERBUFFER,
+      this.depthbuffer_
+    ), this.data_ = new Uint8Array(t[0] * t[1] * 4);
+  }
+}
+const ge = {
+  GENERATE_POLYGON_BUFFERS: "GENERATE_POLYGON_BUFFERS",
+  GENERATE_POINT_BUFFERS: "GENERATE_POINT_BUFFERS",
+  GENERATE_LINE_STRING_BUFFERS: "GENERATE_LINE_STRING_BUFFERS"
+};
+var Re = { exports: {} };
+Re.exports = k;
+Re.exports.default = k;
+function k(n, t, e) {
+  e = e || 2;
+  var r = t && t.length, i = r ? t[0] * e : n.length, s = be(n, 0, i, e, !0), o = [];
+  if (!s || s.next === s.prev) return o;
+  var a, u, h, f, c, l, x;
+  if (r && (s = St(n, t, s, e)), n.length > 80 * e) {
+    a = h = n[0], u = f = n[1];
+    for (var d = e; d < i; d += e)
+      c = n[d], l = n[d + 1], c < a && (a = c), l < u && (u = l), c > h && (h = c), l > f && (f = l);
+    x = Math.max(h - a, f - u), x = x !== 0 ? 32767 / x : 0;
+  }
+  return D(s, o, e, a, u, x, 0), o;
+}
+function be(n, t, e, r, i) {
+  var s, o;
+  if (i === ee(n, t, e, r) > 0)
+    for (s = t; s < e; s += r) o = pe(s, n[s], n[s + 1], o);
+  else
+    for (s = e - r; s >= t; s -= r) o = pe(s, n[s], n[s + 1], o);
+  return o && V(o, o.next) && (M(o), o = o.next), o;
+}
+function P(n, t) {
+  if (!n) return n;
+  t || (t = n);
+  var e = n, r;
+  do
+    if (r = !1, !e.steiner && (V(e, e.next) || p(e.prev, e, e.next) === 0)) {
+      if (M(e), e = t = e.prev, e === e.next) break;
+      r = !0;
+    } else
+      e = e.next;
+  while (r || e !== t);
+  return t;
+}
+function D(n, t, e, r, i, s, o) {
+  if (n) {
+    !o && s && It(n, r, i, s);
+    for (var a = n, u, h; n.prev !== n.next; ) {
+      if (u = n.prev, h = n.next, s ? At(n, r, i, s) : bt(n)) {
+        t.push(u.i / e | 0), t.push(n.i / e | 0), t.push(h.i / e | 0), M(n), n = h.next, a = h.next;
+        continue;
+      }
+      if (n = h, n === a) {
+        o ? o === 1 ? (n = Ft(P(n), t, e), D(n, t, e, r, i, s, 2)) : o === 2 && Lt(n, t, e, r, i, s) : D(P(n), t, e, r, i, s, 1);
+        break;
+      }
+    }
+  }
+}
+function bt(n) {
+  var t = n.prev, e = n, r = n.next;
+  if (p(t, e, r) >= 0) return !1;
+  for (var i = t.x, s = e.x, o = r.x, a = t.y, u = e.y, h = r.y, f = i < s ? i < o ? i : o : s < o ? s : o, c = a < u ? a < h ? a : h : u < h ? u : h, l = i > s ? i > o ? i : o : s > o ? s : o, x = a > u ? a > h ? a : h : u > h ? u : h, d = r.next; d !== t; ) {
+    if (d.x >= f && d.x <= l && d.y >= c && d.y <= x && I(i, a, s, u, o, h, d.x, d.y) && p(d.prev, d, d.next) >= 0) return !1;
+    d = d.next;
+  }
+  return !0;
+}
+function At(n, t, e, r) {
+  var i = n.prev, s = n, o = n.next;
+  if (p(i, s, o) >= 0) return !1;
+  for (var a = i.x, u = s.x, h = o.x, f = i.y, c = s.y, l = o.y, x = a < u ? a < h ? a : h : u < h ? u : h, d = f < c ? f < l ? f : l : c < l ? c : l, b = a > u ? a > h ? a : h : u > h ? u : h, S = f > c ? f > l ? f : l : c > l ? c : l, N = J(x, d, t, e, r), O = J(b, S, t, e, r), _ = n.prevZ, g = n.nextZ; _ && _.z >= N && g && g.z <= O; ) {
+    if (_.x >= x && _.x <= b && _.y >= d && _.y <= S && _ !== i && _ !== o && I(a, f, u, c, h, l, _.x, _.y) && p(_.prev, _, _.next) >= 0 || (_ = _.prevZ, g.x >= x && g.x <= b && g.y >= d && g.y <= S && g !== i && g !== o && I(a, f, u, c, h, l, g.x, g.y) && p(g.prev, g, g.next) >= 0)) return !1;
+    g = g.nextZ;
+  }
+  for (; _ && _.z >= N; ) {
+    if (_.x >= x && _.x <= b && _.y >= d && _.y <= S && _ !== i && _ !== o && I(a, f, u, c, h, l, _.x, _.y) && p(_.prev, _, _.next) >= 0) return !1;
+    _ = _.prevZ;
+  }
+  for (; g && g.z <= O; ) {
+    if (g.x >= x && g.x <= b && g.y >= d && g.y <= S && g !== i && g !== o && I(a, f, u, c, h, l, g.x, g.y) && p(g.prev, g, g.next) >= 0) return !1;
+    g = g.nextZ;
+  }
+  return !0;
+}
+function Ft(n, t, e) {
+  var r = n;
+  do {
+    var i = r.prev, s = r.next.next;
+    !V(i, s) && Ae(i, r, r.next, s) && B(i, s) && B(s, i) && (t.push(i.i / e | 0), t.push(r.i / e | 0), t.push(s.i / e | 0), M(r), M(r.next), r = n = s), r = r.next;
+  } while (r !== n);
+  return P(r);
+}
+function Lt(n, t, e, r, i, s) {
+  var o = n;
+  do {
+    for (var a = o.next.next; a !== o.prev; ) {
+      if (o.i !== a.i && Mt(o, a)) {
+        var u = Fe(o, a);
+        o = P(o, o.next), u = P(u, u.next), D(o, t, e, r, i, s, 0), D(u, t, e, r, i, s, 0);
+        return;
+      }
+      a = a.next;
+    }
+    o = o.next;
+  } while (o !== n);
+}
+function St(n, t, e, r) {
+  var i = [], s, o, a, u, h;
+  for (s = 0, o = t.length; s < o; s++)
+    a = t[s] * r, u = s < o - 1 ? t[s + 1] * r : n.length, h = be(n, a, u, r, !1), h === h.next && (h.steiner = !0), i.push(Bt(h));
+  for (i.sort(Ct), s = 0; s < i.length; s++)
+    e = Pt(i[s], e);
+  return e;
+}
+function Ct(n, t) {
+  return n.x - t.x;
+}
+function Pt(n, t) {
+  var e = Ut(n, t);
+  if (!e)
+    return t;
+  var r = Fe(e, n);
+  return P(r, r.next), P(e, e.next);
+}
+function Ut(n, t) {
+  var e = t, r = n.x, i = n.y, s = -1 / 0, o;
+  do {
+    if (i <= e.y && i >= e.next.y && e.next.y !== e.y) {
+      var a = e.x + (i - e.y) * (e.next.x - e.x) / (e.next.y - e.y);
+      if (a <= r && a > s && (s = a, o = e.x < e.next.x ? e : e.next, a === r))
+        return o;
+    }
+    e = e.next;
+  } while (e !== t);
+  if (!o) return null;
+  var u = o, h = o.x, f = o.y, c = 1 / 0, l;
+  e = o;
+  do
+    r >= e.x && e.x >= h && r !== e.x && I(i < f ? r : s, i, h, f, i < f ? s : r, i, e.x, e.y) && (l = Math.abs(i - e.y) / (r - e.x), B(e, n) && (l < c || l === c && (e.x > o.x || e.x === o.x && wt(o, e))) && (o = e, c = l)), e = e.next;
+  while (e !== u);
+  return o;
+}
+function wt(n, t) {
+  return p(n.prev, n, t.prev) < 0 && p(t.next, n, n.next) < 0;
+}
+function It(n, t, e, r) {
+  var i = n;
+  do
+    i.z === 0 && (i.z = J(i.x, i.y, t, e, r)), i.prevZ = i.prev, i.nextZ = i.next, i = i.next;
+  while (i !== n);
+  i.prevZ.nextZ = null, i.prevZ = null, Dt(i);
+}
+function Dt(n) {
+  var t, e, r, i, s, o, a, u, h = 1;
+  do {
+    for (e = n, n = null, s = null, o = 0; e; ) {
+      for (o++, r = e, a = 0, t = 0; t < h && (a++, r = r.nextZ, !!r); t++)
+        ;
+      for (u = h; a > 0 || u > 0 && r; )
+        a !== 0 && (u === 0 || !r || e.z <= r.z) ? (i = e, e = e.nextZ, a--) : (i = r, r = r.nextZ, u--), s ? s.nextZ = i : n = i, i.prevZ = s, s = i;
+      e = r;
+    }
+    s.nextZ = null, h *= 2;
+  } while (o > 1);
+  return n;
+}
+function J(n, t, e, r, i) {
+  return n = (n - e) * i | 0, t = (t - r) * i | 0, n = (n | n << 8) & 16711935, n = (n | n << 4) & 252645135, n = (n | n << 2) & 858993459, n = (n | n << 1) & 1431655765, t = (t | t << 8) & 16711935, t = (t | t << 4) & 252645135, t = (t | t << 2) & 858993459, t = (t | t << 1) & 1431655765, n | t << 1;
+}
+function Bt(n) {
+  var t = n, e = n;
+  do
+    (t.x < e.x || t.x === e.x && t.y < e.y) && (e = t), t = t.next;
+  while (t !== n);
+  return e;
+}
+function I(n, t, e, r, i, s, o, a) {
+  return (i - o) * (t - a) >= (n - o) * (s - a) && (n - o) * (r - a) >= (e - o) * (t - a) && (e - o) * (s - a) >= (i - o) * (r - a);
+}
+function Mt(n, t) {
+  return n.next.i !== t.i && n.prev.i !== t.i && !Nt(n, t) && // dones't intersect other edges
+  (B(n, t) && B(t, n) && Ot(n, t) && // locally visible
+  (p(n.prev, n, t.prev) || p(n, t.prev, t)) || // does not create opposite-facing sectors
+  V(n, t) && p(n.prev, n, n.next) > 0 && p(t.prev, t, t.next) > 0);
+}
+function p(n, t, e) {
+  return (t.y - n.y) * (e.x - t.x) - (t.x - n.x) * (e.y - t.y);
+}
+function V(n, t) {
+  return n.x === t.x && n.y === t.y;
+}
+function Ae(n, t, e, r) {
+  var i = W(p(n, t, e)), s = W(p(n, t, r)), o = W(p(e, r, n)), a = W(p(e, r, t));
+  return !!(i !== s && o !== a || i === 0 && H(n, e, t) || s === 0 && H(n, r, t) || o === 0 && H(e, n, r) || a === 0 && H(e, t, r));
+}
+function H(n, t, e) {
+  return t.x <= Math.max(n.x, e.x) && t.x >= Math.min(n.x, e.x) && t.y <= Math.max(n.y, e.y) && t.y >= Math.min(n.y, e.y);
+}
+function W(n) {
+  return n > 0 ? 1 : n < 0 ? -1 : 0;
+}
+function Nt(n, t) {
+  var e = n;
+  do {
+    if (e.i !== n.i && e.next.i !== n.i && e.i !== t.i && e.next.i !== t.i && Ae(e, e.next, n, t)) return !0;
+    e = e.next;
+  } while (e !== n);
+  return !1;
+}
+function B(n, t) {
+  return p(n.prev, n, n.next) < 0 ? p(n, t, n.next) >= 0 && p(n, n.prev, t) >= 0 : p(n, t, n.prev) < 0 || p(n, n.next, t) < 0;
+}
+function Ot(n, t) {
+  var e = n, r = !1, i = (n.x + t.x) / 2, s = (n.y + t.y) / 2;
+  do
+    e.y > s != e.next.y > s && e.next.y !== e.y && i < (e.next.x - e.x) * (s - e.y) / (e.next.y - e.y) + e.x && (r = !r), e = e.next;
+  while (e !== n);
+  return r;
+}
+function Fe(n, t) {
+  var e = new Q(n.i, n.x, n.y), r = new Q(t.i, t.x, t.y), i = n.next, s = t.prev;
+  return n.next = t, t.prev = n, e.next = i, i.prev = e, r.next = e, e.prev = r, s.next = r, r.prev = s, r;
+}
+function pe(n, t, e, r) {
+  var i = new Q(n, t, e);
+  return r ? (i.next = r.next, i.prev = r, r.next.prev = i, r.next = i) : (i.prev = i, i.next = i), i;
+}
+function M(n) {
+  n.next.prev = n.prev, n.prev.next = n.next, n.prevZ && (n.prevZ.nextZ = n.nextZ), n.nextZ && (n.nextZ.prevZ = n.prevZ);
+}
+function Q(n, t, e) {
+  this.i = n, this.x = t, this.y = e, this.prev = null, this.next = null, this.z = 0, this.prevZ = null, this.nextZ = null, this.steiner = !1;
+}
+k.deviation = function(n, t, e, r) {
+  var i = t && t.length, s = i ? t[0] * e : n.length, o = Math.abs(ee(n, 0, s, e));
+  if (i)
+    for (var a = 0, u = t.length; a < u; a++) {
+      var h = t[a] * e, f = a < u - 1 ? t[a + 1] * e : n.length;
+      o -= Math.abs(ee(n, h, f, e));
+    }
+  var c = 0;
+  for (a = 0; a < r.length; a += 3) {
+    var l = r[a] * e, x = r[a + 1] * e, d = r[a + 2] * e;
+    c += Math.abs(
+      (n[l] - n[d]) * (n[x + 1] - n[l + 1]) - (n[l] - n[x]) * (n[d + 1] - n[l + 1])
+    );
+  }
+  return o === 0 && c === 0 ? 0 : Math.abs((c - o) / o);
+};
+function ee(n, t, e, r) {
+  for (var i = 0, s = t, o = e - r; s < e; s += r)
+    i += (n[o] - n[s]) * (n[s + 1] + n[o + 1]), o = s;
+  return i;
+}
+k.flatten = function(n) {
+  for (var t = n[0][0].length, e = { vertices: [], holes: [], dimensions: t }, r = 0, i = 0; i < n.length; i++) {
+    for (var s = 0; s < n[i].length; s++)
+      for (var o = 0; o < t; o++) e.vertices.push(n[i][s][o]);
+    i > 0 && (r += n[i - 1].length, e.holes.push(r));
+  }
+  return e;
+};
+function Gt(n, t) {
+  t = t || [];
+  const e = 256, r = e - 1;
+  return t[0] = Math.floor(n / e / e / e) / r, t[1] = Math.floor(n / e / e) % e / r, t[2] = Math.floor(n / e) % e / r, t[3] = n % e / r, t;
+}
+function zt(n) {
+  let t = 0;
+  const e = 256, r = e - 1;
+  return t += Math.round(n[0] * e * e * e * r), t += Math.round(n[1] * e * e * r), t += Math.round(n[2] * e * r), t += Math.round(n[3] * r), t;
+}
+function Zt() {
+  const n = 'const e="GENERATE_POLYGON_BUFFERS",t="GENERATE_POINT_BUFFERS",n="GENERATE_LINE_STRING_BUFFERS",r={1:"The view center is not defined",2:"The view resolution is not defined",3:"The view rotation is not defined",4:"`image` and `src` cannot be provided at the same time",5:"`imgSize` must be set when `image` is provided",7:"`format` must be set when `url` is set",8:"Unknown `serverType` configured",9:"`url` must be configured or set using `#setUrl()`",10:"The default `geometryFunction` can only handle `Point` geometries",11:"`options.featureTypes` must be an Array",12:"`options.geometryName` must also be provided when `options.bbox` is set",13:"Invalid corner",14:"Invalid color",15:"Tried to get a value for a key that does not exist in the cache",16:"Tried to set a value for a key that is used already",17:"`resolutions` must be sorted in descending order",18:"Either `origin` or `origins` must be configured, never both",19:"Number of `tileSizes` and `resolutions` must be equal",20:"Number of `origins` and `resolutions` must be equal",22:"Either `tileSize` or `tileSizes` must be configured, never both",24:"Invalid extent or geometry provided as `geometry`",25:"Cannot fit empty extent provided as `geometry`",26:"Features must have an id set",27:"Features must have an id set",28:\'`renderMode` must be `"hybrid"` or `"vector"`\',30:"The passed `feature` was already added to the source",31:"Tried to enqueue an `element` that was already added to the queue",32:"Transformation matrix cannot be inverted",33:"Invalid units",34:"Invalid geometry layout",36:"Unknown SRS type",37:"Unknown geometry type found",38:"`styleMapValue` has an unknown type",39:"Unknown geometry type",40:"Expected `feature` to have a geometry",41:"Expected an `ol/style/Style` or an array of `ol/style/Style.js`",42:"Question unknown, the answer is 42",43:"Expected `layers` to be an array or a `Collection`",47:"Expected `controls` to be an array or an `ol/Collection`",48:"Expected `interactions` to be an array or an `ol/Collection`",49:"Expected `overlays` to be an array or an `ol/Collection`",50:"`options.featureTypes` should be an Array",51:"Either `url` or `tileJSON` options must be provided",52:"Unknown `serverType` configured",53:"Unknown `tierSizeCalculation` configured",55:"The {-y} placeholder requires a tile grid with extent",56:"mapBrowserEvent must originate from a pointer event",57:"At least 2 conditions are required",59:"Invalid command found in the PBF",60:"Missing or invalid `size`",61:"Cannot determine IIIF Image API version from provided image information JSON",62:"A `WebGLArrayBuffer` must either be of type `ELEMENT_ARRAY_BUFFER` or `ARRAY_BUFFER`",64:"Layer opacity must be a number",66:"`forEachFeatureAtCoordinate` cannot be used on a WebGL layer if the hit detection logic has not been enabled. This is done by providing adequate shaders using the `hitVertexShader` and `hitFragmentShader` properties of `WebGLPointsLayerRenderer`",67:"A layer can only be added to the map once. Use either `layer.setMap()` or `map.addLayer()`, not both",68:"A VectorTile source can only be rendered if it has a projection compatible with the view projection",69:"`width` or `height` cannot be provided together with `scale`"};class o extends Error{constructor(e){const t=r[e];super(t),this.code=e,this.name="AssertionError",this.message=t}}var i=o;function a(e,t){const n=t[0],r=t[1];return t[0]=e[0]*n+e[2]*r+e[4],t[1]=e[1]*n+e[3]*r+e[5],t}function s(e,t){const n=(r=t)[0]*r[3]-r[1]*r[2];var r;!function(e,t){if(!e)throw new i(t)}(0!==n,32);const o=t[0],a=t[1],s=t[2],u=t[3],f=t[4],x=t[5];return e[0]=u/n,e[1]=-a/n,e[2]=-s/n,e[3]=o/n,e[4]=(s*x-u*f)/n,e[5]=-(o*x-a*f)/n,e}function u(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}new Array(6);var f={exports:{}};function x(e,t,n){n=n||2;var r,o,i,a,s,u,f,x=t&&t.length,h=x?t[0]*n:e.length,v=l(e,0,h,n,!0),d=[];if(!v||v.next===v.prev)return d;if(x&&(v=function(e,t,n,r){var o,i,a,s=[];for(o=0,i=t.length;o<i;o++)(a=l(e,t[o]*r,o<i-1?t[o+1]*r:e.length,r,!1))===a.next&&(a.steiner=!0),s.push(A(a));for(s.sort(b),o=0;o<s.length;o++)n=g(s[o],n);return n}(e,t,v,n)),e.length>80*n){r=i=e[0],o=a=e[1];for(var y=n;y<h;y+=n)(s=e[y])<r&&(r=s),(u=e[y+1])<o&&(o=u),s>i&&(i=s),u>a&&(a=u);f=0!==(f=Math.max(i-r,a-o))?32767/f:0}return c(v,d,n,r,o,f,0),d}function l(e,t,n,r,o){var i,a;if(o===P(e,t,n,r)>0)for(i=t;i<n;i+=r)a=k(i,e[i],e[i+1],a);else for(i=n-r;i>=t;i-=r)a=k(i,e[i],e[i+1],a);return a&&F(a,a.next)&&(R(a),a=a.next),a}function h(e,t){if(!e)return e;t||(t=e);var n,r=e;do{if(n=!1,r.steiner||!F(r,r.next)&&0!==Z(r.prev,r,r.next))r=r.next;else{if(R(r),(r=t=r.prev)===r.next)break;n=!0}}while(n||r!==t);return t}function c(e,t,n,r,o,i,a){if(e){!a&&i&&function(e,t,n,r){var o=e;do{0===o.z&&(o.z=w(o.x,o.y,t,n,r)),o.prevZ=o.prev,o.nextZ=o.next,o=o.next}while(o!==e);o.prevZ.nextZ=null,o.prevZ=null,function(e){var t,n,r,o,i,a,s,u,f=1;do{for(n=e,e=null,i=null,a=0;n;){for(a++,r=n,s=0,t=0;t<f&&(s++,r=r.nextZ);t++);for(u=f;s>0||u>0&&r;)0!==s&&(0===u||!r||n.z<=r.z)?(o=n,n=n.nextZ,s--):(o=r,r=r.nextZ,u--),i?i.nextZ=o:e=o,o.prevZ=i,i=o;n=r}i.nextZ=null,f*=2}while(a>1)}(o)}(e,r,o,i);for(var s,u,f=e;e.prev!==e.next;)if(s=e.prev,u=e.next,i?d(e,r,o,i):v(e))t.push(s.i/n|0),t.push(e.i/n|0),t.push(u.i/n|0),R(e),e=u.next,f=u.next;else if((e=u)===f){a?1===a?c(e=y(h(e),t,n),t,n,r,o,i,2):2===a&&p(e,t,n,r,o,i):c(h(e),t,n,r,o,i,1);break}}}function v(e){var t=e.prev,n=e,r=e.next;if(Z(t,n,r)>=0)return!1;for(var o=t.x,i=n.x,a=r.x,s=t.y,u=n.y,f=r.y,x=o<i?o<a?o:a:i<a?i:a,l=s<u?s<f?s:f:u<f?u:f,h=o>i?o>a?o:a:i>a?i:a,c=s>u?s>f?s:f:u>f?u:f,v=r.next;v!==t;){if(v.x>=x&&v.x<=h&&v.y>=l&&v.y<=c&&E(o,s,i,u,a,f,v.x,v.y)&&Z(v.prev,v,v.next)>=0)return!1;v=v.next}return!0}function d(e,t,n,r){var o=e.prev,i=e,a=e.next;if(Z(o,i,a)>=0)return!1;for(var s=o.x,u=i.x,f=a.x,x=o.y,l=i.y,h=a.y,c=s<u?s<f?s:f:u<f?u:f,v=x<l?x<h?x:h:l<h?l:h,d=s>u?s>f?s:f:u>f?u:f,y=x>l?x>h?x:h:l>h?l:h,p=w(c,v,t,n,r),b=w(d,y,t,n,r),g=e.prevZ,m=e.nextZ;g&&g.z>=p&&m&&m.z<=b;){if(g.x>=c&&g.x<=d&&g.y>=v&&g.y<=y&&g!==o&&g!==a&&E(s,x,u,l,f,h,g.x,g.y)&&Z(g.prev,g,g.next)>=0)return!1;if(g=g.prevZ,m.x>=c&&m.x<=d&&m.y>=v&&m.y<=y&&m!==o&&m!==a&&E(s,x,u,l,f,h,m.x,m.y)&&Z(m.prev,m,m.next)>=0)return!1;m=m.nextZ}for(;g&&g.z>=p;){if(g.x>=c&&g.x<=d&&g.y>=v&&g.y<=y&&g!==o&&g!==a&&E(s,x,u,l,f,h,g.x,g.y)&&Z(g.prev,g,g.next)>=0)return!1;g=g.prevZ}for(;m&&m.z<=b;){if(m.x>=c&&m.x<=d&&m.y>=v&&m.y<=y&&m!==o&&m!==a&&E(s,x,u,l,f,h,m.x,m.y)&&Z(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function y(e,t,n){var r=e;do{var o=r.prev,i=r.next.next;!F(o,i)&&T(o,r,r.next,i)&&z(o,i)&&z(i,o)&&(t.push(o.i/n|0),t.push(r.i/n|0),t.push(i.i/n|0),R(r),R(r.next),r=e=i),r=r.next}while(r!==e);return h(r)}function p(e,t,n,r,o,i){var a=e;do{for(var s=a.next.next;s!==a.prev;){if(a.i!==s.i&&M(a,s)){var u=U(a,s);return a=h(a,a.next),u=h(u,u.next),c(a,t,n,r,o,i,0),void c(u,t,n,r,o,i,0)}s=s.next}a=a.next}while(a!==e)}function b(e,t){return e.x-t.x}function g(e,t){var n=function(e,t){var n,r=t,o=e.x,i=e.y,a=-1/0;do{if(i<=r.y&&i>=r.next.y&&r.next.y!==r.y){var s=r.x+(i-r.y)*(r.next.x-r.x)/(r.next.y-r.y);if(s<=o&&s>a&&(a=s,n=r.x<r.next.x?r:r.next,s===o))return n}r=r.next}while(r!==t);if(!n)return null;var u,f=n,x=n.x,l=n.y,h=1/0;r=n;do{o>=r.x&&r.x>=x&&o!==r.x&&E(i<l?o:a,i,x,l,i<l?a:o,i,r.x,r.y)&&(u=Math.abs(i-r.y)/(o-r.x),z(r,e)&&(u<h||u===h&&(r.x>n.x||r.x===n.x&&m(n,r)))&&(n=r,h=u)),r=r.next}while(r!==f);return n}(e,t);if(!n)return t;var r=U(n,e);return h(r,r.next),h(n,n.next)}function m(e,t){return Z(e.prev,e,t.prev)<0&&Z(t.next,e,e.next)<0}function w(e,t,n,r,o){return(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=(e-n)*o|0)|e<<8))|e<<4))|e<<2))|e<<1))|(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=(t-r)*o|0)|t<<8))|t<<4))|t<<2))|t<<1))<<1}function A(e){var t=e,n=e;do{(t.x<n.x||t.x===n.x&&t.y<n.y)&&(n=t),t=t.next}while(t!==e);return n}function E(e,t,n,r,o,i,a,s){return(o-a)*(t-s)>=(e-a)*(i-s)&&(e-a)*(r-s)>=(n-a)*(t-s)&&(n-a)*(i-s)>=(o-a)*(r-s)}function M(e,t){return e.next.i!==t.i&&e.prev.i!==t.i&&!function(e,t){var n=e;do{if(n.i!==e.i&&n.next.i!==e.i&&n.i!==t.i&&n.next.i!==t.i&&T(n,n.next,e,t))return!0;n=n.next}while(n!==e);return!1}(e,t)&&(z(e,t)&&z(t,e)&&function(e,t){var n=e,r=!1,o=(e.x+t.x)/2,i=(e.y+t.y)/2;do{n.y>i!=n.next.y>i&&n.next.y!==n.y&&o<(n.next.x-n.x)*(i-n.y)/(n.next.y-n.y)+n.x&&(r=!r),n=n.next}while(n!==e);return r}(e,t)&&(Z(e.prev,e,t.prev)||Z(e,t.prev,t))||F(e,t)&&Z(e.prev,e,e.next)>0&&Z(t.prev,t,t.next)>0)}function Z(e,t,n){return(t.y-e.y)*(n.x-t.x)-(t.x-e.x)*(n.y-t.y)}function F(e,t){return e.x===t.x&&e.y===t.y}function T(e,t,n,r){var o=S(Z(e,t,n)),i=S(Z(e,t,r)),a=S(Z(n,r,e)),s=S(Z(n,r,t));return o!==i&&a!==s||(!(0!==o||!I(e,n,t))||(!(0!==i||!I(e,r,t))||(!(0!==a||!I(n,e,r))||!(0!==s||!I(n,t,r)))))}function I(e,t,n){return t.x<=Math.max(e.x,n.x)&&t.x>=Math.min(e.x,n.x)&&t.y<=Math.max(e.y,n.y)&&t.y>=Math.min(e.y,n.y)}function S(e){return e>0?1:e<0?-1:0}function z(e,t){return Z(e.prev,e,e.next)<0?Z(e,t,e.next)>=0&&Z(e,e.prev,t)>=0:Z(e,t,e.prev)<0||Z(e,e.next,t)<0}function U(e,t){var n=new B(e.i,e.x,e.y),r=new B(t.i,t.x,t.y),o=e.next,i=t.prev;return e.next=t,t.prev=e,n.next=o,o.prev=n,r.next=n,n.prev=r,i.next=r,r.prev=i,r}function k(e,t,n,r){var o=new B(e,t,n);return r?(o.next=r.next,o.prev=r,r.next.prev=o,r.next=o):(o.prev=o,o.next=o),o}function R(e){e.next.prev=e.prev,e.prev.next=e.next,e.prevZ&&(e.prevZ.nextZ=e.nextZ),e.nextZ&&(e.nextZ.prevZ=e.prevZ)}function B(e,t,n){this.i=e,this.x=t,this.y=n,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}function P(e,t,n,r){for(var o=0,i=t,a=n-r;i<n;i+=r)o+=(e[a]-e[i])*(e[i+1]+e[a+1]),a=i;return o}f.exports=x,f.exports.default=x,x.deviation=function(e,t,n,r){var o=t&&t.length,i=o?t[0]*n:e.length,a=Math.abs(P(e,0,i,n));if(o)for(var s=0,u=t.length;s<u;s++){var f=t[s]*n,x=s<u-1?t[s+1]*n:e.length;a-=Math.abs(P(e,f,x,n))}var l=0;for(s=0;s<r.length;s+=3){var h=r[s]*n,c=r[s+1]*n,v=r[s+2]*n;l+=Math.abs((e[h]-e[v])*(e[c+1]-e[h+1])-(e[h]-e[c])*(e[v+1]-e[h+1]))}return 0===a&&0===l?0:Math.abs((l-a)/a)},x.flatten=function(e){for(var t=e[0][0].length,n={vertices:[],holes:[],dimensions:t},r=0,o=0;o<e.length;o++){for(var i=0;i<e[o].length;i++)for(var a=0;a<t;a++)n.vertices.push(e[o][i][a]);o>0&&(r+=e[o-1].length,n.holes.push(r))}return n};var N=u(f.exports);const _=[],O={vertexPosition:0,indexPosition:0};function q(e,t,n,r,o){e[t+0]=n,e[t+1]=r,e[t+2]=o}function L(e,t,n,r,o,i){const a=3+o,s=e[t+0],u=e[t+1],f=_;f.length=o;for(let n=0;n<f.length;n++)f[n]=e[t+2+n];let x=i?i.vertexPosition:0,l=i?i.indexPosition:0;const h=x/a;return q(n,x,s,u,0),f.length&&n.set(f,x+3),x+=a,q(n,x,s,u,1),f.length&&n.set(f,x+3),x+=a,q(n,x,s,u,2),f.length&&n.set(f,x+3),x+=a,q(n,x,s,u,3),f.length&&n.set(f,x+3),x+=a,r[l++]=h,r[l++]=h+1,r[l++]=h+3,r[l++]=h+1,r[l++]=h+2,r[l++]=h+3,O.vertexPosition=x,O.indexPosition=l,O}function C(e,t,n,r,o,i,s,u,f,x){const l=5+u.length,h=i.length/l,c=[e[t+0],e[t+1]],v=[e[n],e[n+1]],d=a(x,[...c]),y=a(x,[...v]);function p(e,t,n){const r=1e4;return Math.round(1500*t)+Math.round(1500*n)*r+e*r*r}function b(e,t,n){const r=Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),o=[(t[0]-e[0])/r,(t[1]-e[1])/r],i=[-o[1],o[0]],a=Math.sqrt((n[0]-e[0])*(n[0]-e[0])+(n[1]-e[1])*(n[1]-e[1])),s=[(n[0]-e[0])/a,(n[1]-e[1])/a],u=0===r||0===a?0:Math.acos((f=s[0]*o[0]+s[1]*o[1],x=-1,l=1,Math.min(Math.max(f,x),l)));var f,x,l;return s[0]*i[0]+s[1]*i[1]>0?u:2*Math.PI-u}const g=null!==o;let m=0,w=0;if(null!==r){m=b(d,y,a(x,[...[e[r],e[r+1]]]))}if(g){w=b(y,d,a(x,[...[e[o],e[o+1]]]))}i.push(c[0],c[1],v[0],v[1],p(0,m,w)),i.push(...u),i.push(c[0],c[1],v[0],v[1],p(1,m,w)),i.push(...u),i.push(c[0],c[1],v[0],v[1],p(2,m,w)),i.push(...u),i.push(c[0],c[1],v[0],v[1],p(3,m,w)),i.push(...u),s.push(h,h+1,h+2,h+1,h+3,h+2)}function G(e,t,n,r,o){const i=2+o;let a=t;const s=e.slice(a,a+o);a+=o;const u=e[a++];let f=0;const x=new Array(u-1);for(let t=0;t<u;t++)f+=e[a++],t<u-1&&(x[t]=f);const l=e.slice(a,a+2*f),h=N(l,x,2);for(let e=0;e<h.length;e++)r.push(h[e]+n.length/i);for(let e=0;e<l.length;e+=2)n.push(l[e],l[e+1],...s);return a+2*f}const j=self;j.onmessage=r=>{const o=r.data;switch(o.type){case t:{const e=3,t=2,n=o.customAttributesSize,r=t+n,i=new Float32Array(o.renderInstructions),a=i.length/r,s=4*a*(n+e),u=new Uint32Array(6*a),f=new Float32Array(s);let x;for(let e=0;e<i.length;e+=r)x=L(i,e,f,u,n,x);const l=Object.assign({vertexBuffer:f.buffer,indexBuffer:u.buffer,renderInstructions:i.buffer},o);j.postMessage(l,[f.buffer,u.buffer,i.buffer]);break}case n:{const e=[],t=[],n=o.customAttributesSize,r=2,i=new Float32Array(o.renderInstructions);let a=0;const u=o.renderInstructionsTransform,f=[1,0,0,1,0,0];let x,l;for(s(f,u);a<i.length;){l=Array.from(i.slice(a,a+n)),a+=n,x=i[a++];for(let n=0;n<x-1;n++)C(i,a+n*r,a+(n+1)*r,n>0?a+(n-1)*r:null,n<x-2?a+(n+2)*r:null,e,t,l,0,f);a+=x*r}const h=Uint32Array.from(t),c=Float32Array.from(e),v=Object.assign({vertexBuffer:c.buffer,indexBuffer:h.buffer,renderInstructions:i.buffer},o);j.postMessage(v,[c.buffer,h.buffer,i.buffer]);break}case e:{const e=[],t=[],n=o.customAttributesSize,r=new Float32Array(o.renderInstructions);let i=0;for(;i<r.length;)i=G(r,i,e,t,n);const a=Uint32Array.from(t),s=Float32Array.from(e),u=Object.assign({vertexBuffer:s.buffer,indexBuffer:a.buffer,renderInstructions:r.buffer},o);j.postMessage(u,[s.buffer,a.buffer,r.buffer]);break}}};';
+  return new Worker(typeof Blob > "u" ? "data:application/javascript;base64," + Buffer.from(n, "binary").toString("base64") : URL.createObjectURL(new Blob([n], { type: "application/javascript" })));
+}
+class Ht extends ne {
+  /**
+   * @param {import("../../layer/Layer.js").default} layer Layer.
+   * @param {Options} options Options.
+   */
+  constructor(t, e) {
+    const r = e.uniforms || {}, i = C();
+    r[A.PROJECTION_MATRIX] = i, super(t, {
+      uniforms: r,
+      postProcesses: e.postProcesses
+    }), this.sourceRevision_ = -1, this.verticesBuffer_ = new le(te, $), this.indicesBuffer_ = new le(
+      re,
+      $
+    ), this.vertexShader_ = e.vertexShader, this.fragmentShader_ = e.fragmentShader, this.program_, this.hitDetectionEnabled_ = e.hitDetectionEnabled ?? !0;
+    const s = e.attributes ? e.attributes.map(function(a) {
+      return {
+        name: "a_" + a.name,
+        size: 1,
+        type: F.FLOAT
+      };
+    }) : [];
+    this.attributes = [
+      {
+        name: "a_position",
+        size: 2,
+        type: F.FLOAT
+      },
+      {
+        name: "a_index",
+        size: 1,
+        type: F.FLOAT
+      }
+    ], this.hitDetectionEnabled_ && (this.attributes.push({
+      name: "a_hitColor",
+      size: 4,
+      type: F.FLOAT
+    }), this.attributes.push({
+      name: "a_featureUid",
+      size: 1,
+      type: F.FLOAT
+    })), this.attributes.push(...s), this.customAttributes = e.attributes ? e.attributes : [], this.previousExtent_ = He(), this.currentTransform_ = i, this.renderTransform_ = C(), this.invertRenderTransform_ = C(), this.renderInstructions_ = new Float32Array(0), this.hitRenderTarget_, this.lastSentId = 0, this.worker_ = Zt(), this.worker_.addEventListener(
+      "message",
+      /**
+       * @param {*} event Event.
+       */
+      (a) => {
+        const u = a.data;
+        if (u.type === ge.GENERATE_POINT_BUFFERS) {
+          const h = u.projectionTransform;
+          this.verticesBuffer_.fromArrayBuffer(u.vertexBuffer), this.helper.flushBufferData(this.verticesBuffer_), this.indicesBuffer_.fromArrayBuffer(u.indexBuffer), this.helper.flushBufferData(this.indicesBuffer_), this.renderTransform_ = h, We(
+            this.invertRenderTransform_,
+            this.renderTransform_
+          ), this.renderInstructions_ = new Float32Array(
+            a.data.renderInstructions
+          ), u.id === this.lastSentId && (this.ready = !0), this.getLayer().changed();
+        }
+      }
+    ), this.featureCache_ = {}, this.featureCount_ = 0;
+    const o = this.getLayer().getSource();
+    this.sourceListenKeys_ = [
+      z(
+        o,
+        G.ADDFEATURE,
+        this.handleSourceFeatureAdded_,
+        this
+      ),
+      z(
+        o,
+        G.CHANGEFEATURE,
+        this.handleSourceFeatureChanged_,
+        this
+      ),
+      z(
+        o,
+        G.REMOVEFEATURE,
+        this.handleSourceFeatureDelete_,
+        this
+      ),
+      z(
+        o,
+        G.CLEAR,
+        this.handleSourceFeatureClear_,
+        this
+      )
+    ], o.forEachFeature((a) => {
+      this.featureCache_[L(a)] = {
+        feature: a,
+        properties: a.getProperties(),
+        geometry: a.getGeometry()
+      }, this.featureCount_++;
+    });
+  }
+  afterHelperCreated() {
+    this.program_ = this.helper.getProgram(
+      this.fragmentShader_,
+      this.vertexShader_
+    ), this.hitDetectionEnabled_ && (this.hitRenderTarget_ = new Rt(this.helper));
+  }
+  /**
+   * @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
+   * @private
+   */
+  handleSourceFeatureAdded_(t) {
+    const e = t.feature;
+    this.featureCache_[L(e)] = {
+      feature: e,
+      properties: e.getProperties(),
+      geometry: e.getGeometry()
+    }, this.featureCount_++;
+  }
+  /**
+   * @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
+   * @private
+   */
+  handleSourceFeatureChanged_(t) {
+    const e = t.feature;
+    this.featureCache_[L(e)] = {
+      feature: e,
+      properties: e.getProperties(),
+      geometry: e.getGeometry()
+    };
+  }
+  /**
+   * @param {import("../../source/Vector.js").VectorSourceEvent} event Event.
+   * @private
+   */
+  handleSourceFeatureDelete_(t) {
+    const e = t.feature;
+    delete this.featureCache_[L(e)], this.featureCount_--;
+  }
+  /**
+   * @private
+   */
+  handleSourceFeatureClear_() {
+    this.featureCache_ = {}, this.featureCount_ = 0;
+  }
+  /**
+   * Render the layer.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {HTMLElement} The rendered element.
+   */
+  renderFrame(t) {
+    const e = this.helper.getGL();
+    this.preRender(e, t);
+    const [r, i, s] = this.getWorldParameters_(t);
+    this.renderWorlds(t, !1, r, i, s), this.helper.finalizeDraw(
+      t,
+      this.dispatchPreComposeEvent,
+      this.dispatchPostComposeEvent
+    );
+    const o = this.helper.getCanvas();
+    return this.hitDetectionEnabled_ && (this.renderWorlds(t, !0, r, i, s), this.hitRenderTarget_.clearCachedData()), this.postRender(e, t), o;
+  }
+  /**
+   * Compute world params
+   * @private
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {Array<number>} The world start, end and width.
+   */
+  getWorldParameters_(t) {
+    const e = t.viewState.projection, s = this.getLayer().getSource().getWrapX() && e.canWrapX(), o = e.getExtent(), a = t.extent, u = s ? Xe(o) : null, h = s ? Math.ceil((a[2] - o[2]) / u) + 1 : 1;
+    return [s ? Math.floor((a[0] - o[0]) / u) : 0, h, u];
+  }
+  /**
+   * Determine whether renderFrame should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrameInternal(t) {
+    const e = this.getLayer(), r = e.getSource(), i = t.viewState, s = !t.viewHints[ue.ANIMATING] && !t.viewHints[ue.INTERACTING], o = !ke(this.previousExtent_, t.extent), a = this.sourceRevision_ < r.getRevision();
+    if (a && (this.sourceRevision_ = r.getRevision()), s && (o || a)) {
+      const u = i.projection, h = i.resolution, f = e instanceof ve ? e.getRenderBuffer() : 0, c = Ve(t.extent, f * h);
+      r.loadFeatures(c, h, u), this.rebuildBuffers_(t), this.previousExtent_ = t.extent.slice();
+    }
+    return this.helper.useProgram(this.program_, t), this.helper.prepareDraw(t), this.helper.bindBuffer(this.verticesBuffer_), this.helper.bindBuffer(this.indicesBuffer_), this.helper.enableAttributes(this.attributes), !0;
+  }
+  /**
+   * Rebuild internal webgl buffers based on current view extent; costly, should not be called too much
+   * @param {import("../../Map").FrameState} frameState Frame state.
+   * @private
+   */
+  rebuildBuffers_(t) {
+    const e = C();
+    this.helper.makeProjectionTransform(t, e);
+    const i = (this.hitDetectionEnabled_ ? 7 : 2) + this.customAttributes.length, s = i * this.featureCount_;
+    (!this.renderInstructions_ || this.renderInstructions_.length !== s) && (this.renderInstructions_ = new Float32Array(s));
+    let o, a;
+    const u = [], h = [];
+    let f = -1;
+    for (const l in this.featureCache_)
+      if (o = this.featureCache_[l], a = /** @type {import("../../geom").Point} */
+      o.geometry, !(!a || a.getType() !== "Point")) {
+        if (u[0] = a.getFlatCoordinates()[0], u[1] = a.getFlatCoordinates()[1], he(e, u), this.renderInstructions_[++f] = u[0], this.renderInstructions_[++f] = u[1], this.hitDetectionEnabled_) {
+          const x = Gt(f + 5, h);
+          this.renderInstructions_[++f] = x[0], this.renderInstructions_[++f] = x[1], this.renderInstructions_[++f] = x[2], this.renderInstructions_[++f] = x[3], this.renderInstructions_[++f] = Number(l);
+        }
+        for (let x = 0; x < this.customAttributes.length; x++) {
+          const d = this.customAttributes[x].callback(
+            o.feature,
+            o.properties
+          );
+          this.renderInstructions_[++f] = d;
+        }
+      }
+    const c = {
+      id: ++this.lastSentId,
+      type: ge.GENERATE_POINT_BUFFERS,
+      renderInstructions: this.renderInstructions_.buffer,
+      customAttributesSize: i - 2
+    };
+    c.projectionTransform = e, this.ready = !1, this.worker_.postMessage(c, [this.renderInstructions_.buffer]), this.renderInstructions_ = null;
+  }
+  /**
+   * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
+   * @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  forEachFeatureAtCoordinate(t, e, r, i, s) {
+    if (me(this.hitDetectionEnabled_, 66), !this.renderInstructions_ || !this.hitDetectionEnabled_)
+      return;
+    const o = he(
+      e.coordinateToPixelTransform,
+      t.slice()
+    ), a = this.hitRenderTarget_.readPixel(o[0] / 2, o[1] / 2), u = [a[0] / 255, a[1] / 255, a[2] / 255, a[3] / 255], h = zt(u), f = this.renderInstructions_[h], c = Math.floor(f).toString(), x = this.getLayer().getSource().getFeatureByUid(c);
+    if (x)
+      return i(x, this.getLayer(), null);
+  }
+  /**
+   * Render the world, either to the main framebuffer or to the hit framebuffer
+   * @param {import("../../Map.js").FrameState} frameState current frame state
+   * @param {boolean} forHitDetection whether the rendering is for hit detection
+   * @param {number} startWorld the world to render in the first iteration
+   * @param {number} endWorld the last world to render
+   * @param {number} worldWidth the width of the worlds being rendered
+   */
+  renderWorlds(t, e, r, i, s) {
+    let o = r;
+    this.helper.useProgram(this.program_, t), e && (this.hitRenderTarget_.setSize([
+      Math.floor(t.size[0] / 2),
+      Math.floor(t.size[1] / 2)
+    ]), this.helper.prepareDrawToRenderTarget(
+      t,
+      this.hitRenderTarget_,
+      !0
+    )), this.helper.bindBuffer(this.verticesBuffer_), this.helper.bindBuffer(this.indicesBuffer_), this.helper.enableAttributes(this.attributes);
+    do {
+      this.helper.makeProjectionTransform(t, this.currentTransform_), je(this.currentTransform_, o * s, 0), Ye(this.currentTransform_, this.invertRenderTransform_), this.helper.applyUniforms(t), this.helper.applyHitDetectionUniform(e);
+      const a = this.indicesBuffer_.getSize();
+      this.helper.drawElements(0, a);
+    } while (++o < i);
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.worker_.terminate(), this.layer_ = null, this.sourceListenKeys_.forEach(function(t) {
+      et(t);
+    }), this.sourceListenKeys_ = null, super.disposeInternal();
+  }
+}
+const T = {
+  BLUR: "blur",
+  GRADIENT: "gradient",
+  RADIUS: "radius"
+}, Wt = ["#00f", "#0ff", "#0f0", "#ff0", "#f00"];
+class Xt extends ve {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    t = t || {};
+    const e = Object.assign({}, t);
+    delete e.gradient, delete e.radius, delete e.blur, delete e.weight, super(e), this.gradient_ = null, this.addChangeListener(T.GRADIENT, this.handleGradientChanged_), this.setGradient(t.gradient ? t.gradient : Wt), this.setBlur(t.blur !== void 0 ? t.blur : 15), this.setRadius(t.radius !== void 0 ? t.radius : 8);
+    const r = t.weight ? t.weight : "weight";
+    typeof r == "string" ? this.weightFunction_ = function(i) {
+      return i.get(r);
+    } : this.weightFunction_ = r, this.setRenderOrder(null);
+  }
+  /**
+   * Return the blur size in pixels.
+   * @return {number} Blur size in pixels.
+   * @api
+   * @observable
+   */
+  getBlur() {
+    return (
+      /** @type {number} */
+      this.get(T.BLUR)
+    );
+  }
+  /**
+   * Return the gradient colors as array of strings.
+   * @return {Array<string>} Colors.
+   * @api
+   * @observable
+   */
+  getGradient() {
+    return (
+      /** @type {Array<string>} */
+      this.get(T.GRADIENT)
+    );
+  }
+  /**
+   * Return the size of the radius in pixels.
+   * @return {number} Radius size in pixel.
+   * @api
+   * @observable
+   */
+  getRadius() {
+    return (
+      /** @type {number} */
+      this.get(T.RADIUS)
+    );
+  }
+  /**
+   * @private
+   */
+  handleGradientChanged_() {
+    this.gradient_ = kt(this.getGradient());
+  }
+  /**
+   * Set the blur size in pixels.
+   * @param {number} blur Blur size in pixels.
+   * @api
+   * @observable
+   */
+  setBlur(t) {
+    this.set(T.BLUR, t);
+  }
+  /**
+   * Set the gradient colors as array of strings.
+   * @param {Array<string>} colors Gradient.
+   * @api
+   * @observable
+   */
+  setGradient(t) {
+    this.set(T.GRADIENT, t);
+  }
+  /**
+   * Set the size of the radius in pixels.
+   * @param {number} radius Radius size in pixel.
+   * @api
+   * @observable
+   */
+  setRadius(t) {
+    this.set(T.RADIUS, t);
+  }
+  createRenderer() {
+    return new Ht(this, {
+      className: this.getClassName(),
+      attributes: [
+        {
+          name: "weight",
+          callback: (t) => {
+            const e = this.weightFunction_(t);
+            return e !== void 0 ? tt(e, 0, 1) : 1;
+          }
+        }
+      ],
+      hitDetectionEnabled: !0,
+      vertexShader: `
+        precision mediump float;
+        uniform mat4 u_projectionMatrix;
+        uniform mat4 u_offsetScaleMatrix;
+        uniform float u_size;
+        attribute vec2 a_position;
+        attribute float a_index;
+        attribute float a_weight;
+        attribute vec4 a_hitColor;
+
+        varying vec2 v_texCoord;
+        varying float v_weight;
+        varying vec4 v_hitColor;
+
+        void main(void) {
+          mat4 offsetMatrix = u_offsetScaleMatrix;
+          float offsetX = a_index == 0.0 || a_index == 3.0 ? -u_size / 2.0 : u_size / 2.0;
+          float offsetY = a_index == 0.0 || a_index == 1.0 ? -u_size / 2.0 : u_size / 2.0;
+          vec4 offsets = offsetMatrix * vec4(offsetX, offsetY, 0.0, 0.0);
+          gl_Position = u_projectionMatrix * vec4(a_position, 0.0, 1.0) + offsets;
+          float u = a_index == 0.0 || a_index == 3.0 ? 0.0 : 1.0;
+          float v = a_index == 0.0 || a_index == 1.0 ? 0.0 : 1.0;
+          v_texCoord = vec2(u, v);
+          v_hitColor = a_hitColor;
+          v_weight = a_weight;
+        }`,
+      fragmentShader: `
+        precision mediump float;
+        uniform float u_blurSlope;
+        uniform mediump int u_hitDetection;
+
+        varying vec2 v_texCoord;
+        varying float v_weight;
+        varying vec4 v_hitColor;
+
+        void main(void) {
+          vec2 texCoord = v_texCoord * 2.0 - vec2(1.0, 1.0);
+          float sqRadius = texCoord.x * texCoord.x + texCoord.y * texCoord.y;
+          float value = (1.0 - sqrt(sqRadius)) * u_blurSlope;
+          float alpha = smoothstep(0.0, 1.0, value) * v_weight;
+          gl_FragColor = vec4(alpha, alpha, alpha, alpha);
+          if (u_hitDetection > 0) {
+            if (alpha < 0.05) {
+              discard;
+            }
+            gl_FragColor = v_hitColor;
+          }
+      }`,
+      uniforms: {
+        u_size: () => (this.get(T.RADIUS) + this.get(T.BLUR)) * 2,
+        u_blurSlope: () => this.get(T.RADIUS) / Math.max(1, this.get(T.BLUR))
+      },
+      postProcesses: [
+        {
+          fragmentShader: `
+            precision mediump float;
+
+            uniform sampler2D u_image;
+            uniform sampler2D u_gradientTexture;
+            uniform float u_opacity;
+
+            varying vec2 v_texCoord;
+
+            void main() {
+              vec4 color = texture2D(u_image, v_texCoord);
+              gl_FragColor.a = color.a * u_opacity;
+              gl_FragColor.rgb = texture2D(u_gradientTexture, vec2(0.5, color.a)).rgb;
+              gl_FragColor.rgb *= gl_FragColor.a;
+            }`,
+          uniforms: {
+            u_gradientTexture: () => this.gradient_,
+            u_opacity: () => this.getOpacity()
+          }
+        }
+      ]
+    });
+  }
+  renderDeclutter() {
+  }
+}
+function kt(n) {
+  const r = rt(1, 256), i = r.createLinearGradient(0, 0, 1, 256), s = 1 / (n.length - 1);
+  for (let o = 0, a = n.length; o < a; ++o)
+    i.addColorStop(o * s, n[o]);
+  return r.fillStyle = i, r.fillRect(0, 0, 1, 256), r.canvas;
+}
+const nr = (n) => {
+  const t = Ie({ props: n, name: "HCHeatMap" }), {
+    data: e,
+    payload: r,
+    onPayloadUpdate: i,
+    accessToken: s,
+    gradient: o = it,
+    sx: a,
+    ...u
+  } = t, h = De(), f = w(Be("map-")), c = w(null), l = w(null), x = w(null), d = w(null), b = w(), [S, N] = nt(!1), O = () => {
+    if (!S || !c.current || !e || !x.current) return;
+    const v = new at(), E = e.map((y) => Me(y.variables.geometry)[0]).filter((y) => {
       try {
-        return N(n), !0;
+        return ot(y), !0;
       } catch {
         return !1;
       }
     }).map(
-      (n) => e.readFeature(n, {
+      (y) => v.readFeature(y, {
         dataProjection: "EPSG:4326",
         featureProjection: "EPSG:3857"
       })
     );
-    m.current.clear(), m.current.addFeatures(t);
-  }, y = () => {
-    var t;
-    if (!r.current) return;
-    const e = (t = r.current) == null ? void 0 : t.getBoundingBox(), o = {
-      ...s,
-      boundingBox: e
+    x.current.clear(), x.current.addFeatures(E);
+  }, _ = () => {
+    var E;
+    if (!c.current) return;
+    const v = (E = c.current) == null ? void 0 : E.getBoundingBox(), m = {
+      ...r,
+      boundingBox: v
     };
-    E(o);
-  }, G = () => {
-    l.current && clearTimeout(l.current), l.current = setTimeout(() => {
-      var e;
-      (e = r.current) == null || e.updateSize(), c.current && c.current.map.resize();
+    i(m);
+  }, g = () => {
+    b.current && clearTimeout(b.current), b.current = setTimeout(() => {
+      var v;
+      (v = c.current) == null || v.updateSize(), l.current && l.current.map.resize();
     }, 100);
-  }, k = () => {
-    var e, o;
-    (e = r.current) == null || e.on("movestart", () => {
-      a.current && (clearTimeout(a.current), a.current = null);
-    }), (o = r.current) == null || o.on("moveend", () => {
-      a.current && (clearTimeout(a.current), a.current = null), a.current = setTimeout(y, 500);
+  }, Le = () => {
+    var v, m;
+    (v = c.current) == null || v.on("movestart", () => {
+      d.current && (clearTimeout(d.current), d.current = null);
+    }), (m = c.current) == null || m.on("moveend", () => {
+      d.current && (clearTimeout(d.current), d.current = null), d.current = setTimeout(_, 500);
     });
-  }, B = () => {
-    var f, S;
-    const e = p.palette.mode === "light" ? "mapbox://styles/mapbox/light-v11" : "mapbox://styles/mapbox/dark-v11", o = J({
-      id: g.current,
+  }, Se = () => {
+    var j, ie;
+    const v = h.palette.mode === "light" ? "mapbox://styles/mapbox/light-v11" : "mapbox://styles/mapbox/dark-v11", m = st({
+      id: f.current,
       center: [0, 0],
-      style: e,
-      accessToken: P
+      style: v,
+      accessToken: s
     });
-    (f = r.current) == null || f.addLayer(o.layer), c.current = o;
-    const t = new A(), n = new U({
-      source: t,
-      gradient: [...x].reverse()
+    (j = c.current) == null || j.addLayer(m.layer), l.current = m;
+    const E = new Oe(), y = new Xt({
+      source: E,
+      gradient: [...o].reverse()
     });
-    if ((S = r.current) == null || S.addLayer(n), m.current = t, I(!0), k(), y(), s != null && s.boundingBox && r.current) {
-      const { bottomLeft: T, topRight: M } = s.boundingBox, H = [
-        T.longitude,
-        T.latitude,
-        M.longitude,
-        M.latitude
-      ], q = V(H, "EPSG:4326", "EPSG:3857");
-      r.current.centerToExtent(q);
-    }
-  }, z = () => {
-    var t, n;
-    if (!c.current) return;
-    const e = p.palette.mode === "light" ? "mapbox://styles/mapbox/light-v11" : "mapbox://styles/mapbox/dark-v11", o = ((n = (t = c.current.layer.getSource()) == null ? void 0 : t.getMapboxMap) == null ? void 0 : n.call(t)) || c.current.map;
-    o && o.setStyle(e);
+    if ((ie = c.current) == null || ie.addLayer(y), x.current = E, N(!0), Le(), _(), r != null && r.boundingBox && c.current) {
+      const { bottomLeft: se, topRight: oe } = r.boundingBox, Ue = [
+        se.longitude,
+        se.latitude,
+        oe.longitude,
+        oe.latitude
+      ], we = Ke(Ue, "EPSG:4326", "EPSG:3857");
+      c.current.centerToExtent(we);
+    }
+  }, Ce = () => {
+    var E, y;
+    if (!l.current) return;
+    const v = h.palette.mode === "light" ? "mapbox://styles/mapbox/light-v11" : "mapbox://styles/mapbox/dark-v11", m = ((y = (E = l.current.layer.getSource()) == null ? void 0 : E.getMapboxMap) == null ? void 0 : y.call(E)) || l.current.map;
+    m && m.setStyle(v);
   };
-  h(() => (L(), () => {
-  }), [i, b]), h(() => (z(), () => {
-  }), [p.palette.mode]);
-  const D = { ...d };
+  ce(() => (O(), () => {
+  }), [e, S]), ce(() => (Ce(), () => {
+  }), [h.palette.mode]);
+  const Pe = { ...t };
   return {
-    refs: { mapRef: r, mapId: g },
-    actions: { onInit: B, onMapResize: G },
-    gradient: x,
-    ownerState: D,
-    sx: w,
-    other: R
+    refs: { mapRef: c, mapId: f },
+    actions: { onInit: Se, onMapResize: g },
+    gradient: o,
+    ownerState: Pe,
+    sx: a,
+    other: u
   };
 };
 export {
-  ae as useHeatMapLogic
+  nr as useHeatMapLogic
 };