@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/VectorTileLayerView2D-bd3971cd.js

@@ -0,0 +1,2108 @@
+import { U as Ee, a as $e, cJ as re, c$ as ze, fc as Ve, bO as Fe, n as M, i as j, dL as oe, jC as Ce, ao as qe, aG as F, hX as He, Q as U, gS as ne, f6 as Be, f7 as Ne, f9 as We, g2 as Qe, fd as z, jD as Je, hc as Ke, cZ as Re, z as ae, a3 as Ge, h as Ye, x as $, G as je, s as le, m as he, bz as Xe, a$ as Ze, e as ce, y as et, c as tt } from "./index-6ebf29c1.js";
+import { m as st, p as it } from "./diffUtils-54c1c039.js";
+import { E as L, I as v } from "./enums-25d066fc.js";
+import { t as A } from "./Rect-894f011c.js";
+import { G as rt, D as Le, F as C, I as k, O as ue, R as B } from "./enums-2c166c09.js";
+import { e as Pe, m as Ae } from "./Texture-b1727861.js";
+import { n as X } from "./pbf-0b9b579c.js";
+import { i as ot } from "./rasterizingUtils-80de9b14.js";
+import { e as nt } from "./LRUCache-fc532e9b.js";
+import { w as at, d as lt } from "./GeometryUtils-058e30f4.js";
+import { h as R } from "./BufferObject-22d914df.js";
+import { o as E } from "./VertexArrayObject-08a9d938.js";
+import { e as Q, t as ht, c as ct } from "./config-61215215.js";
+import { r as Me } from "./WGLContainer-f05c906a.js";
+import { n as ut, l as O, r as yt, i as Z, a as D } from "./StyleDefinition-f4862d5a.js";
+import { E as N } from "./Container-f931e682.js";
+import { i as dt } from "./TileContainer-ab77d7a6.js";
+import { s as _t } from "./PooledRBush-e4cbf810.js";
+import { e as ye, s as de } from "./SourceLayerData-ec8ab72c.js";
+import { L as ft, l as _e } from "./StyleRepository-2f08de17.js";
+import { m as pt, u as gt } from "./LayerView-e41297e4.js";
+import "vue";
+import "./floatRGBA-005cc596.js";
+import "./constants-5bd557fe.js";
+import "./MemCache-0861cc28.js";
+import "./definitions-a00a3a6c.js";
+import "./LabelMetric-ee740bd1.js";
+import "./enums-fa8f05ab.js";
+import "./Program-ed5a5aa3.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-976cfde1.js";
+import "./earcut-ffaa9a50.js";
+import "./featureConversionUtils-a5f0b9b2.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./parser-7a76caf9.js";
+import "./highlightReasons-b0f772b2.js";
+import "./colorUtils-6d5e716b.js";
+import "./vec42-27060a00.js";
+import "./vec4f64-043e974c.js";
+import "./scaleUtils-ba5596ad.js";
+let V = class {
+  constructor(e, s) {
+    this._width = 0, this._height = 0, this._free = [], this._width = e, this._height = s, this._free.push(new A(0, 0, e, s));
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  allocate(e, s) {
+    if (e > this._width || s > this._height)
+      return new A();
+    let t = null, i = -1;
+    for (let r = 0; r < this._free.length; ++r) {
+      const o = this._free[r];
+      e <= o.width && s <= o.height && (t === null || o.y <= t.y && o.x <= t.x) && (t = o, i = r);
+    }
+    return t === null ? new A() : (this._free.splice(i, 1), t.width < t.height ? (t.width > e && this._free.push(new A(t.x + e, t.y, t.width - e, s)), t.height > s && this._free.push(new A(t.x, t.y + s, t.width, t.height - s))) : (t.width > e && this._free.push(new A(t.x + e, t.y, t.width - e, t.height)), t.height > s && this._free.push(new A(t.x, t.y + s, e, t.height - s))), new A(t.x, t.y, e, s));
+  }
+  release(e) {
+    for (let s = 0; s < this._free.length; ++s) {
+      const t = this._free[s];
+      if (t.y === e.y && t.height === e.height && t.x + t.width === e.x)
+        t.width += e.width;
+      else if (t.x === e.x && t.width === e.width && t.y + t.height === e.y)
+        t.height += e.height;
+      else if (e.y === t.y && e.height === t.height && e.x + e.width === t.x)
+        t.x = e.x, t.width += e.width;
+      else {
+        if (e.x !== t.x || e.width !== t.width || e.y + e.height !== t.y)
+          continue;
+        t.y = e.y, t.height += e.height;
+      }
+      this._free.splice(s, 1), this.release(e);
+    }
+    this._free.push(e);
+  }
+}, fe = class {
+  constructor(e, s, t) {
+    this.width = 0, this.height = 0, this._dirties = [], this._glyphData = [], this._currentPage = 0, this._glyphIndex = {}, this._textures = [], this._rangePromises = /* @__PURE__ */ new Map(), this.width = e, this.height = s, this._glyphSource = t, this._binPack = new V(e - 4, s - 4), this._glyphData.push(new Uint8Array(e * s)), this._dirties.push(!0), this._textures.push(void 0);
+  }
+  getGlyphItems(e, s) {
+    const t = [], i = this._glyphSource, r = /* @__PURE__ */ new Set(), o = 1 / 256;
+    for (const a of s) {
+      const l = Math.floor(a * o);
+      r.add(l);
+    }
+    const n = [];
+    return r.forEach((a) => {
+      const l = e + a;
+      if (this._rangePromises.has(l))
+        n.push(this._rangePromises.get(l));
+      else {
+        const c = i.getRange(e, a).then(() => {
+          this._rangePromises.delete(l);
+        }, () => {
+          this._rangePromises.delete(l);
+        });
+        this._rangePromises.set(l, c), n.push(c);
+      }
+    }), Promise.all(n).then(() => {
+      let a = this._glyphIndex[e];
+      a || (a = {}, this._glyphIndex[e] = a);
+      for (const l of s) {
+        const c = a[l];
+        if (c) {
+          t[l] = { sdf: !0, rect: c.rect, metrics: c.metrics, page: c.page, code: l };
+          continue;
+        }
+        const y = i.getGlyph(e, l);
+        if (!(y != null && y.metrics))
+          continue;
+        const d = y.metrics;
+        let u;
+        if (d.width === 0)
+          u = new A(0, 0, 0, 0);
+        else {
+          const f = d.width + 6, g = d.height + 2 * 3;
+          let p = f % 4 ? 4 - f % 4 : 4, m = g % 4 ? 4 - g % 4 : 4;
+          p === 1 && (p = 5), m === 1 && (m = 5), u = this._binPack.allocate(f + p, g + m), u.isEmpty && (this._dirties[this._currentPage] || (this._glyphData[this._currentPage] = null), this._currentPage = this._glyphData.length, this._glyphData.push(new Uint8Array(this.width * this.height)), this._dirties.push(!0), this._textures.push(void 0), this._binPack = new V(this.width - 4, this.height - 4), u = this._binPack.allocate(f + p, g + m));
+          const b = this._glyphData[this._currentPage], S = y.bitmap;
+          let I, w;
+          if (S)
+            for (let x = 0; x < g; x++) {
+              I = f * x, w = this.width * (u.y + x + 1) + u.x;
+              for (let P = 0; P < f; P++)
+                b[w + P + 1] = S.at(I + P);
+            }
+        }
+        a[l] = { rect: u, metrics: d, tileIDs: null, page: this._currentPage }, t[l] = { sdf: !0, rect: u, metrics: d, page: this._currentPage, code: l }, this._dirties[this._currentPage] = !0;
+      }
+      return t;
+    });
+  }
+  removeGlyphs(e) {
+    for (const s in this._glyphIndex) {
+      const t = this._glyphIndex[s];
+      if (!t)
+        continue;
+      let i;
+      for (const r in t)
+        if (i = t[r], i.tileIDs.delete(e), i.tileIDs.size === 0) {
+          const o = this._glyphData[i.page], n = i.rect;
+          let a, l;
+          for (let c = 0; c < n.height; c++)
+            for (a = this.width * (n.y + c) + n.x, l = 0; l < n.width; l++)
+              o[a + l] = 0;
+          delete t[r], this._dirties[i.page] = !0;
+        }
+    }
+  }
+  bind(e, s, t, i = 0) {
+    if (!this._textures[t]) {
+      const o = new Pe();
+      o.pixelFormat = rt.ALPHA, o.wrapMode = Le.CLAMP_TO_EDGE, o.width = this.width, o.height = this.height, this._textures[t] = new Ae(e, o, new Uint8Array(this.width * this.height));
+    }
+    const r = this._textures[t];
+    r.setSamplingMode(s), this._dirties[t] && r.setData(this._glyphData[t]), e.bindTexture(r, i), this._dirties[t] = !1;
+  }
+  destroy() {
+    this.dispose();
+  }
+  dispose() {
+    this._glyphData.length = 0, this._binPack = null;
+    for (const e of this._textures)
+      e && e.dispose();
+    this._textures.length = 0;
+  }
+}, G = class {
+  constructor(e) {
+    if (this._metrics = [], !e)
+      return void (this._allBitmaps = null);
+    const s = /* @__PURE__ */ new Map();
+    let t = 0;
+    for (; e.next(); )
+      switch (e.tag()) {
+        case 1: {
+          const o = e.getMessage();
+          for (; o.next(); )
+            switch (o.tag()) {
+              case 3: {
+                const n = o.getMessage();
+                let a, l, c, y, d, u, _;
+                for (; n.next(); )
+                  switch (n.tag()) {
+                    case 1:
+                      a = n.getUInt32();
+                      break;
+                    case 2:
+                      l = n.getBytes();
+                      break;
+                    case 3:
+                      c = n.getUInt32();
+                      break;
+                    case 4:
+                      y = n.getUInt32();
+                      break;
+                    case 5:
+                      d = n.getSInt32();
+                      break;
+                    case 6:
+                      u = n.getSInt32();
+                      break;
+                    case 7:
+                      _ = n.getUInt32();
+                      break;
+                    default:
+                      n.skip();
+                  }
+                if (n.release(), a) {
+                  const f = (l == null ? void 0 : l.length) ?? 0;
+                  this._metrics[a] = { width: c, height: y, left: d, top: u, advance: _, startOffset: t, length: f }, s.set(a, l), t += f;
+                }
+                break;
+              }
+              default:
+                o.skip();
+            }
+          o.release();
+          break;
+        }
+        default:
+          e.skip();
+      }
+    const i = new Uint8Array(t), r = this._metrics;
+    for (const [o, n] of s) {
+      const { startOffset: a, length: l } = r[o];
+      if (n)
+        for (let c = 0; c < l; ++c)
+          i[a + c] = n[c];
+    }
+    this._allBitmaps = i;
+  }
+  getMetrics(e) {
+    return this._metrics[e];
+  }
+  getBitmap(e) {
+    if (!this._allBitmaps)
+      return;
+    const s = this._metrics[e];
+    if (s === void 0)
+      return;
+    const { startOffset: t, length: i } = s;
+    return i !== 0 ? new bt(this._allBitmaps, t, i) : void 0;
+  }
+}, mt = class {
+  constructor() {
+    this._ranges = [];
+  }
+  get ranges() {
+    return this._ranges;
+  }
+  getRange(e) {
+    return this._ranges[e];
+  }
+  addRange(e, s) {
+    this._ranges[e] = s;
+  }
+}, pe = class {
+  constructor(e) {
+    this._glyphInfo = {}, this._baseURL = e;
+  }
+  getRange(e, s) {
+    const t = this._getFontStack(e);
+    if (t.getRange(s))
+      return Promise.resolve();
+    const i = 256 * s, r = i + 255;
+    if (this._baseURL) {
+      const o = this._baseURL.replace("{fontstack}", e).replace("{range}", i + "-" + r);
+      return Ee(o, { responseType: "array-buffer" }).then((n) => {
+        t.addRange(s, new G(new X(new Uint8Array(n.data), new DataView(n.data))));
+      }).catch(() => {
+        t.addRange(s, new G());
+      });
+    }
+    return t.addRange(s, new G()), Promise.resolve();
+  }
+  getGlyph(e, s) {
+    const t = this._getFontStack(e);
+    if (!t)
+      return;
+    const i = Math.floor(s / 256), r = t.getRange(i);
+    return r ? { metrics: r.getMetrics(s), bitmap: r.getBitmap(s) } : void 0;
+  }
+  _getFontStack(e) {
+    let s = this._glyphInfo[e];
+    return s || (s = this._glyphInfo[e] = new mt()), s;
+  }
+}, bt = class {
+  constructor(e, s, t) {
+    this._array = e, this._start = s, this.length = t;
+  }
+  at(e) {
+    return 0 <= e && e < this.length ? this._array[this._start + e] : void 0;
+  }
+};
+const wt = "dasharray-";
+let ge = class Oe {
+  constructor(e, s, t = 0) {
+    this._size = [], this._mosaicsData = [], this._textures = [], this._dirties = [], this._maxItemSize = 0, this._currentPage = 0, this._pageWidth = 0, this._pageHeight = 0, this._mosaicRects = {}, this.pixelRatio = 1, (e <= 0 || s <= 0) && console.error("Sprites mosaic defaultWidth and defaultHeight must be greater than zero!"), this._pageWidth = e, this._pageHeight = s, t > 0 && (this._maxItemSize = t), this._binPack = new V(e - 4, s - 4);
+  }
+  destroy() {
+    this.dispose();
+  }
+  dispose() {
+    this._binPack = null, this._mosaicsData.length = 0, this._mosaicRects = {};
+    for (const e of this._textures)
+      e && e.dispose();
+    this._textures.length = 0;
+  }
+  getWidth(e) {
+    return e >= this._size.length ? -1 : this._size[e][0];
+  }
+  getHeight(e) {
+    return e >= this._size.length ? -1 : this._size[e][1];
+  }
+  getPageSize(e) {
+    return e >= this._size.length ? null : this._size[e];
+  }
+  setSpriteSource(e) {
+    if (this.dispose(), this.pixelRatio = e.devicePixelRatio, this._mosaicsData.length === 0) {
+      this._binPack = new V(this._pageWidth - 4, this._pageHeight - 4);
+      const s = Math.floor(this._pageWidth), t = Math.floor(this._pageHeight), i = new Uint32Array(s * t);
+      this._mosaicsData[0] = i, this._dirties.push(!0), this._size.push([this._pageWidth, this._pageHeight]), this._textures.push(void 0);
+    }
+    this._sprites = e;
+  }
+  getSpriteItem(e, s = !1) {
+    let t, i, r = this._mosaicRects[e];
+    if (r)
+      return r;
+    if (!this._sprites || this._sprites.loadStatus !== "loaded" || (e && e.startsWith(wt) ? ([t, i] = this._rasterizeDash(e), s = !0) : t = this._sprites.getSpriteInfo(e), !(t != null && t.width) || !t.height || t.width < 0 || t.height < 0))
+      return null;
+    const o = t.width, n = t.height, [a, l, c] = this._allocateImage(o, n);
+    return a.width <= 0 ? null : (this._copy(a, t, l, c, s, i), r = { type: "sprite", rect: a, width: o, height: n, sdf: t.sdf, simplePattern: !1, rasterizationScale: t.pixelRatio, page: l }, this._mosaicRects[e] = r, r);
+  }
+  getSpriteItems(e) {
+    const s = {};
+    for (const t of e)
+      s[t.name] = this.getSpriteItem(t.name, t.repeat);
+    return s;
+  }
+  getMosaicItemPosition(e, s) {
+    const t = this.getSpriteItem(e, s), i = t && t.rect;
+    if (!i)
+      return null;
+    i.width = t.width, i.height = t.height;
+    const r = t.width, o = t.height, n = 2;
+    return { tl: [i.x + n, i.y + n], br: [i.x + n + r, i.y + n + o], page: t.page };
+  }
+  bind(e, s, t = 0, i = 0) {
+    if (t >= this._size.length || t >= this._mosaicsData.length)
+      return;
+    if (!this._textures[t]) {
+      const o = new Pe();
+      o.wrapMode = Le.CLAMP_TO_EDGE, o.width = this._size[t][0], o.height = this._size[t][1], this._textures[t] = new Ae(e, o, new Uint8Array(this._mosaicsData[t].buffer));
+    }
+    const r = this._textures[t];
+    r.setSamplingMode(s), this._dirties[t] && r.setData(new Uint8Array(this._mosaicsData[t].buffer)), e.bindTexture(r, i), this._dirties[t] = !1;
+  }
+  static _copyBits(e, s, t, i, r, o, n, a, l, c, y) {
+    let d = i * s + t, u = a * o + n;
+    if (y) {
+      u -= o;
+      for (let _ = -1; _ <= c; _++, d = ((_ + c) % c + i) * s + t, u += o)
+        for (let f = -1; f <= l; f++)
+          r[u + f] = e[d + (f + l) % l];
+    } else
+      for (let _ = 0; _ < c; _++) {
+        for (let f = 0; f < l; f++)
+          r[u + f] = e[d + f];
+        d += s, u += o;
+      }
+  }
+  _copy(e, s, t, i, r, o) {
+    if (!this._sprites || this._sprites.loadStatus !== "loaded" || t >= this._mosaicsData.length)
+      return;
+    const n = new Uint32Array(o ? o.buffer : this._sprites.image.buffer), a = this._mosaicsData[t];
+    a && n || console.error("Source or target images are uninitialized!");
+    const l = 2, c = o ? s.width : this._sprites.width;
+    Oe._copyBits(n, c, s.x, s.y, a, i[0], e.x + l, e.y + l, s.width, s.height, r), this._dirties[t] = !0;
+  }
+  _allocateImage(e, s) {
+    e += 2, s += 2;
+    const t = Math.max(e, s);
+    if (this._maxItemSize && this._maxItemSize < t) {
+      const n = new A(0, 0, e, s);
+      return this._mosaicsData.push(new Uint32Array(e * s)), this._dirties.push(!0), this._size.push([e, s]), this._textures.push(void 0), [n, this._mosaicsData.length - 1, [e, s]];
+    }
+    let i = e % 4 ? 4 - e % 4 : 4, r = s % 4 ? 4 - s % 4 : 4;
+    i === 1 && (i = 5), r === 1 && (r = 5);
+    const o = this._binPack.allocate(e + i, s + r);
+    return o.width <= 0 ? (this._dirties[this._currentPage] || (this._mosaicsData[this._currentPage] = null), this._currentPage = this._mosaicsData.length, this._mosaicsData.push(new Uint32Array(this._pageWidth * this._pageHeight)), this._dirties.push(!0), this._size.push([this._pageWidth, this._pageHeight]), this._textures.push(void 0), this._binPack = new V(this._pageWidth - 4, this._pageHeight - 4), this._allocateImage(e, s)) : [o, this._currentPage, [this._pageWidth, this._pageHeight]];
+  }
+  _rasterizeDash(e) {
+    const s = /\[(.*?)\]/, t = e.match(s);
+    if (!t)
+      return null;
+    const i = t[1].split(",").map(Number), r = e.slice(e.lastIndexOf("-") + 1), [o, n, a] = ot(i, r);
+    return [{ x: 0, y: 0, width: n, height: a, sdf: !0, pixelRatio: 1 }, new Uint8Array(o.buffer)];
+  }
+}, St = class {
+  constructor(e, s, t, i) {
+    this._layer = e, this._styleRepository = s, this.devicePixelRatio = t, this._sourceDataMaxLOD = i, this._spriteMosaic = null, this._glyphMosaic = null, this._connection = null, this._spriteSourceAbortController = null, this._startOptionsInputSignal = null, this._inputSignalEventListener = null;
+  }
+  destroy() {
+    var e, s, t;
+    (e = this._connection) == null || e.close(), this._connection = null, this._styleRepository = null, this._layer = null, (s = this._spriteMosaic) == null || s.destroy(), this._spriteMosaic = null, this._glyphMosaic = null, this._spriteSourceAbortController = $e(this._spriteSourceAbortController), this._spriteSourcePromise = null, this._inputSignalEventListener && ((t = this._startOptionsInputSignal) == null || t.removeEventListener("abort", this._inputSignalEventListener)), this._startOptionsInputSignal = null, this._inputSignalEventListener = null;
+  }
+  get spriteMosaic() {
+    return this._spriteSourcePromise.then(() => this._spriteMosaic);
+  }
+  get glyphMosaic() {
+    return this._glyphMosaic;
+  }
+  async start(e) {
+    this._requestSprite(e);
+    const s = this._layer.currentStyleInfo.glyphsUrl, t = new pe(s ? re(s, { ...this._layer.customParameters, token: this._layer.apiKey }) : null);
+    this._glyphMosaic = new fe(1024, 1024, t), this._broadcastPromise = ze("WorkerTileHandler", { client: this, schedule: e.schedule, signal: e.signal }).then((i) => {
+      var r;
+      if (this._layer && ((r = this._connection) == null || r.close(), this._connection = i, this._layer && !this._connection.closed)) {
+        const o = i.broadcast("setStyle", { style: this._layer.currentStyleInfo.style, sourceDataMaxLOD: this._sourceDataMaxLOD }, e);
+        Promise.all(o).catch((n) => Ve(n));
+      }
+    });
+  }
+  _requestSprite(e) {
+    var o, n;
+    (o = this._spriteSourceAbortController) == null || o.abort();
+    const s = new AbortController();
+    this._spriteSourceAbortController = s;
+    const t = e == null ? void 0 : e.signal;
+    this._inputSignalEventListener && ((n = this._startOptionsInputSignal) == null || n.removeEventListener("abort", this._inputSignalEventListener)), this._startOptionsInputSignal = null, t && (this._inputSignalEventListener = xt(s), t.addEventListener("abort", this._inputSignalEventListener, { once: !0 }));
+    const { signal: i } = s, r = { ...e, signal: i };
+    this._spriteSourcePromise = this._layer.loadSpriteSource(this.devicePixelRatio, r), this._spriteSourcePromise.then((a) => {
+      Fe(i), this._spriteMosaic = new ge(1024, 1024, 250), this._spriteMosaic.setSpriteSource(a);
+    });
+  }
+  async updateStyle(e) {
+    return await this._broadcastPromise, this._broadcastPromise = Promise.all(this._connection.broadcast("updateStyle", e)), this._broadcastPromise;
+  }
+  setSpriteSource(e) {
+    const s = new ge(1024, 1024, 250);
+    return s.setSpriteSource(e), this._spriteMosaic = s, this._spriteSourcePromise = Promise.resolve(e), this._spriteSourceAbortController = null, s;
+  }
+  async setStyle(e, s, t) {
+    await this._broadcastPromise, this._styleRepository = e, this._sourceDataMaxLOD = t, this._requestSprite();
+    const i = new pe(this._layer.currentStyleInfo.glyphsUrl ? re(this._layer.currentStyleInfo.glyphsUrl, { ...this._layer.customParameters, token: this._layer.apiKey }) : null);
+    return this._glyphMosaic = new fe(1024, 1024, i), this._broadcastPromise = Promise.all(this._connection.broadcast("setStyle", { style: s, sourceDataMaxLOD: this._sourceDataMaxLOD })), this._broadcastPromise;
+  }
+  async fetchTileData(e, s) {
+    const t = await this._getRefKeys(e, s);
+    return this._getSourcesData(Object.keys(this._layer.sourceNameToSource), t, s);
+  }
+  async fetchTilePBFs(e) {
+    const s = Object.keys(this._layer.sourceNameToSource), t = {}, i = await this._getRefKeys(e, t), r = [], o = [];
+    for (let n = 0; n < i.length; n++)
+      if (i[n].value == null || s[n] == null)
+        o.push(null);
+      else {
+        const a = i[n].value, l = this._getTilePayload(a, s[n], t);
+        l.then((c) => {
+          r.push({ ...c, key: a });
+        }), o.push(l);
+      }
+    return Promise.all(o).then(() => r);
+  }
+  async parseTileData(e, s) {
+    const t = e && e.data;
+    if (!t)
+      return null;
+    const { sourceName2DataAndRefKey: i, transferList: r } = t;
+    return Object.keys(i).length === 0 ? null : this._broadcastPromise.then(() => this._connection.invoke("createTileAndParse", { key: e.key.id, sourceName2DataAndRefKey: i, styleLayerUIDs: e.styleLayerUIDs }, { ...s, transferList: r }));
+  }
+  async getSprites(e) {
+    return await this._spriteSourcePromise, this._spriteMosaic.getSpriteItems(e);
+  }
+  getGlyphs(e) {
+    return this._glyphMosaic.getGlyphItems(e.font, e.codePoints);
+  }
+  async _getTilePayload(e, s, t) {
+    const i = M.pool.acquire(e.id), r = this._layer.sourceNameToSource[s], { level: o, row: n, col: a } = i;
+    M.pool.release(i);
+    try {
+      return { protobuff: await r.requestTile(o, n, a, t), sourceName: s };
+    } catch (l) {
+      if (j(l))
+        throw l;
+      return { protobuff: null, sourceName: s };
+    }
+  }
+  async _getRefKeys(e, s) {
+    const t = this._layer.sourceNameToSource, i = new Array();
+    for (const r in t) {
+      const o = t[r].getRefKey(e, s);
+      i.push(o);
+    }
+    return oe(i);
+  }
+  _getSourcesData(e, s, t) {
+    const i = [];
+    for (let r = 0; r < s.length; r++)
+      if (s[r].value == null || e[r] == null)
+        i.push(null);
+      else {
+        const o = s[r].value, n = this._getTilePayload(o, e[r], t);
+        i.push(n);
+      }
+    return oe(i).then((r) => {
+      const o = {}, n = [];
+      for (let a = 0; a < r.length; a++) {
+        const l = r[a].value;
+        if (l && l.protobuff && l.protobuff.byteLength > 0) {
+          const c = s[a].value.id;
+          o[l.sourceName] = { refKey: c, protobuff: l.protobuff }, n.push(l.protobuff);
+        }
+      }
+      return { sourceName2DataAndRefKey: o, transferList: n };
+    });
+  }
+};
+function xt(h) {
+  return () => h.abort();
+}
+const me = 512, It = 1e-6, Tt = (h, e) => h + 1 / (1 << 2 * e);
+let be = class {
+  constructor(e, s) {
+    this._tiles = /* @__PURE__ */ new Map(), this._tileCache = new nt(40, (t) => t.dispose()), this._viewSize = [0, 0], this._visibleTiles = /* @__PURE__ */ new Map(), this.acquireTile = e.acquireTile, this.releaseTile = e.releaseTile, this.tileInfoView = e.tileInfoView, this._container = s;
+  }
+  destroy() {
+    for (const [e, s] of this._tiles)
+      s.dispose();
+    this._tiles = null, this._tileCache.clear(), this._tileCache = null;
+  }
+  update(e) {
+    this._updateCacheSize(e);
+    const s = this.tileInfoView, t = s.getTileCoverage(e.state, 0, !0, "smallest");
+    if (!t)
+      return !0;
+    const { spans: i, lodInfo: r } = t, { level: o } = r, n = this._tiles, a = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set();
+    for (const { row: y, colFrom: d, colTo: u } of i)
+      for (let _ = d; _ <= u; _++) {
+        const f = M.getId(o, y, r.normalizeCol(_), r.getWorldForColumn(_)), g = this._getOrAcquireTile(f);
+        a.add(f), g.processed() ? this._addToContainer(g) : l.add(new M(f));
+      }
+    for (const [y, d] of n)
+      d.isCoverage = a.has(y);
+    for (const y of l)
+      this._findPlaceholdersForMissingTiles(y, a);
+    let c = !1;
+    for (const [y, d] of n)
+      d.neededForCoverage = a.has(y), d.neededForCoverage || d.isHoldingForFade && s.intersects(t, d.key) && a.add(y), d.isFading && (c = !0);
+    for (const [y, d] of this._tiles)
+      a.has(y) || this._releaseTile(y);
+    return Ce.pool.release(t), !c;
+  }
+  clear() {
+    this._tiles.clear(), this._tileCache.clear(), this._visibleTiles.clear();
+  }
+  clearCache() {
+    this._tileCache.clear();
+  }
+  getIntersectingTiles(e, s, t, i, r) {
+    const o = [0, 0], n = [0, 0];
+    i.toMap(o, e - t, s + t), i.toMap(n, e + t, s - t);
+    const a = Math.min(o[0], n[0]), l = Math.min(o[1], n[1]), c = Math.max(o[0], n[0]), y = Math.max(o[1], n[1]), d = qe(a, l, c, y), u = F(), _ = [];
+    for (const [f, g] of this._visibleTiles)
+      this.tileInfoView.getTileBounds(u, g.key), He(d, u) && _.push(g);
+    if (r != null && r.length > 0) {
+      const f = new Set(_.map((p) => p.id)), g = r.filter((p) => !f.has(p.tileKey.id)).map((p) => this._visibleTiles.get(p.tileKey.id)).filter((p) => p !== void 0);
+      _.push(...g);
+    }
+    return _;
+  }
+  _findPlaceholdersForMissingTiles(e, s) {
+    const t = [];
+    for (const [r, o] of this._tiles)
+      this._addPlaceholderChild(t, o, e, s);
+    const i = t.reduce(Tt, 0);
+    Math.abs(1 - i) < It || this._addPlaceholderParent(e.id, s);
+  }
+  _addPlaceholderChild(e, s, t, i) {
+    s.key.level <= t.level || !s.hasData() || Dt(t, s.key) && (this._addToContainer(s), i.add(s.id), e.push(s.key.level - t.level));
+  }
+  _addPlaceholderParent(e, s) {
+    const t = this._tiles;
+    let i = e;
+    for (; ; ) {
+      if (i = vt(i), !i || s.has(i))
+        return;
+      const r = t.get(i);
+      if (r && r.hasData())
+        return this._addToContainer(r), void s.add(r.id);
+    }
+  }
+  _getOrAcquireTile(e) {
+    let s = this._tiles.get(e);
+    return s || (s = this._tileCache.pop(e), s || (s = this.acquireTile(new M(e))), this._tiles.set(e, s), s);
+  }
+  _releaseTile(e) {
+    const s = this._tiles.get(e);
+    this.releaseTile(s), this._removeFromContainer(s), this._tiles.delete(e), s.hasData() ? this._tileCache.put(e, s, 1) : s.dispose();
+  }
+  _addToContainer(e) {
+    let s;
+    const t = [], i = this._container;
+    if (i.contains(e))
+      return;
+    const r = this._visibleTiles;
+    for (const [o, n] of r)
+      this._canConnectDirectly(e, n) && t.push(n), s == null && this._canConnectDirectly(n, e) && (s = n);
+    if (s != null) {
+      for (const o of t)
+        s.childrenTiles.delete(o), e.childrenTiles.add(o), o.parentTile = e;
+      s.childrenTiles.add(e), e.parentTile = s;
+    } else
+      for (const o of t)
+        e.childrenTiles.add(o), o.parentTile = e;
+    r.set(e.id, e), i.addChild(e);
+  }
+  _removeFromContainer(e) {
+    if (this._visibleTiles.delete(e.id), this._container.removeChild(e), e.parentTile != null) {
+      e.parentTile.childrenTiles.delete(e);
+      for (const s of e.childrenTiles)
+        e.parentTile != null && e.parentTile.childrenTiles.add(s);
+    }
+    for (const s of e.childrenTiles)
+      s.parentTile = e.parentTile;
+    e.parentTile = null, e.childrenTiles.clear();
+  }
+  _canConnectDirectly(e, s) {
+    const t = e.key;
+    let { level: i, row: r, col: o, world: n } = s.key;
+    const a = this._visibleTiles;
+    for (; i > 0; ) {
+      if (i--, r >>= 1, o >>= 1, t.level === i && t.row === r && t.col === o && t.world === n)
+        return !0;
+      if (a.has(`${i}/${r}/${o}/${n}`))
+        return !1;
+    }
+    return !1;
+  }
+  _updateCacheSize(e) {
+    const s = e.state.size;
+    if (s[0] === this._viewSize[0] && s[1] === this._viewSize[1])
+      return;
+    const t = Math.ceil(s[0] / me) + 1, i = Math.ceil(s[1] / me) + 1;
+    this._viewSize[0] = s[0], this._viewSize[1] = s[1], this._tileCache.maxSize = 5 * t * i;
+  }
+};
+function vt(h) {
+  const [e, s, t, i] = h.split("/"), r = parseInt(e, 10);
+  return r === 0 ? null : `${r - 1}/${parseInt(s, 10) >> 1}/${parseInt(t, 10) >> 1}/${parseInt(i, 10)}`;
+}
+function Dt(h, e) {
+  const s = e.level - h.level;
+  return h.row === e.row >> s && h.col === e.col >> s && h.world === e.world;
+}
+let Ct = class {
+  constructor(e, s) {
+    this.sourceTile = s, this.xTile = 0, this.yTile = 0, this.hash = 0, this.priority = 1, this.featureIndex = 0, this.colliders = [], this.textVertexRanges = [], this.iconVertexRanges = [], this.tile = e;
+  }
+};
+class Rt {
+  constructor() {
+    this.tileSymbols = [], this.parts = [{ startTime: 0, startOpacity: 0, targetOpacity: 0, show: !1 }, { startTime: 0, startOpacity: 0, targetOpacity: 0, show: !1 }], this.show = !1;
+  }
+}
+function we(h, e, s, t, i, r) {
+  const o = s - i;
+  if (o >= 0)
+    return (e >> o) + (t - (r << o)) * (h >> o);
+  const n = -o;
+  return e - (r - (t << n)) * (h >> n) << n;
+}
+let ke = class {
+  constructor(e, s, t) {
+    this._rows = Math.ceil(s / t), this._columns = Math.ceil(e / t), this._cellSize = t, this.cells = new Array(this._rows);
+    for (let i = 0; i < this._rows; i++) {
+      this.cells[i] = new Array(this._columns);
+      for (let r = 0; r < this._columns; r++)
+        this.cells[i][r] = [];
+    }
+  }
+  getCell(e, s) {
+    const t = Math.min(Math.max(Math.floor(s / this._cellSize), 0), this._rows - 1), i = Math.min(Math.max(Math.floor(e / this._cellSize), 0), this._columns - 1);
+    return this.cells[t] && this.cells[t][i] || null;
+  }
+  getCellSpan(e, s, t, i) {
+    return [Math.min(Math.max(Math.floor(e / this._cellSize), 0), this.columns - 1), Math.min(Math.max(Math.floor(s / this._cellSize), 0), this.rows - 1), Math.min(Math.max(Math.floor(t / this._cellSize), 0), this.columns - 1), Math.min(Math.max(Math.floor(i / this._cellSize), 0), this.rows - 1)];
+  }
+  get cellSize() {
+    return this._cellSize;
+  }
+  get columns() {
+    return this._columns;
+  }
+  get rows() {
+    return this._rows;
+  }
+};
+function Lt(h, e, s, t, i, r, o) {
+  const n = e[t++];
+  for (let a = 0; a < n; a++) {
+    const l = new Ct(r, o);
+    l.xTile = e[t++], l.yTile = e[t++], l.hash = e[t++], l.priority = e[t++], l.featureIndex = e[t++];
+    const c = e[t++];
+    for (let u = 0; u < c; u++) {
+      const _ = e[t++], f = e[t++], g = e[t++], p = e[t++], m = !!e[t++], b = e[t++], S = s[t++], I = s[t++], w = e[t++], x = e[t++];
+      l.colliders.push({ xTile: _, yTile: f, dxPixels: g, dyPixels: p, hard: m, partIndex: b, width: w, height: x, minLod: S, maxLod: I });
+    }
+    const y = h[t++];
+    for (let u = 0; u < y; u++)
+      l.textVertexRanges.push([h[t++], h[t++]]);
+    const d = h[t++];
+    for (let u = 0; u < d; u++)
+      l.iconVertexRanges.push([h[t++], h[t++]]);
+    i.push(l);
+  }
+  return t;
+}
+function Pt(h, e, s) {
+  for (const [t, i] of h.symbols)
+    At(h, e, s, i, t);
+}
+function At(h, e, s, t, i) {
+  const r = h.layerData.get(i);
+  if (r.type === L.SYMBOL) {
+    for (const o of t) {
+      const n = o.unique;
+      let a;
+      if (o.selectedForRendering) {
+        const l = n.parts[0], c = l.startOpacity, y = l.targetOpacity;
+        h.allSymbolsFadingOut = h.allSymbolsFadingOut && y === 0;
+        const d = s ? Math.floor(127 * c) | y << 7 : y ? 255 : 0;
+        a = d << 24 | d << 16 | d << 8 | d;
+      } else
+        a = 0;
+      for (const [l, c] of o.iconVertexRanges)
+        for (let y = l; y < l + c; y += 4)
+          r.iconOpacity[y / 4] = a;
+      if (o.selectedForRendering) {
+        const l = n.parts[1], c = l.startOpacity, y = l.targetOpacity;
+        h.allSymbolsFadingOut = h.allSymbolsFadingOut && y === 0;
+        const d = s ? Math.floor(127 * c) | y << 7 : y ? 255 : 0;
+        a = d << 24 | d << 16 | d << 8 | d;
+      } else
+        a = 0;
+      for (const [l, c] of o.textVertexRanges)
+        for (let y = l; y < l + c; y += 4)
+          r.textOpacity[y / 4] = a;
+    }
+    r.lastOpacityUpdate = e, r.opacityChanged = !0;
+  }
+}
+function Mt(h, e, s, t) {
+  const i = h.colliders;
+  let r, o, n, a;
+  for (const l of i)
+    if (h.unique.show && h.unique.parts[l.partIndex].show && (r = l.xScreen - t[0] + l.dxScreen, o = l.yScreen - t[1] + l.dyScreen, n = r + l.width, a = o + l.height, at(s, e.x, e.y, r, o, n, a)))
+      return !0;
+  return !1;
+}
+let K = class {
+  constructor(e, s) {
+    this.layerUIDs = [], this.isDestroyed = !1, this._data = e;
+    let t = 1;
+    const i = new Uint32Array(e);
+    this.layerUIDs = [];
+    const r = i[t++];
+    for (let o = 0; o < r; o++)
+      this.layerUIDs[o] = i[t++];
+    this.bufferDataOffset = t, s && (this.layer = s.getStyleLayerByUID(this.layerUIDs[0]));
+  }
+  get isPreparedForRendering() {
+    return this._data == null;
+  }
+  get offset() {
+    return this.bufferDataOffset;
+  }
+  get data() {
+    return this._data;
+  }
+  destroy() {
+    this.isDestroyed || (this.doDestroy(), this._data = null, this.isDestroyed = !0);
+  }
+  prepareForRendering(e) {
+    this._data != null && (this.doPrepareForRendering(e, this._data, this.bufferDataOffset), this._data = null);
+  }
+};
+class Ot extends K {
+  constructor(e, s) {
+    super(e, s), this.type = L.LINE, this.lineIndexStart = 0, this.lineIndexCount = 0;
+    const t = new Uint32Array(e);
+    let i = this.bufferDataOffset;
+    this.lineIndexStart = t[i++], this.lineIndexCount = t[i++];
+    const r = t[i++];
+    if (r > 0) {
+      this.patternMap = /* @__PURE__ */ new Map();
+      for (let o = 0; o < r; o++) {
+        const n = t[i++], a = t[i++], l = t[i++];
+        this.patternMap.set(n, [a, l]);
+      }
+    }
+    this.bufferDataOffset = i;
+  }
+  get memoryUsed() {
+    var e, s;
+    return (((e = this.data) == null ? void 0 : e.byteLength) ?? 0) + (((s = this.vao) == null ? void 0 : s.usedMemory) ?? 0);
+  }
+  hasData() {
+    return this.lineIndexCount > 0;
+  }
+  triangleCount() {
+    return this.lineIndexCount / 3;
+  }
+  doDestroy() {
+    this.vao = U(this.vao);
+  }
+  doPrepareForRendering(e, s, t) {
+    const i = new Uint32Array(s), r = new Int32Array(i.buffer), o = i[t++], n = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, o));
+    t += o;
+    const a = i[t++], l = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, a));
+    t += a;
+    const c = this.layer.lineMaterial;
+    this.vao = new E(e, c.getAttributeLocations(), c.getLayoutInfo(), { geometry: n }, l);
+  }
+}
+let kt = class extends K {
+  constructor(e, s) {
+    super(e, s), this.type = L.FILL, this.fillIndexStart = 0, this.fillIndexCount = 0, this.outlineIndexStart = 0, this.outlineIndexCount = 0;
+    const t = new Uint32Array(e);
+    let i = this.bufferDataOffset;
+    this.fillIndexStart = t[i++], this.fillIndexCount = t[i++], this.outlineIndexStart = t[i++], this.outlineIndexCount = t[i++];
+    const r = t[i++];
+    if (r > 0) {
+      this.patternMap = /* @__PURE__ */ new Map();
+      for (let o = 0; o < r; o++) {
+        const n = t[i++], a = t[i++], l = t[i++];
+        this.patternMap.set(n, [a, l]);
+      }
+    }
+    this.bufferDataOffset = i;
+  }
+  get memoryUsed() {
+    var e, s, t;
+    return (((e = this.data) == null ? void 0 : e.byteLength) ?? 0) + (((s = this.fillVAO) == null ? void 0 : s.usedMemory) ?? 0) + (((t = this.outlineVAO) == null ? void 0 : t.usedMemory) ?? 0);
+  }
+  hasData() {
+    return this.fillIndexCount > 0 || this.outlineIndexCount > 0;
+  }
+  triangleCount() {
+    return (this.fillIndexCount + this.outlineIndexCount) / 3;
+  }
+  doDestroy() {
+    this.fillVAO = U(this.fillVAO), this.outlineVAO = U(this.outlineVAO);
+  }
+  doPrepareForRendering(e, s, t) {
+    const i = new Uint32Array(s), r = new Int32Array(i.buffer), o = i[t++], n = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, o));
+    t += o;
+    const a = i[t++], l = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, a));
+    t += a;
+    const c = i[t++], y = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, c));
+    t += c;
+    const d = i[t++], u = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, d));
+    t += d;
+    const _ = this.layer, f = _.fillMaterial, g = _.outlineMaterial;
+    this.fillVAO = new E(e, f.getAttributeLocations(), f.getLayoutInfo(), { geometry: n }, l), this.outlineVAO = new E(e, g.getAttributeLocations(), g.getLayoutInfo(), { geometry: y }, u);
+  }
+}, Ut = class extends K {
+  constructor(e, s, t) {
+    super(e, s), this.type = L.SYMBOL, this.iconPerPageElementsMap = /* @__PURE__ */ new Map(), this.glyphPerPageElementsMap = /* @__PURE__ */ new Map(), this.symbolInstances = [], this.isIconSDF = !1, this.opacityChanged = !1, this.lastOpacityUpdate = 0, this.symbols = [];
+    const i = new Uint32Array(e), r = new Int32Array(e), o = new Float32Array(e);
+    let n = this.bufferDataOffset;
+    this.isIconSDF = !!i[n++];
+    const a = i[n++], l = i[n++], c = i[n++], y = new M(a, l, c, 0), d = i[n++];
+    for (let g = 0; g < d; g++) {
+      const p = i[n++], m = i[n++], b = i[n++];
+      this.iconPerPageElementsMap.set(p, [m, b]);
+    }
+    const u = i[n++];
+    for (let g = 0; g < u; g++) {
+      const p = i[n++], m = i[n++], b = i[n++];
+      this.glyphPerPageElementsMap.set(p, [m, b]);
+    }
+    const _ = i[n++], f = i[n++];
+    this.iconOpacity = new Int32Array(_), this.textOpacity = new Int32Array(f), n = Lt(i, r, o, n, this.symbols, t, y), this.bufferDataOffset = n;
+  }
+  get memoryUsed() {
+    var e, s, t;
+    return (((e = this.data) == null ? void 0 : e.byteLength) ?? 0) + (((s = this.iconVAO) == null ? void 0 : s.usedMemory) ?? 0) + (((t = this.textVAO) == null ? void 0 : t.usedMemory) ?? 0) + ne(this.iconOpacity) + ne(this.textOpacity);
+  }
+  hasData() {
+    return this.iconPerPageElementsMap.size > 0 || this.glyphPerPageElementsMap.size > 0;
+  }
+  triangleCount() {
+    let e = 0;
+    for (const [s, t] of this.iconPerPageElementsMap)
+      e += t[1];
+    for (const [s, t] of this.glyphPerPageElementsMap)
+      e += t[1];
+    return e / 3;
+  }
+  doDestroy() {
+    this.iconVAO = U(this.iconVAO), this.textVAO = U(this.textVAO);
+  }
+  updateOpacityInfo() {
+    if (!this.opacityChanged)
+      return;
+    this.opacityChanged = !1;
+    const e = this.iconOpacity, s = this.iconVAO.vertexBuffers.opacity;
+    e.length > 0 && e.byteLength === s.usedMemory && s.setSubData(e, 0, 0, e.length);
+    const t = this.textOpacity, i = this.textVAO.vertexBuffers.opacity;
+    t.length > 0 && t.byteLength === i.usedMemory && i.setSubData(t, 0, 0, t.length);
+  }
+  doPrepareForRendering(e, s, t) {
+    const i = new Uint32Array(s), r = new Int32Array(i.buffer), o = i[t++], n = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, o));
+    t += o;
+    const a = i[t++], l = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, a));
+    t += a;
+    const c = i[t++], y = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, c));
+    t += c;
+    const d = i[t++], u = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, d));
+    t += d;
+    const _ = R.createVertex(e, C.STATIC_DRAW, this.iconOpacity.buffer), f = R.createVertex(e, C.STATIC_DRAW, this.textOpacity.buffer), g = this.layer, p = g.iconMaterial, m = g.textMaterial;
+    this.iconVAO = new E(e, p.getAttributeLocations(), p.getLayoutInfo(), { geometry: n, opacity: _ }, l), this.textVAO = new E(e, m.getAttributeLocations(), m.getLayoutInfo(), { geometry: y, opacity: f }, u);
+  }
+}, Et = class extends K {
+  constructor(e, s) {
+    super(e, s), this.type = L.CIRCLE, this.circleIndexStart = 0, this.circleIndexCount = 0;
+    const t = new Uint32Array(e);
+    let i = this.bufferDataOffset;
+    this.circleIndexStart = t[i++], this.circleIndexCount = t[i++], this.bufferDataOffset = i;
+  }
+  get memoryUsed() {
+    var e, s;
+    return (((e = this.data) == null ? void 0 : e.byteLength) ?? 0) + (((s = this.vao) == null ? void 0 : s.usedMemory) ?? 0);
+  }
+  hasData() {
+    return this.circleIndexCount > 0;
+  }
+  triangleCount() {
+    return this.circleIndexCount / 3;
+  }
+  doDestroy() {
+    this.vao = U(this.vao);
+  }
+  doPrepareForRendering(e, s, t) {
+    const i = new Uint32Array(s), r = new Int32Array(i.buffer), o = i[t++], n = R.createVertex(e, C.STATIC_DRAW, new Int32Array(r.buffer, 4 * t, o));
+    t += o;
+    const a = i[t++], l = R.createIndex(e, C.STATIC_DRAW, new Uint32Array(i.buffer, 4 * t, a));
+    t += a;
+    const c = this.layer.circleMaterial;
+    this.vao = new E(e, c.getAttributeLocations(), c.getLayoutInfo(), { geometry: n }, l);
+  }
+}, $t = class Ue extends Me {
+  constructor(e, s, t, i, r, o, n, a = null) {
+    super(e, s, t, i, r, o, 4096, 4096), this.styleRepository = n, this._memCache = a, this.type = "vector-tile", this._referenced = 0, this._hasSymbolBuckets = !1, this._memoryUsedByLayerData = 0, this.layerData = /* @__PURE__ */ new Map(), this.status = "loading", this.allSymbolsFadingOut = !1, this.lastOpacityUpdate = 0, this.symbols = /* @__PURE__ */ new Map(), this.isCoverage = !1, this.neededForCoverage = !1, this.decluttered = !1, this.parentTile = null, this.childrenTiles = /* @__PURE__ */ new Set(), this.featureIndex = null, this.triangleCount = 0, this._processed = !1, this._referenced = 1, this.id = e.id;
+  }
+  get hasSymbolBuckets() {
+    return this._hasSymbolBuckets;
+  }
+  get isFading() {
+    return this._hasSymbolBuckets && performance.now() - this.lastOpacityUpdate < Q;
+  }
+  get isHoldingForFade() {
+    return this._hasSymbolBuckets && (!this.allSymbolsFadingOut || performance.now() - this.lastOpacityUpdate < Q);
+  }
+  get wasRequested() {
+    return this.status === "errored" || this.status === "loaded" || this.status === "reloading";
+  }
+  setData(e) {
+    this.changeDataImpl(e), this.requestRender(), this.ready(), this._processed = !0;
+  }
+  deleteLayerData(e) {
+    var t, i;
+    let s = !1;
+    for (const r of e) {
+      const o = this.layerData.get(r);
+      o && (this._memoryUsedByLayerData -= o.memoryUsed, o.type === L.SYMBOL && this.symbols.delete(r) && (s = !0), o.destroy(), this.layerData.delete(r));
+    }
+    (t = this._memCache) == null || t.updateSize(this.key.id, this, this._memoryUsedByLayerData), s && ((i = this.featureIndex) == null || i.clear(), this.emit("symbols-changed")), this.requestRender();
+  }
+  processed() {
+    return this._processed;
+  }
+  hasData() {
+    return this.layerData.size > 0;
+  }
+  dispose() {
+    this.status !== "unloaded" && (this.featureIndex = null, zt.delete(this), Ue._destroyRenderBuckets(this.layerData), this.layerData.clear(), this._memoryUsedByLayerData = 0, this.destroy(), this.status = "unloaded");
+  }
+  release() {
+    return --this._referenced == 0 && (this.dispose(), this.stage = null, !0);
+  }
+  retain() {
+    ++this._referenced;
+  }
+  get referenced() {
+    return this._referenced;
+  }
+  get usedMemory() {
+    return this._memoryUsedByLayerData + 256;
+  }
+  changeDataImpl(e) {
+    var t, i;
+    (t = this.featureIndex) == null || t.clear();
+    let s = !1;
+    if (e) {
+      const { bucketsWithData: r, emptyBuckets: o } = e, n = this._createRenderBuckets(r);
+      if (o && o.byteLength > 0) {
+        const a = new Uint32Array(o);
+        for (const l of a)
+          this._deleteLayerData(l);
+      }
+      for (const [a, l] of n)
+        this._deleteLayerData(a), l.type === L.SYMBOL && (this.symbols.set(a, l.symbols), s = !0), this._memoryUsedByLayerData += l.memoryUsed, this.layerData.set(a, l);
+      (i = this._memCache) == null || i.updateSize(this.key.id, this, this.usedMemory);
+    }
+    this._hasSymbolBuckets = !1;
+    for (const [r, o] of this.layerData)
+      o.type === L.SYMBOL && (this._hasSymbolBuckets = !0);
+    s && this.emit("symbols-changed");
+  }
+  attachWithContext(e) {
+    this.stage = { context: e, trashDisplayObject(s) {
+      s.processDetach();
+    }, untrashDisplayObject: () => !1 };
+  }
+  setTransform(e) {
+    super.setTransform(e);
+    const s = this.resolution / (e.resolution * e.pixelRatio), t = this.width / this.rangeX * s, i = this.height / this.rangeY * s, r = [0, 0];
+    e.toScreen(r, [this.x, this.y]);
+    const o = this.transforms.tileUnitsToPixels;
+    Be(o), Ne(o, o, r), We(o, o, Math.PI * e.rotation / 180), Qe(o, o, [t, i, 1]);
+  }
+  _createTransforms() {
+    return { displayViewScreenMat3: z(), tileMat3: z(), tileUnitsToPixels: z() };
+  }
+  static _destroyRenderBuckets(e) {
+    if (!e)
+      return;
+    const s = /* @__PURE__ */ new Set();
+    for (const t of e.values())
+      s.has(t) || (t.destroy(), s.add(t));
+    e.clear();
+  }
+  _createRenderBuckets(e) {
+    const s = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map();
+    for (const i of e) {
+      const r = this._deserializeBucket(i, t);
+      for (const o of r.layerUIDs)
+        s.set(o, r);
+    }
+    return s;
+  }
+  _deserializeBucket(e, s) {
+    let t = s.get(e);
+    if (t)
+      return t;
+    switch (new Uint32Array(e)[0]) {
+      case L.FILL:
+        t = new kt(e, this.styleRepository);
+        break;
+      case L.LINE:
+        t = new Ot(e, this.styleRepository);
+        break;
+      case L.SYMBOL:
+        t = new Ut(e, this.styleRepository, this);
+        break;
+      case L.CIRCLE:
+        t = new Et(e, this.styleRepository);
+    }
+    return s.set(e, t), t;
+  }
+  _deleteLayerData(e) {
+    if (!this.layerData.has(e))
+      return;
+    const s = this.layerData.get(e);
+    this._memoryUsedByLayerData -= s.memoryUsed, s.destroy(), this.layerData.delete(e);
+  }
+};
+const zt = /* @__PURE__ */ new Map();
+function Vt(h, e, s, t, i, r) {
+  const { iconRotationAlignment: o, textRotationAlignment: n, iconTranslate: a, iconTranslateAnchor: l, textTranslate: c, textTranslateAnchor: y } = t;
+  let d = 0;
+  for (const u of h.colliders) {
+    const [_, f] = u.partIndex === 0 ? a : c, g = u.partIndex === 0 ? l : y, p = u.minLod <= r && r <= u.maxLod;
+    d += p ? 0 : 1, u.enabled = p, u.xScreen = u.xTile * i[0] + u.yTile * i[3] + i[6], u.yScreen = u.xTile * i[1] + u.yTile * i[4] + i[7], g === yt.MAP ? (u.xScreen += s * _ - e * f, u.yScreen += e * _ + s * f) : (u.xScreen += _, u.yScreen += f), O.VIEWPORT === (u.partIndex === 0 ? o : n) ? (u.dxScreen = u.dxPixels, u.dyScreen = u.dyPixels) : (u.dxScreen = s * (u.dxPixels + u.width / 2) - e * (u.dyPixels + u.height / 2) - u.width / 2, u.dyScreen = e * (u.dxPixels + u.width / 2) + s * (u.dyPixels + u.height / 2) - u.height / 2);
+  }
+  h.colliders.length > 0 && d === h.colliders.length && (h.unique.show = !1);
+}
+class Ft {
+  constructor(e, s, t, i, r, o) {
+    this._symbols = e, this._styleRepository = i, this._zoom = r, this._currentLayerCursor = 0, this._currentSymbolCursor = 0, this._styleProps = /* @__PURE__ */ new Map(), this._allNeededMatrices = /* @__PURE__ */ new Map(), this._gridIndex = new ke(s, t, ht), this._si = Math.sin(Math.PI * o / 180), this._co = Math.cos(Math.PI * o / 180);
+    for (const n of e)
+      for (const a of n.symbols)
+        this._allNeededMatrices.has(a.tile) || this._allNeededMatrices.set(a.tile, Je(a.tile.transforms.tileUnitsToPixels));
+  }
+  work(e) {
+    const s = this._gridIndex;
+    function t(r) {
+      const o = r.xScreen + r.dxScreen, n = r.yScreen + r.dyScreen, a = o + r.width, l = n + r.height, [c, y, d, u] = s.getCellSpan(o, n, a, l);
+      for (let _ = y; _ <= u; _++)
+        for (let f = c; f <= d; f++) {
+          const g = s.cells[_][f];
+          for (const p of g) {
+            const m = p.xScreen + p.dxScreen, b = p.yScreen + p.dyScreen, S = m + p.width, I = b + p.height;
+            if (!(a < m || o > S || l < b || n > I))
+              return !0;
+          }
+        }
+      return !1;
+    }
+    const i = performance.now();
+    for (; this._currentLayerCursor < this._symbols.length; this._currentLayerCursor++, this._currentSymbolCursor = 0) {
+      const r = this._symbols[this._currentLayerCursor], o = this._getProperties(r.styleLayerUID);
+      for (; this._currentSymbolCursor < r.symbols.length; this._currentSymbolCursor++) {
+        if (this._currentSymbolCursor % 100 == 99 && performance.now() - i > e)
+          return !1;
+        const n = r.symbols[this._currentSymbolCursor];
+        if (!n.unique.show)
+          continue;
+        Vt(n, this._si, this._co, o, this._allNeededMatrices.get(n.tile), this._zoom);
+        const a = n.unique;
+        if (!a.show)
+          continue;
+        const { iconAllowOverlap: l, iconIgnorePlacement: c, textAllowOverlap: y, textIgnorePlacement: d } = o;
+        for (const u of n.colliders) {
+          if (!u.enabled)
+            continue;
+          const _ = a.parts[u.partIndex];
+          _.show && !(u.partIndex ? y : l) && t(u) && (u.hard ? a.show = !1 : _.show = !1);
+        }
+        if (a.show)
+          for (const u of n.colliders) {
+            if (!u.enabled || (u.partIndex ? d : c) || !a.parts[u.partIndex].show)
+              continue;
+            const _ = u.xScreen + u.dxScreen, f = u.yScreen + u.dyScreen, g = _ + u.width, p = f + u.height, [m, b, S, I] = this._gridIndex.getCellSpan(_, f, g, p);
+            for (let w = b; w <= I; w++)
+              for (let x = m; x <= S; x++)
+                this._gridIndex.cells[w][x].push(u);
+          }
+      }
+    }
+    return !0;
+  }
+  _getProperties(e) {
+    const s = this._styleProps.get(e);
+    if (s)
+      return s;
+    const t = this._zoom, i = this._styleRepository.getStyleLayerByUID(e), r = i.getLayoutValue("symbol-placement", t) !== ut.POINT;
+    let o = i.getLayoutValue("icon-rotation-alignment", t);
+    o === O.AUTO && (o = r ? O.MAP : O.VIEWPORT);
+    let n = i.getLayoutValue("text-rotation-alignment", t);
+    n === O.AUTO && (n = r ? O.MAP : O.VIEWPORT);
+    const a = i.getPaintValue("icon-translate", t), l = i.getPaintValue("icon-translate-anchor", t), c = i.getPaintValue("text-translate", t), y = i.getPaintValue("text-translate-anchor", t), d = { iconAllowOverlap: i.getLayoutValue("icon-allow-overlap", t), iconIgnorePlacement: i.getLayoutValue("icon-ignore-placement", t), textAllowOverlap: i.getLayoutValue("text-allow-overlap", t), textIgnorePlacement: i.getLayoutValue("text-ignore-placement", t), iconRotationAlignment: o, textRotationAlignment: n, iconTranslateAnchor: l, iconTranslate: a, textTranslateAnchor: y, textTranslate: c };
+    return this._styleProps.set(e, d), d;
+  }
+}
+function qt(h, e) {
+  if (h.priority - e.priority)
+    return h.priority - e.priority;
+  const s = h.tile.key, t = e.tile.key;
+  return s.world - t.world ? s.world - t.world : s.level - t.level ? s.level - t.level : s.row - t.row ? s.row - t.row : s.col - t.col ? s.col - t.col : h.xTile - e.xTile ? h.xTile - e.xTile : h.yTile - e.yTile;
+}
+class Ht {
+  get running() {
+    return this._running;
+  }
+  constructor(e, s, t, i, r, o) {
+    this._visibleTiles = e, this._symbolRepository = s, this._createCollisionJob = t, this._assignTileSymbolsOpacity = i, this._symbolLayerSorter = r, this._isLayerVisible = o, this._selectionJob = null, this._selectionJobCompleted = !1, this._collisionJob = null, this._collisionJobCompleted = !1, this._opacityJob = null, this._opacityJobCompleted = !1, this._running = !0;
+  }
+  setScreenSize(e, s) {
+    this._screenWidth === e && this._screenHeight === s || this.restart(), this._screenWidth = e, this._screenHeight = s;
+  }
+  restart() {
+    this._selectionJob = null, this._selectionJobCompleted = !1, this._collisionJob = null, this._collisionJobCompleted = !1, this._opacityJob = null, this._opacityJobCompleted = !1, this._running = !0;
+  }
+  continue(e) {
+    if (this._selectionJob || (this._selectionJob = this._createSelectionJob()), !this._selectionJobCompleted) {
+      const s = performance.now();
+      if (!this._selectionJob.work(e) || (this._selectionJobCompleted = !0, (e = Math.max(0, e - (performance.now() - s))) === 0))
+        return !1;
+    }
+    if (this._collisionJob || (this._collisionJob = this._createCollisionJob(this._selectionJob.sortedSymbols, this._screenWidth, this._screenHeight)), !this._collisionJobCompleted) {
+      const s = performance.now();
+      if (!this._collisionJob.work(e) || (this._collisionJobCompleted = !0, (e = Math.max(0, e - (performance.now() - s))) === 0))
+        return !1;
+    }
+    if (this._opacityJob || (this._opacityJob = this._createOpacityJob()), !this._opacityJobCompleted) {
+      const s = performance.now();
+      if (!this._opacityJob.work(e) || (this._opacityJobCompleted = !0, (e = Math.max(0, e - (performance.now() - s))) === 0))
+        return !1;
+    }
+    return this._running = !1, !0;
+  }
+  _createSelectionJob() {
+    const e = this._symbolRepository.uniqueSymbols;
+    for (let a = 0; a < e.length; a++) {
+      const l = e[a];
+      for (let c = 0; c < l.uniqueSymbols.length; c++) {
+        const y = l.uniqueSymbols[c];
+        for (const d of y.tileSymbols)
+          d.selectedForRendering = !1;
+      }
+    }
+    const s = [];
+    let t = 0, i = 0;
+    const r = this._isLayerVisible;
+    function o(a) {
+      let l;
+      const c = performance.now();
+      for (; i < e.length; i++, t = 0) {
+        const y = e[i], d = y.styleLayerUID;
+        if (!r(d)) {
+          s[i] || (s[i] = { styleLayerUID: d, symbols: [] });
+          continue;
+        }
+        s[i] = s[i] || { styleLayerUID: d, symbols: [] };
+        const u = s[i];
+        for (; t < y.uniqueSymbols.length; t++) {
+          if (l = y.uniqueSymbols[t], t % 100 == 99 && performance.now() - c > a)
+            return !1;
+          let _ = null, f = !1, g = !1;
+          for (const p of l.tileSymbols)
+            if (!g || !f) {
+              const m = p.tile;
+              (!_ || m.isCoverage || m.neededForCoverage && !f) && (_ = p, (m.neededForCoverage || m.isCoverage) && (g = !0), m.isCoverage && (f = !0));
+            }
+          if (_.selectedForRendering = !0, g) {
+            u.symbols.push(_), l.show = !0;
+            for (const p of l.parts)
+              p.show = !0;
+          } else
+            l.show = !1;
+        }
+      }
+      for (const y of s)
+        y.symbols.sort(qt);
+      return !0;
+    }
+    const n = this._symbolLayerSorter;
+    return { work: o, get sortedSymbols() {
+      return s.sort(n);
+    } };
+  }
+  _createOpacityJob() {
+    const e = this._assignTileSymbolsOpacity, s = this._visibleTiles;
+    let t = 0;
+    function i(r, o) {
+      const n = r.symbols;
+      for (const [a, l] of n)
+        Bt(l, o);
+      e(r, o);
+      for (const a of r.childrenTiles)
+        i(a, o);
+    }
+    return { work(r) {
+      const o = performance.now();
+      for (; t < s.length; t++) {
+        if (performance.now() - o > r)
+          return !1;
+        const n = s[t];
+        n.parentTile == null && i(n, performance.now());
+      }
+      return !0;
+    } };
+  }
+}
+function Bt(h, e) {
+  for (const s of h) {
+    const t = s.unique;
+    for (const i of t.parts) {
+      const r = i.targetOpacity > 0.5 ? 1 : -1;
+      i.startOpacity += r * ((e - i.startTime) / Q), i.startOpacity = Math.min(Math.max(i.startOpacity, 0), 1), i.startTime = e, i.targetOpacity = t.show && i.show ? 1 : 0;
+    }
+  }
+}
+const Nt = 32, Wt = 8, Qt = 64;
+class Jt {
+  constructor(e, s, t) {
+    this.tileCoordRange = e, this._visibleTiles = s, this._createUnique = t, this._tiles = /* @__PURE__ */ new Map(), this._uniqueSymbolsReferences = /* @__PURE__ */ new Map();
+  }
+  get uniqueSymbols() {
+    return this._uniqueSymbolLayerArray == null && (this._uniqueSymbolLayerArray = this._createUniqueSymbolLayerArray()), this._uniqueSymbolLayerArray;
+  }
+  get uniqueSymbolsReferences() {
+    return this._uniqueSymbolsReferences;
+  }
+  add(e, s) {
+    this._uniqueSymbolLayerArray = null;
+    let t = this._tiles.get(e.id);
+    t || (t = { symbols: /* @__PURE__ */ new Map() }, this._tiles.set(e.id, t));
+    const i = /* @__PURE__ */ new Map();
+    if (s)
+      for (const n of s)
+        t.symbols.has(n) && (i.set(n, t.symbols.get(n)), t.symbols.delete(n));
+    else
+      for (const [n, a] of e.layerData)
+        t.symbols.has(n) && (i.set(n, t.symbols.get(n)), t.symbols.delete(n));
+    this._removeSymbols(i);
+    const r = e.symbols, o = /* @__PURE__ */ new Map();
+    for (const [n, a] of r) {
+      let l = a.length;
+      if (l >= Nt) {
+        let c = this.tileCoordRange;
+        do
+          c /= 2, l /= 4;
+        while (l > Wt && c > Qt);
+        const y = new ke(this.tileCoordRange, this.tileCoordRange, c);
+        o.set(n, { flat: a, index: y }), t.symbols.set(n, { flat: a, index: y });
+        for (const d of a)
+          y.getCell(d.xTile, d.yTile).push(d);
+      } else
+        o.set(n, { flat: a }), t.symbols.set(n, { flat: a });
+    }
+    this._addSymbols(e.key, r);
+  }
+  deleteStyleLayers(e) {
+    this._uniqueSymbolLayerArray = null;
+    for (const [s, t] of this._tiles) {
+      const i = /* @__PURE__ */ new Map();
+      for (const r of e)
+        t.symbols.has(r) && (i.set(r, t.symbols.get(r)), t.symbols.delete(r));
+      this._removeSymbols(i), t.symbols.size === 0 && this._tiles.delete(s);
+    }
+  }
+  removeTile(e) {
+    this._uniqueSymbolLayerArray = null;
+    const s = this._tiles.get(e.id);
+    if (!s)
+      return;
+    const t = /* @__PURE__ */ new Map();
+    for (const [i, r] of e.symbols)
+      s.symbols.has(i) && (t.set(i, s.symbols.get(i)), s.symbols.delete(i));
+    this._removeSymbols(t), s.symbols.size === 0 && this._tiles.delete(e.id);
+  }
+  querySymbols(e, s, t, i) {
+    const r = [], o = this.uniqueSymbols;
+    for (const n of o) {
+      const a = n.styleLayerUID, l = n.uniqueSymbols;
+      for (const c of l) {
+        const y = c.tileSymbols.find((d) => d.selectedForRendering);
+        y && Mt(y, e, s * (window.devicePixelRatio || 1), t) && r.push({ vtlSymbol: y, styleLayerUID: a, tileKey: y.tile.key });
+      }
+    }
+    return r;
+  }
+  _removeSymbols(e) {
+    for (const [s, { flat: t }] of e)
+      for (const i of t) {
+        const r = i.unique, o = r.tileSymbols, n = o.length - 1;
+        for (let a = 0; a < n; a++)
+          if (o[a] === i) {
+            o[a] = o[n];
+            break;
+          }
+        if (o.length = n, n === 0) {
+          const a = this._uniqueSymbolsReferences.get(s);
+          a.delete(r), a.size === 0 && this._uniqueSymbolsReferences.delete(s);
+        }
+        i.unique = null;
+      }
+  }
+  _addSymbols(e, s) {
+    if (s.size === 0)
+      return;
+    const t = this._visibleTiles;
+    for (const i of t)
+      i.parentTile || i.key.world !== e.world || i.key.level === e.level && !i.key.equals(e) || this._matchSymbols(i, e, s);
+    for (const [i, r] of s)
+      for (const o of r)
+        if (o.unique == null) {
+          const n = this._createUnique();
+          o.unique = n, n.tileSymbols.push(o);
+          let a = this._uniqueSymbolsReferences.get(i);
+          a || (a = /* @__PURE__ */ new Set(), this._uniqueSymbolsReferences.set(i, a)), a.add(n);
+        }
+  }
+  _matchSymbols(e, s, t) {
+    if (e.key.level > s.level) {
+      const r = e.key.level - s.level;
+      if (e.key.row >> r !== s.row || e.key.col >> r !== s.col)
+        return;
+    }
+    if (s.level > e.key.level) {
+      const r = s.level - e.key.level;
+      if (s.row >> r !== e.key.row || s.col >> r !== e.key.col)
+        return;
+    }
+    if (s.equals(e.key)) {
+      for (const r of e.childrenTiles)
+        this._matchSymbols(r, s, t);
+      return;
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (const [r, o] of t) {
+      const n = [];
+      for (const y of o) {
+        const d = we(this.tileCoordRange, y.xTile, s.level, s.col, e.key.level, e.key.col), u = we(this.tileCoordRange, y.yTile, s.level, s.row, e.key.level, e.key.row);
+        d >= 0 && d < this.tileCoordRange && u >= 0 && u < this.tileCoordRange && n.push({ symbol: y, xTransformed: d, yTransformed: u });
+      }
+      const a = [], l = e.key.level < s.level ? 1 : 1 << e.key.level - s.level, c = this._tiles.get(e.id).symbols.get(r);
+      if (c) {
+        const y = c.flat;
+        for (const d of n) {
+          let u, _ = !1;
+          const f = d.xTransformed, g = d.yTransformed;
+          u = c.index != null ? c.index.getCell(f, g) : y;
+          const p = d.symbol, m = p.hash;
+          for (const b of u)
+            if (m === b.hash && Math.abs(f - b.xTile) <= l && Math.abs(g - b.yTile) <= l) {
+              const S = b.unique;
+              p.unique = S, S.tileSymbols.push(p), _ = !0;
+              break;
+            }
+          _ || a.push(p);
+        }
+      }
+      a.length > 0 && i.set(r, a);
+    }
+    for (const r of e.childrenTiles)
+      this._matchSymbols(r, s, i);
+  }
+  _createUniqueSymbolLayerArray() {
+    const e = this._uniqueSymbolsReferences, s = new Array(e.size);
+    let t, i = 0;
+    for (const [r, o] of e) {
+      const n = new Array(o.size);
+      t = 0;
+      for (const a of o)
+        n[t++] = a;
+      s[i] = { styleLayerUID: r, uniqueSymbols: n }, i++;
+    }
+    return s;
+  }
+}
+const Kt = 0.5, Se = 1e-6;
+class Gt {
+  constructor(e, s) {
+    this.styleRepository = e, this._tileToHandle = /* @__PURE__ */ new Map(), this._viewState = { scale: 0, rotation: 0, center: [0, 0], size: [0, 0] }, this._declutterViewState = { scale: 0, rotation: 0, center: [0, 0], size: [0, 0] }, this._offsetFromScreenCenter = [0, 0], this._completed = !1, this._fading = Ke(!1), this._symbolRepository = new Jt(4096, s, () => new Rt()), this._symbolDeclutterer = new Ht(s, this._symbolRepository, (t, i, r) => this._createCollisionJob(t, i, r), (t, i) => {
+      t.allSymbolsFadingOut = !0, t.lastOpacityUpdate = i, Pt(t, i, !0), t.decluttered = !0, t.requestRender();
+    }, (t, i) => this.styleRepository.getStyleLayerByUID(t.styleLayerUID).z - this.styleRepository.getStyleLayerByUID(i.styleLayerUID).z, (t) => {
+      const i = this.styleRepository.getStyleLayerByUID(t);
+      if (this._zoom + Se < i.minzoom || this._zoom - Se >= i.maxzoom)
+        return !1;
+      const r = i.getLayoutProperty("visibility");
+      return !r || r.getValue() !== Z.NONE;
+    });
+  }
+  get symbolRepository() {
+    return this._symbolRepository;
+  }
+  _createCollisionJob(e, s, t) {
+    return this.updateDecluttererViewState(), new Ft(e, s, t, this.styleRepository, this._zoom, this._viewState.rotation);
+  }
+  get fading() {
+    return this._fading.value;
+  }
+  get decluttererOffset() {
+    return this._offsetFromScreenCenter;
+  }
+  addTile(e) {
+    e.decluttered = !1, this._tileToHandle.set(e, e.on("symbols-changed", () => {
+      this._symbolRepository.add(e), this.restartDeclutter();
+    })), this._symbolRepository.add(e), this.restartDeclutter();
+  }
+  removeTile(e) {
+    const s = this._tileToHandle.get(e);
+    s && (this._symbolRepository.removeTile(e), this.restartDeclutter(), s.remove(), this._tileToHandle.delete(e));
+  }
+  update(e, s) {
+    this._zoom = e, this._viewState = { scale: s.scale, rotation: s.rotation, center: [s.center[0], s.center[1]], size: [s.size[0], s.size[1]] };
+    const t = [0, 0];
+    s.toScreen(t, s.center);
+    const i = [0, 0];
+    return s.toScreen(i, this._declutterViewState.center), this._offsetFromScreenCenter[0] = t[0] - i[0], this._offsetFromScreenCenter[1] = t[1] - i[1], this._continueDeclutter(), this._completed;
+  }
+  restartDeclutter() {
+    this._completed = !1, this._symbolDeclutterer.restart(), this._notifyUnstable();
+  }
+  clear() {
+    this._completed = !1, this._symbolRepository = null, this._symbolDeclutterer.restart(), this._tileToHandle.forEach((e) => e.remove()), this._tileToHandle.clear();
+  }
+  get stale() {
+    return this._zoom !== this._declutterZoom || this._viewState.size[0] !== this._declutterViewState.size[0] || this._viewState.size[1] !== this._declutterViewState.size[1] || this._viewState.scale !== this._declutterViewState.scale || this._viewState.rotation !== this._declutterViewState.rotation;
+  }
+  deleteStyleLayers(e) {
+    this._symbolRepository.deleteStyleLayers(e);
+  }
+  _continueDeclutter() {
+    this._completed && !this.stale || (this._symbolDeclutterer.running || (this.updateDecluttererViewState(), this._symbolDeclutterer.restart()), this._symbolDeclutterer.setScreenSize(this._viewState.size[0], this._viewState.size[1]), this._completed = this._symbolDeclutterer.continue(ct), this._completed && this._scheduleNotifyStable());
+  }
+  _scheduleNotifyStable() {
+    this._stableNotificationHandle != null && clearTimeout(this._stableNotificationHandle), this._stableNotificationHandle = setTimeout(() => {
+      this._stableNotificationHandle = null, this._fading.value = !1;
+    }, (1 + Kt) * Q);
+  }
+  _notifyUnstable() {
+    this._stableNotificationHandle != null && (clearTimeout(this._stableNotificationHandle), this._stableNotificationHandle = null), this._fading.value = !0;
+  }
+  updateDecluttererViewState() {
+    this._declutterZoom = this._zoom, this._declutterViewState.center[0] = this._viewState.center[0], this._declutterViewState.center[1] = this._viewState.center[1], this._declutterViewState.rotation = this._viewState.rotation, this._declutterViewState.scale = this._viewState.scale, this._declutterViewState.size[0] = this._viewState.size[0], this._declutterViewState.size[1] = this._viewState.size[1], this._offsetFromScreenCenter[0] = 0, this._offsetFromScreenCenter[1] = 0;
+  }
+}
+let Yt = class extends Me {
+  _createTransforms() {
+    return { displayViewScreenMat3: z(), tileMat3: z() };
+  }
+};
+const J = 1e-6;
+function xe(h, e) {
+  if (h) {
+    const s = h.getLayoutProperty("visibility");
+    if (!s || s.getValue() !== Z.NONE && (h.minzoom === void 0 || h.minzoom < e + J) && (h.maxzoom === void 0 || h.maxzoom >= e - J))
+      return !0;
+  }
+  return !1;
+}
+let jt = class extends dt {
+  constructor(e) {
+    super(e), this._backgroundTiles = [], this._computeDisplayInfoView(e);
+  }
+  destroy() {
+    var e, s;
+    this.removeAllChildren(), (e = this._spriteMosaic) == null || e.dispose(), this._spriteMosaic = null, (s = this._glyphMosaic) == null || s.dispose(), this._glyphMosaic = null, this._symbolFader != null && (this._symbolFader.clear(), this._symbolFader = null), this._styleRepository = null, this._backgroundTiles = [];
+  }
+  get fading() {
+    var e;
+    return ((e = this._symbolFader) == null ? void 0 : e.fading) ?? !1;
+  }
+  get symbolFader() {
+    return this._symbolFader;
+  }
+  get symbolRepository() {
+    var e;
+    return (e = this._symbolFader) == null ? void 0 : e.symbolRepository;
+  }
+  setStyleResources(e, s, t, i) {
+    this._spriteMosaic = e, this._glyphMosaic = s, this._styleRepository = t, this._tileInfoView = i, this._computeDisplayInfoView(i), this._symbolFader == null && (this._symbolFader = new Gt(this._styleRepository, this.children)), this._symbolFader.styleRepository = t;
+  }
+  setSpriteMosaic(e) {
+    var s;
+    (s = this._spriteMosaic) == null || s.dispose(), this._spriteMosaic = e;
+  }
+  deleteStyleLayers(e) {
+    this._symbolFader != null && this._symbolFader.deleteStyleLayers(e);
+  }
+  createRenderParams(e) {
+    return { ...super.createRenderParams(e), renderPass: null, styleLayer: null, styleLayerUID: -1, glyphMosaic: this._glyphMosaic, spriteMosaic: this._spriteMosaic, hasClipping: !!this._clippingInfos };
+  }
+  doRender(e) {
+    !this.visible || e.drawPhase !== N.MAP && e.drawPhase !== N.DEBUG || this._spriteMosaic === void 0 || super.doRender(e);
+  }
+  addChild(e) {
+    return super.addChild(e), this._symbolFader != null ? this._symbolFader.addTile(e) : e.decluttered = !0, this.requestRender(), e;
+  }
+  removeChild(e) {
+    return this._symbolFader != null && this._symbolFader.removeTile(e), this.requestRender(), super.removeChild(e);
+  }
+  renderChildren(e) {
+    const { drawPhase: s } = e;
+    s !== N.DEBUG ? this._doRender(e) : super.renderChildren(e);
+  }
+  removeAllChildren() {
+    for (let e = 0; e < this.children.length; e++) {
+      const s = this.children[e];
+      this._symbolFader != null && this._symbolFader.removeTile(s), s.dispose();
+    }
+    super.removeAllChildren();
+  }
+  getStencilTarget() {
+    return this.children.filter((e) => e.neededForCoverage && e.hasData());
+  }
+  restartDeclutter() {
+    this._symbolFader != null && this._symbolFader.restartDeclutter();
+  }
+  _doRender(e) {
+    const { context: s, state: t } = e, i = this._styleRepository;
+    if (!i)
+      return;
+    const r = i.layers, o = this._displayInfo.scaleToZoom(t.scale);
+    i.backgroundBucketIds.length > 0 && (e.renderPass = "background", this._renderBackgroundLayers(e, i.backgroundBucketIds, o)), super.renderChildren(e), e.drawPhase === N.MAP && this._fade(o, t);
+    const n = this.children.filter((a) => a.visible && a.hasData());
+    if (!n || n.length === 0)
+      return s.bindVAO(), s.setStencilTestEnabled(!0), void s.setBlendingEnabled(!0);
+    for (const a of n)
+      a.triangleCount = 0;
+    s.setStencilWriteMask(0), s.setColorMask(!0, !0, !0, !0), s.setStencilOp(k.KEEP, k.KEEP, k.REPLACE), s.setStencilTestEnabled(!0), s.setBlendingEnabled(!1), s.setDepthTestEnabled(!0), s.setDepthWriteEnabled(!0), s.setDepthFunction(ue.LEQUAL), s.setClearDepth(1), s.clear(s.gl.DEPTH_BUFFER_BIT), e.renderPass = "opaque";
+    for (let a = r.length - 1; a >= 0; a--)
+      this._renderStyleLayer(r[a], e, n);
+    s.setDepthWriteEnabled(!1), s.setBlendingEnabled(!0), s.setBlendFunctionSeparate(B.ONE, B.ONE_MINUS_SRC_ALPHA, B.ONE, B.ONE_MINUS_SRC_ALPHA), e.renderPass = "translucent";
+    for (let a = 0; a < r.length; a++)
+      this._renderStyleLayer(r[a], e, n);
+    s.bindVAO(), s.setStencilTestEnabled(!0), s.setBlendingEnabled(!0);
+    for (const a of n)
+      a.debugInfo.display.triangleCount = a.triangleCount;
+  }
+  _fade(e, s) {
+    this._symbolFader != null && (this._symbolFader.update(e, s) || this.requestRender());
+  }
+  _renderStyleLayer(e, s, t) {
+    const { displayLevel: i, painter: r, renderPass: o } = s;
+    if (e === void 0)
+      return;
+    const n = e.getLayoutProperty("visibility");
+    if (n && n.getValue() === Z.NONE)
+      return;
+    let a;
+    switch (e.type) {
+      case D.BACKGROUND:
+        return;
+      case D.FILL:
+        if (o !== "opaque" && s.renderPass !== "translucent")
+          return;
+        a = "vtlFill";
+        break;
+      case D.LINE:
+        if (o !== "translucent")
+          return;
+        a = "vtlLine";
+        break;
+      case D.CIRCLE:
+        if (o !== "translucent")
+          return;
+        a = "vtlCircle";
+        break;
+      case D.SYMBOL:
+        if (o !== "translucent")
+          return;
+        a = "vtlSymbol";
+    }
+    if (t = e.type === D.SYMBOL ? t.filter((c) => c.decluttered) : t.filter((c) => c.neededForCoverage), a !== "vtlSymbol" && (t.length === 0 || e.minzoom !== void 0 && e.minzoom >= i + J || e.maxzoom !== void 0 && e.maxzoom < i - J))
+      return;
+    const l = e.uid;
+    s.styleLayerUID = l, s.styleLayer = e;
+    for (const c of t)
+      if (c.layerData.has(l)) {
+        r.renderObjects(s, t, a);
+        break;
+      }
+  }
+  _renderBackgroundLayers(e, s, t) {
+    const { context: i, painter: r, state: o } = e, n = this._styleRepository;
+    let a = !1;
+    for (const b of s)
+      if (n.getLayerById(b).type === D.BACKGROUND && xe(n.getLayerById(b), t)) {
+        a = !0;
+        break;
+      }
+    if (!a)
+      return;
+    const l = this._tileInfoView, c = l.getTileCoverage(e.state, 0, !0, "smallest"), { spans: y, lodInfo: d } = c, { level: u } = d, _ = F(), f = [];
+    if (this._renderPasses) {
+      const b = this._renderPasses[0];
+      this._clippingInfos != null && (b.brushes[0].prepareState(e), b.brushes[0].drawMany(e, this._clippingInfos));
+    }
+    const g = this._backgroundTiles;
+    let p, m = 0;
+    for (const { row: b, colFrom: S, colTo: I } of y)
+      for (let w = S; w <= I; w++) {
+        if (m < g.length)
+          p = g[m], p.key.set(u, b, d.normalizeCol(w), d.getWorldForColumn(w)), l.getTileBounds(_, p.key, !1), p.x = _[0], p.y = _[3], p.resolution = l.getTileResolution(u);
+        else {
+          const x = new M(u, b, d.normalizeCol(w), d.getWorldForColumn(w)), P = l.getTileBounds(F(), x), q = l.getTileResolution(u);
+          p = new Yt(x, q, P[0], P[3], 512, 512, 4096, 4096), g.push(p);
+        }
+        p.setTransform(o), f.push(p), m++;
+      }
+    i.setStencilWriteMask(0), i.setColorMask(!0, !0, !0, !0), i.setStencilOp(k.KEEP, k.KEEP, k.REPLACE), i.setStencilFunction(ue.EQUAL, 0, 255), i.setStencilTestEnabled(!0);
+    for (const b of s) {
+      const S = n.getLayerById(b);
+      S.type === D.BACKGROUND && xe(S, t) && (e.styleLayerUID = S.uid, e.styleLayer = S, r.renderObjects(e, f, "vtlBackground"));
+    }
+    Ce.pool.release(c);
+  }
+  _computeDisplayInfoView(e) {
+    let s = e.tileInfo.lods[0].scale;
+    const t = Math.max(25, e.tileInfo.lods.length), i = [];
+    for (let r = 0; r <= t; r++)
+      i.push(s), s /= 2;
+    this._displayInfo = Re.create({ scales: i, size: 512, spatialReference: e.spatialReference, numLODs: t });
+  }
+};
+const Xt = 8, Zt = 512, Ie = 4096, es = (h, e) => {
+  const s = h.vtlSymbol.sourceTile, t = e.vtlSymbol.sourceTile;
+  return s.level !== t.level ? s.level - t.level : s.row !== t.row ? s.row - t.row : s.col !== t.col ? s.col - t.col : h.styleLayerUID - e.styleLayerUID;
+};
+class ee {
+  constructor(e, s, t, i, r) {
+    this.tileKey = e, this._index = null, this._styleRepository = null, this._tileHandler = null, this._tileKeyToPBF = /* @__PURE__ */ new Map(), this._tileLayerData = s, this._styleRepository = t, this._tileHandler = i, this._parentLayer = r;
+  }
+  static create(e, s, t, i, r) {
+    return new ee(e, s, t, i, r);
+  }
+  clear() {
+    var e;
+    (e = this._index) == null || e.clear(), this._tileKeyToPBF.clear();
+  }
+  async queryAttributes(e, s, t, i, r) {
+    if (this._tileLayerData.size === 0 || !this._styleRepository || !this._tileHandler)
+      return [];
+    this._index === null && (this._index = new _t(100, ts), await this._indexLayers());
+    const o = [];
+    return this._queryIndex(o, e, s, t, this.tileKey.level, i), r && (r == null ? void 0 : r.length) > 0 && await this._getSymbolsAttributes(o, r), o;
+  }
+  async _indexLayers() {
+    const e = this.tileKey, s = this._styleRepository.layers, t = await this._getTilePayload(e);
+    for (const [i, r] of this._tileLayerData) {
+      const o = s[i], n = t.find((c) => c.sourceName === o.source);
+      if (!n)
+        continue;
+      const { protobuff: a, key: l } = n;
+      if (r.type !== L.SYMBOL) {
+        const c = 1 << e.level - l.level, y = e.row - l.row * c, d = e.col - l.col * c;
+        this._indexLayer(o, a, e.level, c, y, d);
+      }
+    }
+  }
+  _indexLayer(e, s, t, i, r, o) {
+    const n = e.sourceLayer, a = e.getFeatureFilter(), l = t, c = t + 1, y = lt(l), d = new X(new Uint8Array(s), new DataView(s));
+    for (; d.next(); )
+      switch (d.tag()) {
+        case 3: {
+          const u = d.getMessage(), _ = new ye(u);
+          if (u.release(), _.name !== n)
+            continue;
+          const f = _.getData(), g = _.extent / i, p = g * o - y, m = g * r - y, b = p + g + 2 * y, S = m + g + 2 * y, I = g / Zt, w = Ie / g, x = g * o, P = g * r;
+          for (; f.nextTag(2); ) {
+            const q = f.getMessage(), H = new de(q, _);
+            if (q.release(), a && !a.filter(H, t))
+              continue;
+            const te = H.values || {}, se = te._minzoom, ie = te._maxzoom;
+            if (se && se >= 10 * c || ie && ie <= 10 * l)
+              continue;
+            const T = e.getFeatureInflatedBounds(H, l, _.extent, I);
+            T == null || T[0] > b || T[1] > S || T[2] < p || T[3] < m || (T[0] = (T[0] - x) * w, T[1] = (T[1] - P) * w, T[2] = (T[2] - x) * w, T[3] = (T[3] - P) * w, this._index.insert(new ft(e, H, T, w, x, P)));
+          }
+          break;
+        }
+        default:
+          d.skip();
+      }
+  }
+  async _getSymbolsAttributes(e, s) {
+    if (!s || s.length === 0)
+      return e;
+    const t = [];
+    s.sort(es);
+    let i = s[0].styleLayerUID, r = 0;
+    for (let l = 0; l < s.length; l++)
+      i !== s[l].styleLayerUID && (t.push({ from: r, to: l, styleLayerUID: i, sourceTileKey: s[l].vtlSymbol.sourceTile }), r = l, i = s[l].styleLayerUID);
+    t.push({ from: r, to: s.length, styleLayerUID: i, sourceTileKey: s[s.length - 1].vtlSymbol.sourceTile });
+    const o = this._styleRepository.layers;
+    let n, a = null;
+    for (const l of t) {
+      const c = await this._getTilePayload(l.sourceTileKey);
+      n = o[l.styleLayerUID], a = !!n && c.find((y) => y.sourceName === n.source), a && this._addSymbolsAttributes(e, s.slice(l.from, l.to).map((y) => y.vtlSymbol), i, a);
+    }
+    return e;
+  }
+  _addSymbolsAttributes(e, s, t, i) {
+    const r = this._styleRepository.layers, o = i.key, n = this.tileKey, a = 1 << n.level - o.level, l = n.row - o.row * a, c = n.col - o.col * a;
+    this._getSymbolAttributes(i.protobuff, s, t, a, l, c).forEach((y) => {
+      const { attributes: d, tilePoint: u } = y;
+      e.push({ layerId: r[t].id, layerIndex: t, graphic: new ae({ attributes: d, origin: { type: "vector-tile", layerId: r[t].id, layerIndex: t, layer: this._parentLayer } }), tilePoint: u });
+    });
+  }
+  _getSymbolAttributes(e, s, t, i, r, o) {
+    const n = [], a = this._styleRepository.layers;
+    let l = 0;
+    s.sort((y, d) => y.featureIndex - d.featureIndex);
+    const c = new X(new Uint8Array(e), new DataView(e));
+    for (; c.next(); )
+      switch (c.tag()) {
+        case 3: {
+          const y = c.getMessage(), d = new ye(y);
+          if (y.release(), d.name !== a[t].sourceLayer)
+            continue;
+          const u = d.getData(), _ = d.extent / i, f = Ie / _, g = _ * o, p = _ * r;
+          let m = 0;
+          for (; u.nextTag(2); ) {
+            const b = u.getMessage();
+            if (m++ === s[l].featureIndex) {
+              const S = new de(b, d), I = S.values, w = S.getGeometry(), x = w != null ? [f * (w[0][0].x - g), f * (w[0][0].y - p)] : null;
+              n.push({ attributes: I, tilePoint: x }), l++;
+            }
+            if (b.release(), l === s.length)
+              return n;
+          }
+          break;
+        }
+        default:
+          c.skip();
+      }
+    return n;
+  }
+  _queryIndex(e, s, t, i, r, o) {
+    var a;
+    const n = Xt * i * (window.devicePixelRatio || 1);
+    return (a = this._index) == null || a.search({ minX: s - n, minY: t - n, maxX: s + n, maxY: t + n }, (l) => {
+      const { layer: c, feature: y } = l;
+      c.isIntersectingFeature(s, t, i, y, r, o, l) && e.push({ layerId: c.id, layerIndex: c.uid, tilePoint: null, graphic: new ae({ attributes: y.values, origin: { type: "vector-tile", layerId: l.layer.id, layerIndex: l.layer.uid, layer: this._parentLayer } }) });
+    }), e;
+  }
+  async _getTilePayload(e) {
+    return Ge(this._tileKeyToPBF, e.id, () => this._tileHandler.fetchTilePBFs(e)).then((s) => s);
+  }
+}
+const ts = (h) => ({ minX: h.bounds[0], minY: h.bounds[1], maxX: h.bounds[2], maxY: h.bounds[3] });
+class Te extends Ye {
+  constructor() {
+    super(...arguments), this._fullCacheLodInfos = null, this._levelByScale = {};
+  }
+  getTileParentId(e) {
+    const s = M.pool.acquire(e), t = s.level === 0 ? null : M.getId(s.level - 1, s.row >> 1, s.col >> 1, s.world);
+    return M.pool.release(s), t;
+  }
+  getTileCoverage(e, s, t = !0, i) {
+    const r = super.getTileCoverage(e, s, t, i);
+    if (!r)
+      return r;
+    const o = 1 << r.lodInfo.level;
+    return r.spans = r.spans.filter((n) => n.row >= 0 && n.row < o), r;
+  }
+  scaleToLevel(e) {
+    if (this._fullCacheLodInfos || this._initializeFullCacheLODs(this._lodInfos), this._levelByScale[e])
+      return this._levelByScale[e];
+    {
+      const s = this._fullCacheLodInfos;
+      if (e > s[0].scale)
+        return s[0].level;
+      let t, i;
+      for (let r = 0; r < s.length - 1; r++)
+        if (i = s[r + 1], e > i.scale)
+          return t = s[r], t.level + (t.scale - e) / (t.scale - i.scale);
+      return s[s.length - 1].level;
+    }
+  }
+  _initializeFullCacheLODs(e) {
+    let s;
+    if (e[0].level === 0)
+      s = e.map((t) => ({ level: t.level, resolution: t.resolution, scale: t.scale }));
+    else {
+      const t = this.tileInfo.size[0], i = this.tileInfo.spatialReference;
+      s = Re.create({ size: t, spatialReference: i }).lods.map((r) => ({ level: r.level, resolution: r.resolution, scale: r.scale }));
+    }
+    for (let t = 0; t < s.length; t++)
+      this._levelByScale[s[t].scale] = s[t].level;
+    this._fullCacheLodInfos = s;
+  }
+}
+const Y = 2, ve = 8, De = 512;
+let W = class extends pt(gt) {
+  constructor() {
+    super(...arguments), this._styleChanges = [], this._fetchQueue = null, this._parseQueue = null, this._tileHandlerPromise = null, this._isTileHandlerReady = !1;
+  }
+  get fading() {
+    var h;
+    return ((h = this._vectorTileContainer) == null ? void 0 : h.fading) ?? !1;
+  }
+  async hitTest(h, e) {
+    var c, y;
+    const s = this._tileHandlerPromise, t = (c = this._vectorTileContainer) == null ? void 0 : c.symbolFader;
+    if (!s || !this._isTileHandlerReady || !t)
+      return;
+    await s;
+    let i = null;
+    const r = (y = this._vectorTileContainer) == null ? void 0 : y.symbolRepository;
+    r && (i = r.querySymbols(e, Y, t.decluttererOffset, {}));
+    const o = this.view.state, n = this._tileManager.getIntersectingTiles(e.x, e.y, Y, o, i);
+    if ((!n || n.length === 0) && (i == null ? void 0 : i.length) === 0)
+      return null;
+    h = h.clone().normalize();
+    const a = [], l = [];
+    for (const d of n)
+      a.push(this._queryTile(l, h, Y, this.view.state.rotation, d, i == null ? void 0 : i.filter((u) => u.tileKey.id === d.id)));
+    return await Promise.all(a), l;
+  }
+  update(h) {
+    if (this._tileHandlerPromise && this._isTileHandlerReady)
+      return h.pixelRatio !== this._tileHandler.devicePixelRatio ? (this._start(), void (this._tileHandler.devicePixelRatio = h.pixelRatio)) : void (this._styleChanges.length > 0 ? this._tileHandlerPromise = this._applyStyleChanges() : (this._fetchQueue.pause(), this._parseQueue.pause(), this._fetchQueue.state = h.state, this._parseQueue.state = h.state, this._tileManager.update(h) || this.requestUpdate(), this._parseQueue.resume(), this._fetchQueue.resume()));
+  }
+  attach() {
+    const { style: h } = this.layer.currentStyleInfo;
+    this._styleRepository = new _e(h), this._tileInfoView = new Te(this.layer.tileInfo, this.layer.fullExtent), this._vectorTileContainer = new jt(this._tileInfoView), this._tileHandler = new St(this.layer, this._styleRepository, window.devicePixelRatio || 1, this.layer.tileInfo.lods.length - 1), this.container.addChild(this._vectorTileContainer), this._start(), this.addAttachHandles([this.layer.on("paint-change", (e) => {
+      var s, t;
+      if (e.isDataDriven)
+        this._styleChanges.push({ type: v.PAINTER_CHANGED, data: e }), this.requestUpdate();
+      else {
+        const i = this._styleRepository, r = i.getLayerById(e.layer);
+        if (!r)
+          return;
+        const o = r.type === D.SYMBOL;
+        i.setPaintProperties(e.layer, e.paint), o && ((s = this._vectorTileContainer) == null || s.restartDeclutter()), (t = this._vectorTileContainer) == null || t.requestRender();
+      }
+    }), this.layer.on("layout-change", (e) => {
+      var r, o;
+      const s = this._styleRepository, t = s.getLayerById(e.layer);
+      if (!t)
+        return;
+      const i = st(t.layout, e.layout);
+      if (i != null) {
+        if (it(i, "visibility") && ss(i) === 1)
+          return s.setLayoutProperties(e.layer, e.layout), t.type === D.SYMBOL && ((r = this._vectorTileContainer) == null || r.restartDeclutter()), void ((o = this._vectorTileContainer) == null ? void 0 : o.requestRender());
+        this._styleChanges.push({ type: v.LAYOUT_CHANGED, data: e }), this.requestUpdate();
+      }
+    }), this.layer.on("style-layer-visibility-change", (e) => {
+      var i, r;
+      const s = this._styleRepository, t = s.getLayerById(e.layer);
+      t && (s.setStyleLayerVisibility(e.layer, e.visibility), t.type === D.SYMBOL && ((i = this._vectorTileContainer) == null || i.restartDeclutter()), (r = this._vectorTileContainer) == null || r.requestRender());
+    }), this.layer.on("style-layer-change", (e) => {
+      this._styleChanges.push({ type: v.LAYER_CHANGED, data: e }), this.requestUpdate();
+    }), this.layer.on("delete-style-layer", (e) => {
+      this._styleChanges.push({ type: v.LAYER_REMOVED, data: e }), this.requestUpdate();
+    }), this.layer.on("load-style", () => this._loadStyle()), this.layer.on("spriteSource-change", (e) => {
+      this._styleChanges.push({ type: v.SPRITES_CHANGED, data: e });
+      const s = this._styleRepository.layers;
+      for (const t of s)
+        switch (t.type) {
+          case D.SYMBOL:
+            t.getLayoutProperty("icon-image") && this._styleChanges.push({ type: v.LAYOUT_CHANGED, data: { layer: t.id, layout: t.layout } });
+            break;
+          case D.LINE:
+            t.getPaintProperty("line-pattern") && this._styleChanges.push({ type: v.PAINTER_CHANGED, data: { layer: t.id, paint: t.paint, isDataDriven: t.isPainterDataDriven() } });
+            break;
+          case D.FILL:
+            t.getLayoutProperty("fill-pattern") && this._styleChanges.push({ type: v.PAINTER_CHANGED, data: { layer: t.id, paint: t.paint, isDataDriven: t.isPainterDataDriven() } });
+        }
+      this.requestUpdate();
+    })]);
+  }
+  detach() {
+    this._stop(), this.container.removeAllChildren(), this._vectorTileContainer = $(this._vectorTileContainer), this._tileHandler = $(this._tileHandler);
+  }
+  moveStart() {
+    this.requestUpdate();
+  }
+  viewChange() {
+    this.requestUpdate();
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  supportsSpatialReference(h) {
+    var e;
+    return je((e = this.layer.tileInfo) == null ? void 0 : e.spatialReference, h);
+  }
+  canResume() {
+    let h = super.canResume();
+    const { currentStyleInfo: e } = this.layer;
+    if (h && (e != null && e.layerDefinition)) {
+      const s = this.view.scale, { minScale: t, maxScale: i } = e.layerDefinition;
+      e != null && e.layerDefinition && (t && t < s && (h = !1), i && i > s && (h = !1));
+    }
+    return h;
+  }
+  isUpdating() {
+    return this.fading;
+  }
+  acquireTile(h) {
+    const e = this._createVectorTile(h);
+    return this._updatingHandles.addPromise(this._fetchQueue.push(e.key).then((s) => this._parseQueue.push({ key: e.key, data: s })).then((s) => {
+      e.once("attach", () => this.requestUpdate()), e.setData(s), this.requestUpdate();
+    }).catch((s) => {
+      j(s) || le.getLogger(this).error(s);
+    })), e;
+  }
+  releaseTile(h) {
+    const e = h.key.id;
+    this._fetchQueue.abort(e), this._parseQueue.abort(e), this.requestUpdate();
+  }
+  _start() {
+    if (this._stop(), this._tileManager = new be({ acquireTile: (s) => this.acquireTile(s), releaseTile: (s) => this.releaseTile(s), tileInfoView: this._tileInfoView }, this._vectorTileContainer), !this.layer.currentStyleInfo)
+      return;
+    const h = new AbortController(), e = this._tileHandler.start({ signal: h.signal }).then(() => {
+      this._fetchQueue = new he({ tileInfoView: this._tileInfoView, process: (s, t) => this._getTileData(s, t), concurrency: 15 }), this._parseQueue = new he({ tileInfoView: this._tileInfoView, process: (s, t) => this._parseTileData(s, t), concurrency: 8 }), this.requestUpdate(), this._isTileHandlerReady = !0;
+    });
+    this._tileHandler.spriteMosaic.then((s) => {
+      this._vectorTileContainer.setStyleResources(s, this._tileHandler.glyphMosaic, this._styleRepository, this._tileInfoView), this.requestUpdate();
+    }), this._tileHandlerAbortController = h, this._tileHandlerPromise = e;
+  }
+  _stop() {
+    if (!this._tileHandlerAbortController || !this._vectorTileContainer)
+      return;
+    const h = this._tileHandlerAbortController;
+    h && h.abort(), this._tileHandlerPromise = null, this._isTileHandlerReady = !1, this._fetchQueue = $(this._fetchQueue), this._parseQueue = $(this._parseQueue), this._tileManager = $(this._tileManager), this._vectorTileContainer.removeAllChildren();
+  }
+  async _getTileData(h, e) {
+    return this._tileHandler.fetchTileData(h, e);
+  }
+  async _parseTileData(h, e) {
+    return this._tileHandler.parseTileData(h, e);
+  }
+  async _applyStyleChanges() {
+    this._isTileHandlerReady = !1, this._fetchQueue.pause(), this._parseQueue.pause(), this._fetchQueue.clear(), this._parseQueue.clear(), this._tileManager.clearCache();
+    const h = this._styleChanges;
+    try {
+      await this._tileHandler.updateStyle(h);
+    } catch (r) {
+      le.getLogger(this).error("error applying vector-tiles style update", r.message), this._fetchQueue.resume(), this._parseQueue.resume(), this._isTileHandlerReady = !0;
+    }
+    const e = this._styleRepository, s = /* @__PURE__ */ new Set();
+    h.forEach((r) => {
+      if (r.type !== v.LAYER_REMOVED)
+        return;
+      const o = r.data, n = e.getLayerById(o.layer);
+      n && s.add(n.uid);
+    });
+    const t = /* @__PURE__ */ new Set();
+    h.forEach((r) => {
+      let o;
+      switch (r.type) {
+        case v.PAINTER_CHANGED:
+          e.setPaintProperties(r.data.layer, r.data.paint), o = r.data.layer;
+          break;
+        case v.LAYOUT_CHANGED:
+          e.setLayoutProperties(r.data.layer, r.data.layout), o = r.data.layer;
+          break;
+        case v.LAYER_REMOVED:
+          return void e.deleteStyleLayer(r.data.layer);
+        case v.LAYER_CHANGED:
+          e.setStyleLayer(r.data.layer, r.data.index), o = r.data.layer.id;
+          break;
+        case v.SPRITES_CHANGED:
+          this._vectorTileContainer.setSpriteMosaic(this._tileHandler.setSpriteSource(r.data.spriteSource));
+      }
+      if (o) {
+        const n = e.getLayerById(o);
+        n && t.add(n.uid);
+      }
+    });
+    const i = this._vectorTileContainer.children;
+    if (s.size > 0) {
+      const r = Array.from(s);
+      this._vectorTileContainer.deleteStyleLayers(r);
+      for (const o of i)
+        o.deleteLayerData(r);
+    }
+    if (this._fetchQueue.resume(), this._parseQueue.resume(), t.size > 0) {
+      const r = Array.from(t), o = [];
+      for (const n of i) {
+        const a = this._updatingHandles.addPromise(this._fetchQueue.push(n.key).then((l) => this._parseQueue.push({ key: n.key, data: l, styleLayerUIDs: r })).then((l) => n.setData(l)));
+        o.push(a);
+      }
+      await Promise.all(o);
+    }
+    this._styleChanges = [], this._isTileHandlerReady = !0, this.requestUpdate();
+  }
+  async _loadStyle() {
+    const { style: h } = this.layer.currentStyleInfo, e = Xe(h);
+    this._isTileHandlerReady = !1, this._fetchQueue.pause(), this._parseQueue.pause(), this._fetchQueue.clear(), this._parseQueue.clear(), this._styleRepository = new _e(e), this._vectorTileContainer.destroy(), this._tileManager.clear(), this._tileHandlerAbortController.abort(), this._tileHandlerAbortController = new AbortController();
+    const { signal: s } = this._tileHandlerAbortController;
+    try {
+      this._tileHandlerPromise = this._tileHandler.setStyle(this._styleRepository, e, this.layer.tileInfo.lods.length - 1), await this._tileHandlerPromise;
+    } catch (r) {
+      if (!j(r))
+        throw r;
+    }
+    if (s.aborted)
+      return this._fetchQueue.resume(), this._parseQueue.resume(), this._isTileHandlerReady = !0, void this.requestUpdate();
+    const t = await this._tileHandler.spriteMosaic, i = this._vectorTileContainer;
+    this._tileInfoView = new Te(this.layer.tileInfo, this.layer.fullExtent), i.setStyleResources(t, this._tileHandler.glyphMosaic, this._styleRepository, this._tileInfoView), this._tileManager = new be({ acquireTile: (r) => this.acquireTile(r), releaseTile: (r) => this.releaseTile(r), tileInfoView: this._tileInfoView }, this._vectorTileContainer), this._fetchQueue.resume(), this._parseQueue.resume(), this._isTileHandlerReady = !0, this.requestUpdate();
+  }
+  _createVectorTile(h) {
+    const e = this._tileInfoView.getTileBounds(F(), h), s = this._tileInfoView.getTileResolution(h.level);
+    return new $t(h, s, e[0], e[3], 512, 512, this._styleRepository);
+  }
+  async _queryTile(h, e, s, t, i, r) {
+    if (i.layerData.size === 0)
+      return;
+    const o = this._ensureTileIndex(i), n = this._tileInfoView.getTileBounds(F(), i.key, !0), a = ve * De * ((e.x - n[0]) / (n[2] - n[0])), l = ve * De * (1 - (e.y - n[1]) / (n[3] - n[1])), c = await o.queryAttributes(a, l, s, t, r);
+    for (const y of c)
+      y.graphic.geometry = this._tileToMapPoint(y.tilePoint, i.transforms.tileUnitsToPixels), h.push({ type: "graphic", layer: this.layer, graphic: y.graphic, mapPoint: e.clone() });
+    h.sort((y, d) => d.graphic.origin.layerIndex - y.graphic.origin.layerIndex);
+  }
+  _tileToMapPoint(h, e) {
+    if (!h)
+      return null;
+    const s = h[0] * e[0] + h[1] * e[3] + e[6], t = h[0] * e[1] + h[1] * e[4] + e[7], i = this.view.state, r = [0, 0];
+    return i.toMap(r, [s, t]), new Ze({ x: r[0], y: r[1], spatialReference: i.spatialReference });
+  }
+  _ensureTileIndex(h) {
+    let e = h.featureIndex;
+    return e || (e = ee.create(h.key, h.layerData, this._styleRepository, this._tileHandler, this.layer), h.featureIndex = e), e;
+  }
+};
+function ss(h) {
+  if (h == null)
+    return 0;
+  switch (h.type) {
+    case "partial":
+      return Object.keys(h.diff).length;
+    case "complete":
+      return Math.max(Object.keys(h.oldValue).length, Object.keys(h.newValue).length);
+    case "collection":
+      return Object.keys(h.added).length + Object.keys(h.changed).length + Object.keys(h.removed).length;
+  }
+}
+ce([et()], W.prototype, "_isTileHandlerReady", void 0), W = ce([tt("esri.views.2d.layers.VectorTileLayerView2D")], W);
+const ai = W;
+export {
+  ai as default
+};