@thibezer/ui-components-kit 2.8.2 → 2.10.0

package/dist/motor-CFI84lM2.js

@@ -0,0 +1,1301 @@
+var At = Object.defineProperty;
+var yt = (e, t, a) => t in e ? At(e, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[t] = a;
+var M = (e, t, a) => yt(e, typeof t != "symbol" ? t + "" : t, a);
+function z(e) {
+  return e.partes && e.partes.length > 1 ? e.partes : [e.coordenadas];
+}
+function La(e) {
+  return e.tipo === "LineString" && !!e.partes && e.partes.length > 1;
+}
+function Ct(e) {
+  return e.length > 1 ? { tipo: "LineString", coordenadas: e[0], partes: e } : { tipo: "LineString", coordenadas: e[0] };
+}
+const R = 6378137, V = 1 / 298.257222101, W = V * (2 - V), A = (e) => e * Math.PI / 180;
+function Q(e) {
+  const t = Math.sin(A(e)), a = 1 - W * t * t;
+  return { N: R / Math.sqrt(a), M: R * (1 - W) / (a * Math.sqrt(a)) };
+}
+function Pa(e) {
+  const { M: t, N: a } = Q(e);
+  return { lat: A(1) * t, lng: A(1) * a * Math.cos(A(e)) };
+}
+function It(e, t) {
+  const a = R * (1 - V), o = V, i = A(t[1] - e[1]), n = Math.atan((1 - o) * Math.tan(A(e[0]))), s = Math.atan((1 - o) * Math.tan(A(t[0]))), r = Math.sin(n), c = Math.cos(n), l = Math.sin(s), d = Math.cos(s);
+  let h = i, u = 0, v = 0, x = 0, f = 0, m = 0;
+  for (let g = 0; g < 100; g++) {
+    const p = Math.sin(h), P = Math.cos(h);
+    if (u = Math.hypot(d * p, c * l - r * d * P), u === 0) return 0;
+    v = r * l + c * d * P, x = Math.atan2(u, v);
+    const D = c * d * p / u;
+    f = 1 - D * D, m = f === 0 ? 0 : v - 2 * r * l / f;
+    const C = o / 16 * f * (4 + o * (4 - 3 * f)), O = h;
+    if (h = i + (1 - C) * o * D * (x + C * u * (m + C * v * (-1 + 2 * m * m))), Math.abs(h - O) < 1e-12) break;
+  }
+  const L = f * (R * R - a * a) / (a * a), w = 1 + L / 16384 * (4096 + L * (-768 + L * (320 - 175 * L))), I = L / 1024 * (256 + L * (-128 + L * (74 - 47 * L))), y = I * u * (m + I / 4 * (v * (-1 + 2 * m * m) - I / 6 * m * (-3 + 4 * u * u) * (-3 + 4 * m * m)));
+  return a * w * (x - y);
+}
+function tt(e, t) {
+  const a = t[0] - e[0], o = t[1] - e[1];
+  if (Math.abs(a) < 0.1 && Math.abs(o) < 0.1) {
+    const { M: i, N: n } = Q((e[0] + t[0]) / 2), s = A(a) * i, r = A(o) * n * Math.cos(A((e[0] + t[0]) / 2));
+    return Math.hypot(r, s);
+  }
+  return It(e, t);
+}
+function at(e, t = !1) {
+  let a = 0;
+  for (let o = 1; o < e.length; o++) a += tt(e[o - 1], e[o]);
+  return t && e.length > 2 && (a += tt(e[e.length - 1], e[0])), a;
+}
+function ot(e) {
+  const t = e.length;
+  if (t < 3) return 0;
+  let a = 0, o = 0;
+  for (let r = 0; r < t; r++) {
+    const c = e[(r - 1 + t) % t], l = e[r], d = e[(r + 1) % t];
+    a += A(d[1] - c[1]) * Math.sin(A(l[0])), o += l[0];
+  }
+  const { M: i, N: n } = Q(o / t), s = Math.abs(a * i * n / 2);
+  return Number.isFinite(s) ? s : 0;
+}
+function St(e) {
+  const [t, ...a] = e;
+  return t ? Math.max(0, ot(t) - a.reduce((o, i) => o + ot(i), 0)) : 0;
+}
+const bt = new Intl.NumberFormat("pt-BR", { minimumFractionDigits: 4, maximumFractionDigits: 4 }), et = new Intl.NumberFormat("pt-BR", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+function Ot(e) {
+  return `${bt.format(e / 1e4)} ha`;
+}
+function Nt(e) {
+  return e >= 1e3 ? `${et.format(e / 1e3)} km` : `${et.format(e)} m`;
+}
+function wt(e) {
+  return e.tipo === "Polygon" ? St(e.aneis) : e.tipo === "Circle" ? Math.PI * e.raioMetros ** 2 : null;
+}
+function Et(e) {
+  return e.tipo === "LineString" ? z(e).reduce((t, a) => t + at(a), 0) : e.tipo === "Polygon" ? at(e.aneis[0] ?? [], !0) : e.tipo === "Circle" ? 2 * Math.PI * e.raioMetros : null;
+}
+function Ft(e, t) {
+  var i;
+  const a = t ?? "name";
+  if (a === "area") {
+    const n = wt(e.geometria);
+    return n === null ? "" : Ot(n);
+  }
+  if (a === "extensao") {
+    const n = Et(e.geometria);
+    return n === null ? "" : Nt(n);
+  }
+  if (a === "id") return e.id;
+  const o = (i = e.propriedades) == null ? void 0 : i[a];
+  return o != null && o !== "" ? String(o) : t ? "" : e.id;
+}
+function Rt(e) {
+  let t;
+  switch (e.tipo) {
+    case "Point":
+    case "Text":
+      t = [e.coordenada];
+      break;
+    case "LineString":
+      t = z(e).flat();
+      break;
+    case "Polygon":
+      t = e.aneis.flat();
+      break;
+    case "Circle": {
+      const i = e.raioMetros / 111320, n = i / Math.max(0.01, Math.cos(A(e.centro[0])));
+      t = [[e.centro[0] - i, e.centro[1] - n], [e.centro[0] + i, e.centro[1] + n]];
+      break;
+    }
+  }
+  const a = t.map((i) => i[0]), o = t.map((i) => i[1]);
+  return [[Math.min(...a), Math.min(...o)], [Math.max(...a), Math.max(...o)]];
+}
+const j = 16, zt = 256;
+function it(e) {
+  const [[t, a], [o, i]] = Rt(e.geometria);
+  return { minLon: a, minLat: t, maxLon: i, maxLat: o };
+}
+function $(e, t) {
+  return e.minLon <= t.maxLon && e.maxLon >= t.minLon && e.minLat <= t.maxLat && e.maxLat >= t.minLat;
+}
+function nt(e) {
+  let t = 1 / 0, a = 1 / 0, o = -1 / 0, i = -1 / 0;
+  for (const n of e)
+    n.minLon < t && (t = n.minLon), n.minLat < a && (a = n.minLat), n.maxLon > o && (o = n.maxLon), n.maxLat > i && (i = n.maxLat);
+  return { minLon: t, minLat: a, maxLon: o, maxLat: i };
+}
+function st(e) {
+  const t = e.length, a = Math.ceil(t / j), i = Math.ceil(Math.sqrt(a)) * j, n = [...e].sort((r, c) => r.minLon + r.maxLon - (c.minLon + c.maxLon)), s = [];
+  for (let r = 0; r < t; r += i) {
+    const c = n.slice(r, r + i).sort((l, d) => l.minLat + l.maxLat - (d.minLat + d.maxLat));
+    for (let l = 0; l < c.length; l += j) s.push(c.slice(l, l + j));
+  }
+  return s;
+}
+function jt(e) {
+  if (e.length === 0) return null;
+  let t = st(e).map((a) => ({ ...nt(a), folhas: a }));
+  for (; t.length > 1; )
+    t = st(t).map((a) => ({ ...nt(a), filhos: a }));
+  return t[0];
+}
+class _t {
+  constructor() {
+    M(this, "raiz", null);
+    /** Itens vivos: a fonte da verdade (a árvore pode conter itens já removidos/atualizados). */
+    M(this, "itens", /* @__PURE__ */ new Map());
+    /** Itens que entraram ou mudaram depois da última montagem. */
+    M(this, "delta", /* @__PURE__ */ new Map());
+    /** Ids que estão na árvore mas foram removidos ou substituídos. */
+    M(this, "obsoletos", /* @__PURE__ */ new Set());
+  }
+  get tamanho() {
+    return this.itens.size;
+  }
+  construir(t) {
+    this.itens.clear();
+    for (const a of t)
+      a.excluida || this.itens.set(a.id, { id: a.id, ...it(a) });
+    this.remontar();
+  }
+  inserir(t) {
+    this.atualizar(t);
+  }
+  /** Insere ou substitui; feição `excluida` sai do índice. */
+  atualizar(t) {
+    if (t.excluida) {
+      this.remover(t.id);
+      return;
+    }
+    const a = { id: t.id, ...it(t) };
+    this.itens.has(t.id) && this.obsoletos.add(t.id), this.itens.set(t.id, a), this.delta.set(t.id, a), this.compactarSeNecessario();
+  }
+  remover(t) {
+    this.itens.delete(t) && (this.obsoletos.add(t), this.delta.delete(t), this.compactarSeNecessario());
+  }
+  limpar() {
+    this.itens.clear(), this.remontar();
+  }
+  /** Ids das feições cujo envelope toca `caixa`. */
+  consultar(t) {
+    const a = [], o = this.raiz ? [this.raiz] : [];
+    for (; o.length > 0; ) {
+      const i = o.pop();
+      if ($(i, t))
+        if (i.folhas)
+          for (const n of i.folhas)
+            !this.obsoletos.has(n.id) && $(n, t) && a.push(n.id);
+        else i.filhos && o.push(...i.filhos);
+    }
+    for (const i of this.delta.values()) $(i, t) && a.push(i.id);
+    return a;
+  }
+  intersecta(t) {
+    return this.consultar(t).length > 0;
+  }
+  /** Envelope da feição indexada, se houver. */
+  caixaDe(t) {
+    return this.itens.get(t);
+  }
+  compactarSeNecessario() {
+    this.delta.size + this.obsoletos.size > Math.max(zt, this.itens.size * 0.1) && this.remontar();
+  }
+  remontar() {
+    this.raiz = jt([...this.itens.values()]), this.delta.clear(), this.obsoletos.clear();
+  }
+}
+const pt = 17, J = 9, Tt = 1.2;
+function $t(e) {
+  return !Number.isFinite(e) || e >= pt ? 0 : 360 / (256 * 2 ** e) * Tt;
+}
+function rt(e) {
+  return Number.isFinite(e) ? 1 / Math.max(0.05, Math.cos(Math.max(-85, Math.min(85, e)) * Math.PI / 180)) : 1;
+}
+function Bt(e, t, a, o) {
+  const i = a[1] - t[1], n = (a[0] - t[0]) * o, s = i * i + n * n, r = (e[0] - t[0]) * o;
+  let c = s === 0 ? 0 : ((e[1] - t[1]) * i + r * n) / s;
+  return c = Math.max(0, Math.min(1, c)), Math.hypot(e[1] - (t[1] + c * i), r - c * n);
+}
+function gt(e, t, a = 1) {
+  if (!(t > 0) || e.length < 3) return e;
+  const o = Number.isFinite(a) && a > 0 ? a : 1, i = new Uint8Array(e.length);
+  i[0] = 1, i[e.length - 1] = 1;
+  const n = [[0, e.length - 1]];
+  for (; n.length > 0; ) {
+    const [s, r] = n.pop();
+    let c = 0, l = -1;
+    for (let d = s + 1; d < r; d++) {
+      const h = Bt(e[d], e[s], e[r], o);
+      h > c && (c = h, l = d);
+    }
+    l !== -1 && c > t && (i[l] = 1, n.push([s, l], [l, r]));
+  }
+  return e.filter((s, r) => i[r] === 1);
+}
+function Vt(e, t, a = 1) {
+  if (!(t > 0) || e.length < 4) return e;
+  const o = [...e, e[0]], i = gt(o, t, a);
+  return i.pop(), i.length >= 3 ? i : e;
+}
+function kt(e) {
+  return (e.tipo === "LineString" || e.tipo === "Polygon") && e.curva ? 0 : e.tipo === "LineString" ? z(e).reduce((t, a) => t + a.length, 0) : e.tipo === "Polygon" ? e.aneis.reduce((t, a) => t + a.length, 0) : 0;
+}
+function Da(e, t) {
+  var o, i, n, s;
+  const a = $t(t);
+  if (a === 0 || kt(e) < J) return e;
+  if (e.tipo === "LineString") {
+    const r = z(e), c = rt(((i = (o = r[0]) == null ? void 0 : o[0]) == null ? void 0 : i[0]) ?? NaN);
+    return Ct(r.map((l) => gt(l, a, c)));
+  }
+  if (e.tipo === "Polygon") {
+    const r = rt(((s = (n = e.aneis[0]) == null ? void 0 : n[0]) == null ? void 0 : s[0]) ?? NaN);
+    return { tipo: "Polygon", aneis: e.aneis.map((c) => Vt(c, a, r)) };
+  }
+  return e;
+}
+const qt = /* @__PURE__ */ new Set(["previa", "prévia", "preview", "rascunho", "draft", "proposta"]);
+function S(e) {
+  var a, o;
+  const t = [e.status, (a = e.propriedades) == null ? void 0 : a.status, (o = e.propriedades) == null ? void 0 : o.tipo_geometria];
+  for (const i of t)
+    if (typeof i == "string" && qt.has(i.trim().toLowerCase())) return "previa";
+  return "oficial";
+}
+function b(e) {
+  var a;
+  const t = e.entidadeId ?? ((a = e.propriedades) == null ? void 0 : a.entidadeId);
+  return typeof t == "string" || typeof t == "number" ? String(t) : e.id;
+}
+const G = (e, t) => `${e}\0${t}`;
+class Aa {
+  constructor() {
+    /** Mostra as prévias de todas as entidades. */
+    M(this, "global", !1);
+    M(this, "individuais", /* @__PURE__ */ new Set());
+  }
+  alternarIndividual(t, a) {
+    const o = G(t, a);
+    return this.individuais.has(o) ? this.individuais.delete(o) : this.individuais.add(o), this.individuais.has(o);
+  }
+  definirIndividual(t, a, o) {
+    const i = G(t, a);
+    o ? this.individuais.add(i) : this.individuais.delete(i);
+  }
+  individualAtiva(t, a) {
+    return this.individuais.has(G(t, a));
+  }
+  /** Entidades da camada que têm geometria oficial. */
+  static oficiais(t) {
+    const a = /* @__PURE__ */ new Set();
+    for (const o of t) !o.excluida && S(o) === "oficial" && a.add(b(o));
+    return a;
+  }
+  /** A feição aparece? `comOficial` = entidades da camada com geometria oficial (ver `oficiais`). */
+  visivel(t, a) {
+    if (S(t) === "oficial") return !0;
+    const o = b(t);
+    return this.global || !a.has(o) || this.individualAtiva(t.camadaId, o);
+  }
+  /** A prévia está sendo mostrada por pedido (global ou individual), e não só por falta de oficial? */
+  previaSolicitada(t) {
+    return this.global || this.individualAtiva(t.camadaId, b(t));
+  }
+}
+const Ut = 24, Xt = 2, ct = (e) => typeof e == "number" && Number.isFinite(e), Z = (e) => Array.isArray(e) && e.length === 2 && ct(e[0]) && ct(e[1]);
+function ya(e, t) {
+  return [2 * e[0] - t[0], 2 * e[1] - t[1]];
+}
+function Gt(e) {
+  return e.some((t) => t.entrada !== void 0 || t.saida !== void 0);
+}
+function vt(e, t) {
+  return [e.saida ?? e.ponto, t.entrada ?? t.ponto];
+}
+function Mt(e, t) {
+  const a = [];
+  for (let o = 0; o < e - 1; o++) a.push([o, o + 1]);
+  return t && e > 2 && a.push([e - 1, 0]), a;
+}
+function Zt(e, t, a, o, i) {
+  const n = 1 - i, s = n * n * n, r = 3 * n * n * i, c = 3 * n * i * i, l = i * i * i;
+  return [s * e[0] + r * t[0] + c * a[0] + l * o[0], s * e[1] + r * t[1] + c * a[1] + l * o[1]];
+}
+function Ca(e, t = !1, a = Ut) {
+  if (e.length === 0) return [];
+  const o = [[e[0].ponto[0], e[0].ponto[1]]];
+  for (const [i, n] of Mt(e.length, t)) {
+    const s = e[i], r = e[n];
+    if (!(s.saida === void 0 && r.entrada === void 0)) {
+      const [l, d] = vt(s, r);
+      for (let h = 1; h < a; h++) o.push(Zt(s.ponto, l, d, r.ponto, h / a));
+    }
+    n !== 0 && o.push([r.ponto[0], r.ponto[1]]);
+  }
+  return o;
+}
+function Ht(e, t) {
+  if (e.length === 0) return [];
+  const a = [{ cmd: "M", pts: [e[0].ponto] }];
+  for (const [o, i] of Mt(e.length, t)) {
+    const n = e[o], s = e[i];
+    if (n.saida === void 0 && s.entrada === void 0)
+      a.push({ cmd: "L", pts: [s.ponto] });
+    else {
+      const [r, c] = vt(n, s);
+      a.push({ cmd: "C", pts: [r, c, s.ponto] });
+    }
+  }
+  return a;
+}
+function Ia(e, t, a) {
+  const o = (n) => String(Math.round(n * 100) / 100), i = Ht(e, t).map((n) => n.cmd + n.pts.map((s) => {
+    const r = a(s);
+    return `${o(r.x)} ${o(r.y)}`;
+  }).join(" ")).join("");
+  return i && t ? `${i}Z` : i;
+}
+function Sa(e, t = Xt) {
+  if (!Array.isArray(e) || e.length < t) return null;
+  const a = [];
+  for (const o of e) {
+    if (!o || typeof o != "object" || !Z(o.ponto)) return null;
+    const i = o, n = { ponto: [i.ponto[0], i.ponto[1]] };
+    Z(i.entrada) && (n.entrada = [i.entrada[0], i.entrada[1]]), Z(i.saida) && (n.saida = [i.saida[0], i.saida[1]]), a.push(n);
+  }
+  return Gt(a) ? a : null;
+}
+function ba(e, t) {
+  return e.map((a) => {
+    const o = { ponto: t(a.ponto) };
+    return a.entrada && (o.entrada = t(a.entrada)), a.saida && (o.saida = t(a.saida)), o;
+  });
+}
+function dt(e) {
+  return e.tipo === "LineString" ? e.curva && e.curva.length >= 2 && !(e.partes && e.partes.length > 1) ? e.curva : null : e.tipo === "Polygon" && e.curva && e.curva.length >= 3 && e.aneis.length === 1 ? e.curva : null;
+}
+const k = 55, Jt = 17, Yt = 8;
+function xt(e, t) {
+  return t < Jt && e > Yt;
+}
+function Qt(e) {
+  let t = 0, a = 0;
+  for (const o of e)
+    t += o.coordenada[0], a += o.coordenada[1];
+  return [t / e.length, a / e.length];
+}
+function Oa(e, t, a) {
+  if (!xt(e.length, t)) return { clusters: [], isolados: e };
+  const o = /* @__PURE__ */ new Map();
+  for (const s of e) {
+    const { x: r, y: c } = a(s.coordenada), l = `${t}:${Math.floor(r / k)}:${Math.floor(c / k)}`, d = o.get(l);
+    d ? d.push(s) : o.set(l, [s]);
+  }
+  const i = [], n = [];
+  for (const [s, r] of o)
+    r.length === 1 ? n.push(r[0]) : i.push({ chave: s, coordenada: Qt(r), membros: r });
+  return { clusters: i, isolados: n };
+}
+class Kt {
+  constructor(t, a) {
+    M(this, "celulas", /* @__PURE__ */ new Map());
+    M(this, "celulaDe", /* @__PURE__ */ new Map());
+    /** Chaves das células com 2 ou mais pontos (as únicas que viram cluster). */
+    M(this, "multiplas", /* @__PURE__ */ new Set());
+    this.zoom = t, this.projetar = a;
+  }
+  /** Pontos agrupáveis na grade. */
+  get total() {
+    return this.celulaDe.size;
+  }
+  /** Chave da célula do ponto, ou `undefined` se ele não está na grade. */
+  chaveDoPonto(t) {
+    return this.celulaDe.get(t);
+  }
+  celula(t) {
+    return this.celulas.get(t);
+  }
+  /** Só as células que viram cluster (2+ pontos). */
+  *celulasAgrupadas() {
+    for (const t of this.multiplas) {
+      const a = this.celulas.get(t);
+      a && (yield [t, a]);
+    }
+  }
+  /** Está numa célula com 2 ou mais pontos (ou seja, dentro de um cluster)? */
+  emCluster(t) {
+    var o;
+    const a = this.celulaDe.get(t);
+    return a !== void 0 && (((o = this.celulas.get(a)) == null ? void 0 : o.membros.size) ?? 0) >= 2;
+  }
+  /** Insere (ou move) o ponto; devolve a chave da célula nova. */
+  inserir(t) {
+    this.remover(t.id);
+    const { x: a, y: o } = this.projetar(t.coordenada), i = `${this.zoom}:${Math.floor(a / k)}:${Math.floor(o / k)}`;
+    let n = this.celulas.get(i);
+    return n || (n = { membros: /* @__PURE__ */ new Map(), somaLat: 0, somaLon: 0 }, this.celulas.set(i, n)), n.membros.set(t.id, t), n.somaLat += t.coordenada[0], n.somaLon += t.coordenada[1], n.membros.size >= 2 && this.multiplas.add(i), this.celulaDe.set(t.id, i), i;
+  }
+  /** Tira o ponto da grade; devolve a chave da célula de onde saiu. */
+  remover(t) {
+    const a = this.celulaDe.get(t);
+    if (a === void 0) return;
+    this.celulaDe.delete(t);
+    const o = this.celulas.get(a), i = o == null ? void 0 : o.membros.get(t);
+    return o && i && (o.membros.delete(t), o.somaLat -= i.coordenada[0], o.somaLon -= i.coordenada[1], o.membros.size < 2 && this.multiplas.delete(a), o.membros.size === 0 && this.celulas.delete(a)), a;
+  }
+}
+const Wt = 3, Lt = 0.75, lt = 85.0511287798, ta = 256;
+function Y(e, t, a) {
+  const o = ta * 2 ** a, i = Math.max(-lt, Math.min(lt, e)), n = Math.sin(i * Math.PI / 180);
+  return {
+    x: (t + 180) / 360 * o,
+    y: (0.5 - Math.log((1 + n) / (1 - n)) / (4 * Math.PI)) * o
+  };
+}
+const aa = (e) => Number.isFinite(e.minLat) && Number.isFinite(e.maxLat) && Number.isFinite(e.minLon) && Number.isFinite(e.maxLon) && e.minLat <= e.maxLat && e.minLon <= e.maxLon;
+function Pt(e, t) {
+  if (!Number.isFinite(t) || t < 0 || !aa(e)) return NaN;
+  const a = Y(e.minLat, e.minLon, t), o = Y(e.maxLat, e.maxLon, t);
+  return Math.hypot(o.x - a.x, o.y - a.y);
+}
+function oa(e, t, a = Wt) {
+  if (!e) return !1;
+  const o = Pt(e, t);
+  return Number.isFinite(o) && o < a;
+}
+function ea(e) {
+  return Number.isFinite(e) && e < 1.5 ? 1 : 2;
+}
+function ia(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const a of e) {
+    const o = t.get(a.cor);
+    o ? o.push(a) : t.set(a.cor, [a]);
+  }
+  return t;
+}
+const na = "#38bdf8";
+function Na(e, t, a, o, i, n, s) {
+  let r = 0;
+  const c = ia(t);
+  for (const [l, d] of c) {
+    let h = !1;
+    for (const u of d) {
+      const v = Y(u.lat, u.lon, a), x = v.x - o, f = v.y - i;
+      x >= -2 && f >= -2 && x <= n + 2 && f <= s + 2 && (h || (e.fillStyle = l || na, e.globalAlpha = Lt, h = !0), e.fillRect(Math.round(x - u.lado / 2), Math.round(f - u.lado / 2), u.lado, u.lado), r++);
+    }
+  }
+  return r;
+}
+const q = "#38bdf8", sa = "#38bdf8", ra = /^(#[0-9a-f]{3,8}|(rgb|hsl)a?\([0-9.,%\s\/-]+\)|[a-z]{3,20})$/i;
+function B(e, t) {
+  return typeof e == "string" && ra.test(e.trim()) ? e.trim() : t;
+}
+const F = (e) => typeof e == "number" && Number.isFinite(e);
+function ut(e, t, a = !1) {
+  const o = e.estilo ?? {}, i = B(o.corTraco ?? t.corPrimaria, q), n = e.geometria.tipo, s = n === "Polygon" || n === "Circle", r = n === "Point", c = r && B(o.corContorno, "") || i, l = r && F(o.espessuraContorno) && o.espessuraContorno >= 0 ? o.espessuraContorno : void 0, d = l ?? (F(o.espessuraTraco) ? o.espessuraTraco : void 0) ?? (F(t.espessuraLinha) ? t.espessuraLinha : 2), h = F(o.opacidadePreenchimento) ? o.opacidadePreenchimento : s ? 0.2 : 0.85;
+  return {
+    cor: a ? sa : c,
+    traco: !(l === 0 && !a),
+    peso: a ? d + 2 : d,
+    dash: o.dashArray ?? (S(e) === "previa" ? "6 4" : t.dashArray),
+    preencher: s || r,
+    corPreenchimento: B(o.corPreenchimento, i),
+    opacidadePreenchimento: a ? Math.min(1, h + 0.18) : h
+  };
+}
+function ca(e, t) {
+  var o;
+  const a = ((o = e.estilo) == null ? void 0 : o.tamanhoIcone) ?? t.tamanhoMarcador ?? 8;
+  return (F(a) && a > 0 ? a : 8) / 2;
+}
+class da {
+  constructor() {
+    M(this, "porChave", /* @__PURE__ */ new Map());
+  }
+  interno(t) {
+    const a = `${t.cor}|${t.traco ? 1 : 0}|${t.peso}|${t.dash ?? ""}|${t.preencher ? 1 : 0}|${t.corPreenchimento}|${t.opacidadePreenchimento}`, o = this.porChave.get(a);
+    return o || (this.porChave.set(a, t), t);
+  }
+  limpar() {
+    this.porChave.clear();
+  }
+}
+const la = 0.3, ht = (e) => !!e && typeof e.id == "string" && !!e.geometria && typeof e.geometria.tipo == "string";
+class ua {
+  constructor() {
+    M(this, "loja", /* @__PURE__ */ new Map());
+    M(this, "indice", new _t());
+    /** Muda a cada alteração dos dados (invalida cache de geometria por feição). */
+    M(this, "revisao", 0);
+    /** Muda quando o agrupamento e a contagem de pontos precisam ser refeitos do zero. */
+    M(this, "revisaoBase", 0);
+    M(this, "listaSincronizada", null);
+    /** Entidades com geometria oficial, e quantas oficiais cada uma tem. */
+    M(this, "oficiais", /* @__PURE__ */ new Set());
+    M(this, "contOficiais", /* @__PURE__ */ new Map());
+    /** Entidade -> quantas prévias (entidade com oficial E prévia forma um par: sempre em detalhe completo). */
+    M(this, "contPrevias", /* @__PURE__ */ new Map());
+    M(this, "nPrevias", 0);
+    M(this, "selecionadas", /* @__PURE__ */ new Set());
+    M(this, "regra", null);
+    /** Revisão por feição (id → número crescente): chave do cache de geometria projetada. */
+    M(this, "revisaoDe", /* @__PURE__ */ new Map());
+    M(this, "contador", 0);
+  }
+  revisaoDaFeicao(t) {
+    return this.revisaoDe.get(t) ?? 0;
+  }
+  /** Aparece segundo a regra (não oculta e visível por versão)? */
+  desenhavel(t) {
+    return t.oculta ? !1 : !this.regra || this.regra(t, this.oficiais);
+  }
+  /** Visível pela regra de versões (ignora `oculta`: o hit-test e a seleção seguem regras próprias). */
+  visivelPorVersao(t) {
+    return !this.regra || this.regra(t, this.oficiais);
+  }
+  /** Troca total: diferencia contra a loja, mantém o índice e a contabilidade de versões. */
+  sincronizar(t) {
+    const a = t.filter((s) => ht(s) && !s.excluida), o = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+    for (const s of a)
+      i.add(s.id), this.loja.get(s.id) !== s && o.add(s.id);
+    const n = [...this.loja.keys()].filter((s) => !i.has(s));
+    if (o.size > 0 || n.length > 0) {
+      if (this.revisao++, this.revisaoBase++, this.loja.size === 0 || o.size + n.length > a.length * la)
+        this.indice.construir(a);
+      else {
+        for (const s of a) o.has(s.id) && this.indice.atualizar(s);
+        for (const s of n) this.indice.remover(s);
+      }
+      this.loja.clear();
+      for (const s of a) this.loja.set(s.id, s);
+      for (const s of n) this.revisaoDe.delete(s);
+      for (const s of o) this.revisaoDe.set(s, ++this.contador);
+      this.recontarOficiais();
+    }
+    this.listaSincronizada = t;
+    for (const s of [...this.selecionadas]) i.has(s) || this.selecionadas.delete(s);
+    return { mudadas: [...o], removidas: n, oficiaisMudou: !1 };
+  }
+  recontarOficiais() {
+    this.contOficiais = /* @__PURE__ */ new Map(), this.contPrevias = /* @__PURE__ */ new Map(), this.nPrevias = 0;
+    for (const t of this.loja.values()) {
+      if (S(t) !== "oficial") {
+        this.nPrevias++;
+        const o = b(t);
+        this.contPrevias.set(o, (this.contPrevias.get(o) ?? 0) + 1);
+        continue;
+      }
+      const a = b(t);
+      this.contOficiais.set(a, (this.contOficiais.get(a) ?? 0) + 1);
+    }
+    this.oficiais = new Set(this.contOficiais.keys());
+  }
+  /** Aplica só a diferença. Devolve `null` se o delta não parte da lista sincronizada (então use `sincronizar`). */
+  aplicarDelta(t, a) {
+    if (!a || a.base !== this.listaSincronizada) return null;
+    const o = /* @__PURE__ */ new Map(), i = (d, h) => {
+      if (!d || d.excluida || S(d) !== "oficial") return;
+      const u = b(d);
+      o.has(u) || o.set(u, this.oficiais.has(u));
+      const v = (this.contOficiais.get(u) ?? 0) + h;
+      v <= 0 ? (this.contOficiais.delete(u), this.oficiais.delete(u)) : (this.contOficiais.set(u, v), this.oficiais.add(u));
+    }, n = (d, h) => {
+      const u = b(d), v = (this.contPrevias.get(u) ?? 0) + h;
+      v <= 0 ? this.contPrevias.delete(u) : this.contPrevias.set(u, v);
+    }, s = [], r = [], c = (d) => {
+      const h = this.loja.get(d);
+      h && (S(h) === "previa" && (this.nPrevias--, n(h, -1)), i(h, -1), this.loja.delete(d), this.indice.remover(d), this.selecionadas.delete(d), this.revisaoDe.delete(d), r.push(d));
+    };
+    for (const d of a.removidas ?? []) c(d);
+    for (const d of a.mudadas ?? []) {
+      if (!ht(d)) continue;
+      if (d.excluida) {
+        c(d.id);
+        continue;
+      }
+      const h = this.loja.get(d.id);
+      S(d) === "previa" && (this.nPrevias++, n(d, 1)), h && (S(h) === "previa" && (this.nPrevias--, n(h, -1)), i(h, -1)), this.loja.set(d.id, d), this.indice.atualizar(d), i(d, 1), this.revisaoDe.set(d.id, ++this.contador), s.push(d.id);
+    }
+    let l = !1;
+    if (this.nPrevias > 0)
+      for (const [d, h] of o) h !== this.oficiais.has(d) && (l = !0);
+    return this.listaSincronizada = t, this.revisao++, l && this.revisaoBase++, { mudadas: s, removidas: r, oficiaisMudou: l };
+  }
+}
+const ha = 256, N = 85.0511287798, fa = 4007501668557849e-8;
+function Dt(e, t, a, o, i) {
+  const n = a > N ? N : a < -N ? -N : a, s = Math.sin(n * Math.PI / 180);
+  e[t] = (o + 180) / 360 * i, e[t + 1] = (0.5 - Math.log((1 + s) / (1 - s)) / (4 * Math.PI)) * i;
+}
+const U = (e) => ha * 2 ** e;
+function wa(e, t, a) {
+  const o = U(a);
+  return [Math.atan(Math.sinh(Math.PI * (1 - 2 * t / o))) * 180 / Math.PI, e / o * 360 - 180];
+}
+function ft(e, t) {
+  const a = U(t), o = new Float64Array(e.length * 2);
+  for (let i = 0; i < e.length; i++) {
+    const n = e[i];
+    Dt(o, i * 2, n[0], n[1], a);
+  }
+  return o;
+}
+function E(e, t, a) {
+  const o = new Float64Array(2);
+  return Dt(o, 0, e, t, U(a)), o;
+}
+function ma(e, t) {
+  const a = Math.max(-N, Math.min(N, e));
+  return fa * Math.cos(a * Math.PI / 180) / U(t);
+}
+function pa(e, t, a) {
+  const o = ma(e, a), i = t / o;
+  return Number.isFinite(i) && i >= 0 ? i : 0;
+}
+function Ea(e) {
+  let t = 1 / 0, a = 1 / 0, o = -1 / 0, i = -1 / 0;
+  for (const n of e)
+    for (let s = 0; s + 1 < n.length; s += 2) {
+      const r = n[s], c = n[s + 1];
+      Number.isFinite(r) && Number.isFinite(c) && (r < t && (t = r), r > o && (o = r), c < a && (a = c), c > i && (i = c));
+    }
+  return t <= o && a <= i ? { minX: t, minY: a, maxX: o, maxY: i } : null;
+}
+function ga(e, t, a, o, i, n) {
+  const s = i - a, r = n - o, c = s * s + r * r;
+  let l = c === 0 ? 0 : ((e - a) * s + (t - o) * r) / c;
+  return l = l < 0 ? 0 : l > 1 ? 1 : l, Math.hypot(e - (a + l * s), t - (o + l * r));
+}
+function mt(e, t, a) {
+  const o = e.length >> 1;
+  if (!(t > 0) || o < 3) return e;
+  let i = e, n = o;
+  a && (i = new Float64Array((o + 1) * 2), i.set(e), i[o * 2] = e[0], i[o * 2 + 1] = e[1], n = o + 1);
+  const s = new Uint8Array(n);
+  s[0] = 1, s[n - 1] = 1;
+  const r = [0, n - 1];
+  for (; r.length > 0; ) {
+    const u = r.pop(), v = r.pop();
+    let x = 0, f = -1;
+    const m = i[v * 2], L = i[v * 2 + 1], w = i[u * 2], I = i[u * 2 + 1];
+    for (let y = v + 1; y < u; y++) {
+      const g = ga(i[y * 2], i[y * 2 + 1], m, L, w, I);
+      g > x && (x = g, f = y);
+    }
+    f !== -1 && x > t && (s[f] = 1, r.push(v, f, f, u));
+  }
+  const c = a ? n - 1 : n;
+  let l = 0;
+  for (let u = 0; u < c; u++) s[u] && l++;
+  if (a && l < 3 || l === c) return e;
+  const d = new Float64Array(l * 2);
+  let h = 0;
+  for (let u = 0; u < c; u++)
+    s[u] && (d[h++] = i[u * 2], d[h++] = i[u * 2 + 1]);
+  return d;
+}
+const va = 1.2, _ = 1e-9, Ma = 6, T = {
+  cor: q,
+  traco: !1,
+  peso: 0,
+  dash: void 0,
+  preencher: !1,
+  corPreenchimento: q,
+  opacidadePreenchimento: 0
+}, H = (e) => !!e && Number.isFinite(e.zoom) && e.zoom >= 0 && !!e.caixa && Number.isFinite(e.caixa.minLat) && Number.isFinite(e.caixa.maxLat) && Number.isFinite(e.caixa.minLon) && Number.isFinite(e.caixa.maxLon);
+class Fa {
+  constructor() {
+    M(this, "camadas", /* @__PURE__ */ new Map());
+    M(this, "regra", null);
+  }
+  // ---------------------------------------------------------------- camadas
+  /** Cria a camada ou atualiza a definição (estilo, zIndex, opacidade, visibilidade). */
+  definirCamada(t) {
+    if (!t || typeof t.id != "string") return;
+    let a = this.camadas.get(t.id);
+    if (!a) {
+      a = {
+        def: t,
+        dados: new ua(),
+        zoomCache: -1,
+        geom: /* @__PURE__ */ new Map(),
+        estilos: /* @__PURE__ */ new Map(),
+        lod: /* @__PURE__ */ new Map(),
+        avaliacoesLOD: 0,
+        agrupador: null,
+        agrupadorRev: -1,
+        nPontos: 0,
+        nPontosRev: -1,
+        previas: /* @__PURE__ */ new Map(),
+        destaques: /* @__PURE__ */ new Set(),
+        revEstilo: 0,
+        internador: new da(),
+        ultima: { total: 0, desenhadas: 0, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: 0 }
+      }, a.dados.regra = this.regra, this.camadas.set(t.id, a);
+      return;
+    }
+    const o = JSON.stringify(a.def.estilo) !== JSON.stringify(t.estilo);
+    a.def = t, o && (a.revEstilo++, a.estilos.clear(), a.internador.limpar());
+  }
+  removerCamada(t) {
+    this.camadas.delete(t);
+  }
+  temCamada(t) {
+    return this.camadas.has(t);
+  }
+  definirRegra(t) {
+    this.regra = t;
+    for (const a of this.camadas.values()) a.dados.regra = t;
+  }
+  /** A regra de versões mudou (prévias ligadas/desligadas): o conjunto desenhado e o agrupamento precisam ser refeitos. */
+  reavaliarVersoes(t) {
+    const a = this.camadas.get(t);
+    a && (a.dados.revisao++, a.dados.revisaoBase++);
+  }
+  // ---------------------------------------------------------------- dados
+  /** Troca total dos dados da camada (diferencia contra o que já existe). */
+  definirFeicoes(t, a) {
+    const o = this.camadas.get(t);
+    if (!o) return;
+    const i = Array.isArray(a) ? a : [], n = o.dados.sincronizar(i);
+    this.aposMudanca(o, n.mudadas, n.removidas, !0);
+  }
+  /**
+   * Mudança incremental: só vale se `delta.base` for a lista sincronizada por último; senão a camada é refeita
+   * por inteiro a partir de `lista`.
+   */
+  aplicarDelta(t, a, o) {
+    const i = this.camadas.get(t);
+    if (!i) return;
+    const n = Array.isArray(a) ? a : [], s = /* @__PURE__ */ new Map();
+    if (o) {
+      for (const l of o.removidas ?? []) s.set(l, this.pontoVisivel(i, i.dados.loja.get(l)));
+      for (const l of o.mudadas ?? []) l && typeof l.id == "string" && s.set(l.id, this.pontoVisivel(i, i.dados.loja.get(l.id)));
+    }
+    const r = i.dados.aplicarDelta(n, o);
+    if (!r) {
+      this.definirFeicoes(t, n);
+      return;
+    }
+    let c = i.nPontos;
+    for (const [l, d] of s) {
+      const h = this.pontoVisivel(i, i.dados.loja.get(l));
+      c += (h ? 1 : 0) - (d ? 1 : 0);
+    }
+    i.nPontos = Math.max(0, c), this.aposMudanca(i, r.mudadas, r.removidas, r.oficiaisMudou), r.oficiaisMudou || this.manterAgrupador(i, r.mudadas, r.removidas);
+  }
+  pontoVisivel(t, a) {
+    var o;
+    return !!a && ((o = a.geometria) == null ? void 0 : o.tipo) === "Point" && t.dados.desenhavel(a);
+  }
+  aposMudanca(t, a, o, i) {
+    for (const n of a)
+      t.lod.delete(n), t.geom.delete(n), t.estilos.delete(n), t.previas.delete(n);
+    for (const n of o)
+      t.lod.delete(n), t.geom.delete(n), t.estilos.delete(n), t.previas.delete(n), t.destaques.delete(n);
+    i && (t.agrupador = null);
+  }
+  /** O agrupador do zoom atual acompanha os pontos que mudaram (células afetadas, sem reagrupar a camada). */
+  manterAgrupador(t, a, o) {
+    const i = t.agrupador;
+    if (i) {
+      for (const n of o) i.remover(n);
+      for (const n of a) {
+        const s = t.dados.loja.get(n);
+        s && s.geometria.tipo === "Point" && t.dados.desenhavel(s) ? i.inserir({ id: n, coordenada: s.geometria.coordenada }) : i.remover(n);
+      }
+    }
+  }
+  // ---------------------------------------------------------------- seleção e edição
+  /** Define a seleção da camada. Devolve quem entrou e quem saiu (só o que mudou). */
+  selecionar(t, a) {
+    const o = this.camadas.get(t);
+    if (!o) return { entrou: [], saiu: [] };
+    const i = /* @__PURE__ */ new Set();
+    for (const r of a) o.dados.loja.has(r) && i.add(r);
+    const n = [], s = [];
+    for (const r of i) o.dados.selecionadas.has(r) || n.push(r);
+    for (const r of o.dados.selecionadas) i.has(r) || s.push(r);
+    o.dados.selecionadas.clear();
+    for (const r of i) o.dados.selecionadas.add(r);
+    return { entrou: n, saiu: s };
+  }
+  selecionadas(t) {
+    var a;
+    return ((a = this.camadas.get(t)) == null ? void 0 : a.dados.selecionadas) ?? /* @__PURE__ */ new Set();
+  }
+  /** Geometria provisória (arrasto de vértice): o canvas base deixa de desenhar a feição e a sobreposição a mostra. */
+  previsualizar(t, a) {
+    const o = this.camadas.get(t);
+    !o || !a || typeof a.id != "string" || !o.dados.loja.has(a.id) || o.previas.set(a.id, a);
+  }
+  temPrevia(t, a) {
+    var o;
+    return ((o = this.camadas.get(t)) == null ? void 0 : o.previas.has(a)) ?? !1;
+  }
+  /** Realce temporário (hover): as feições entram na sobreposição com `destaque: true`. */
+  destacar(t, a) {
+    const o = this.camadas.get(t);
+    o && (o.destaques = new Set(a));
+  }
+  // ---------------------------------------------------------------- consultas (geometria original)
+  feicao(t, a) {
+    var o;
+    return (o = this.camadas.get(t)) == null ? void 0 : o.dados.loja.get(a);
+  }
+  caixaDe(t, a) {
+    var o;
+    return (o = this.camadas.get(t)) == null ? void 0 : o.dados.indice.caixaDe(a);
+  }
+  /** Feições cujo envelope toca `caixa`, sem as ocultas (snap, hit-test, seleção por caixa). Não passa pelo LOD. */
+  consultarCaixa(t, a) {
+    const o = this.camadas.get(t);
+    if (!o) return [];
+    const i = [];
+    for (const n of o.dados.indice.consultar(a)) {
+      const s = o.dados.loja.get(n);
+      s && !s.oculta && i.push(s);
+    }
+    return i;
+  }
+  feicaoVisivel(t, a) {
+    const o = this.camadas.get(t);
+    return !o || o.dados.visivelPorVersao(a);
+  }
+  estatisticas(t) {
+    const a = this.camadas.get(t);
+    return a ? { ...a.ultima, total: a.dados.loja.size, avaliacoesLOD: a.avaliacoesLOD } : null;
+  }
+  /** Entidades da camada com prévia e com oficial (pares em detalhe completo): para testes e diagnóstico. */
+  ehPar(t, a) {
+    const o = this.camadas.get(t);
+    return !!o && this.emPar(o, a);
+  }
+  // ---------------------------------------------------------------- lista de desenho
+  /**
+   * O que desenhar nesta vista, camada a camada, na ordem de empilhamento (a última fica por cima).
+   * `parte`: `'canvas'` só o que se pinta no canvas (marcas, formas, pontos sem ícone), `'dom'` só marcadores DOM e
+   * curvas (clusters, ícones, textos, rótulos), `'tudo'` (padrão) os dois. O pan incremental pede o canvas só das faixas
+   * expostas e o DOM da vista inteira (poucos itens, sem projetar nem simplificar formas).
+   */
+  listaDesenho(t, a) {
+    const o = this.origemDe(t), i = { vista: t, origem: o, camadas: [] };
+    if (!H(t)) return i;
+    const n = a != null && a.camadas ? new Set(a.camadas) : null, s = [...this.camadas.values()].filter((r) => r.def.visivel && (!n || n.has(r.def.id)));
+    s.sort((r, c) => r.def.zIndex - c.def.zIndex);
+    for (const r of s)
+      try {
+        i.camadas.push(this.listarCamada(r, t, (a == null ? void 0 : a.parte) ?? "tudo"));
+      } catch {
+        i.camadas.push(this.camadaVazia(r));
+      }
+    return i;
+  }
+  origemDe(t) {
+    if (t != null && t.origemPx && Number.isFinite(t.origemPx.x) && Number.isFinite(t.origemPx.y)) return t.origemPx;
+    if (!H(t)) return { x: 0, y: 0 };
+    const a = E(t.caixa.maxLat, t.caixa.minLon, t.zoom);
+    return { x: a[0], y: a[1] };
+  }
+  camadaVazia(t) {
+    return {
+      camadaId: t.def.id,
+      zIndex: t.def.zIndex,
+      opacidade: t.def.opacidade,
+      itens: [],
+      estatisticas: { total: t.dados.loja.size, desenhadas: 0, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: t.avaliacoesLOD }
+    };
+  }
+  prepararZoom(t, a) {
+    a !== t.zoomCache && (t.geom.clear(), t.lod.clear(), t.zoomCache = a);
+  }
+  estiloDe(t, a) {
+    const o = t.dados.revisaoDaFeicao(a.id), i = t.estilos.get(a.id);
+    if (i && i.rev === o && i.revEstilo === t.revEstilo) return i.estilo;
+    const n = t.internador.interno(ut(a, t.def.estilo, !1));
+    return t.estilos.set(a.id, { rev: o, revEstilo: t.revEstilo, estilo: n }), n;
+  }
+  emPar(t, a) {
+    if (t.dados.contPrevias.size === 0) return !1;
+    const o = b(a);
+    return t.dados.contPrevias.has(o) && t.dados.oficiais.has(o);
+  }
+  /**
+   * Vira marca? Sempre em detalhe completo: com rótulo e em par oficial × prévia; ponto e texto nunca. A seleção NÃO
+   * entra aqui: o canvas base não depende dela (a sobreposição desenha a selecionada em detalhe completo por cima).
+   */
+  comoMarca(t, a, o) {
+    var r;
+    const i = a.geometria.tipo;
+    if (i === "Point" || i === "Text" || (r = a.estilo) != null && r.mostrarRotulo || this.emPar(t, a)) return !1;
+    const n = t.lod.get(a.id);
+    if (n !== void 0) return n;
+    t.avaliacoesLOD++;
+    const s = oa(t.dados.indice.caixaDe(a.id), o);
+    return t.lod.set(a.id, s), s;
+  }
+  /** Geometria projetada e simplificada em px, em cache por (feição, revisão, zoom). `null` se não há o que desenhar. */
+  geometriaProjetada(t, a, o) {
+    const i = t.dados.revisaoDaFeicao(a.id), n = t.geom.get(a.id);
+    if (n && n.rev === i) return n;
+    const s = this.construirGeometria(t, a, o, i);
+    return s && t.geom.set(a.id, s), s;
+  }
+  construirGeometria(t, a, o, i) {
+    const n = a.geometria, s = o < pt ? va : 0;
+    if (n.tipo === "Polygon") {
+      const r = [];
+      for (const c of n.aneis ?? []) {
+        if (!Array.isArray(c) || c.length < 3) continue;
+        let l = ft(c, o);
+        s > 0 && c.length >= J && (l = mt(l, s, !0)), r.push(l);
+      }
+      return r.length > 0 ? { rev: i, partes: r, raioPx: 0, marca: !1 } : null;
+    }
+    if (n.tipo === "LineString") {
+      const r = [];
+      for (const c of z(n)) {
+        if (!Array.isArray(c) || c.length < 2) continue;
+        let l = ft(c, o);
+        s > 0 && c.length >= J && (l = mt(l, s, !1)), r.push(l);
+      }
+      return r.length > 0 ? { rev: i, partes: r, raioPx: 0, marca: !1 } : null;
+    }
+    if (n.tipo === "Circle") {
+      const r = n.centro;
+      if (!Array.isArray(r)) return null;
+      const c = E(r[0], r[1], o);
+      return { rev: i, partes: [c], raioPx: pa(r[0], n.raioMetros, o), marca: !1 };
+    }
+    return n.tipo === "Point" || n.tipo === "Text" ? { rev: i, partes: [E(n.coordenada[0], n.coordenada[1], o)], raioPx: n.tipo === "Point" ? ca(a, t.def.estilo) : 0, marca: !1 } : null;
+  }
+  /** Marca de LOD: centro do envelope, lado de 1–2 px, cor do preenchimento/contorno. */
+  marcaDe(t, a, o) {
+    const i = t.dados.revisaoDaFeicao(a.id), n = t.geom.get(a.id);
+    if (n && n.rev === i) return n;
+    const s = t.dados.indice.caixaDe(a.id);
+    if (!s) return null;
+    const r = E((s.minLat + s.maxLat) / 2, (s.minLon + s.maxLon) / 2, o);
+    if (!(Number.isFinite(r[0]) && Number.isFinite(r[1]))) return null;
+    const c = { rev: i, partes: [r], raioPx: ea(Pt(s, o)), marca: !0 };
+    return t.geom.set(a.id, c), c;
+  }
+  /**
+   * Item da marca, em cache junto com a geometria por (feição, zoom). Com 100 mil marcas na tela, montar o item e internar
+   * o estilo a cada vista custava a maior parte da lista; no pan agora só se confere se algo mudou, sem alocar.
+   */
+  itemMarca(t, a, o) {
+    const i = this.marcaDe(t, a, o);
+    if (!i) return null;
+    const n = i.item;
+    if (n && n.feicao === a && i.revEstilo === t.revEstilo && n.selecionada === t.dados.selecionadas.has(a.id) && n.destaque === !0 === t.destaques.has(a.id)) return n;
+    const s = this.itemBase(t, a, "marca", i.partes, i.raioPx, this.estiloMarca(t, a));
+    return i.item = s, i.revEstilo = t.revEstilo, s;
+  }
+  estiloMarca(t, a) {
+    const o = a.estilo ?? {}, i = B(o.corPreenchimento ?? o.corTraco ?? t.def.estilo.corPrimaria, q);
+    return t.internador.interno({ cor: i, traco: !1, peso: 0, dash: void 0, preencher: !0, corPreenchimento: i, opacidadePreenchimento: Lt });
+  }
+  agrupadorAtivo(t, a) {
+    const { dados: o } = t;
+    if (t.nPontosRev !== o.revisaoBase) {
+      let s = 0;
+      for (const r of o.loja.values()) r.geometria.tipo === "Point" && o.desenhavel(r) && s++;
+      t.nPontos = s, t.nPontosRev = o.revisaoBase;
+    }
+    if (!xt(t.nPontos, a))
+      return t.agrupador = null, null;
+    const i = t.agrupador;
+    if (i && i.zoom === a && t.agrupadorRev === o.revisaoBase) return i;
+    const n = new Kt(a, (s) => {
+      const r = E(s[0], s[1], a);
+      return { x: r[0], y: r[1] };
+    });
+    for (const s of o.loja.values())
+      s.geometria.tipo === "Point" && o.desenhavel(s) && n.inserir({ id: s.id, coordenada: s.geometria.coordenada });
+    return t.agrupador = n, t.agrupadorRev = o.revisaoBase, n;
+  }
+  itemBase(t, a, o, i, n, s) {
+    return {
+      camadaId: t.def.id,
+      id: a.id,
+      forma: o,
+      geometriaEmPx: i,
+      raioPx: n,
+      estilo: s,
+      selecionada: t.dados.selecionadas.has(a.id),
+      feicao: a,
+      ...t.destaques.has(a.id) ? { destaque: !0 } : {}
+    };
+  }
+  /**
+   * A caixa da vista com uma folga de poucos px: o traço de uma feição com o envelope logo fora da vista ainda entra nela
+   * (o índice é por envelope). Sem isto, o pan incremental e o quadro completo divergem na borda do canvas.
+   */
+  caixaComFolga(t) {
+    const a = t.caixa, i = 360 / (256 * 2 ** t.zoom) * Ma, n = i * Math.cos((a.minLat + a.maxLat) / 2 * Math.PI / 180);
+    return { minLat: a.minLat - n, maxLat: a.maxLat + n, minLon: a.minLon - i, maxLon: a.maxLon + i };
+  }
+  listarCamada(t, a, o) {
+    var y;
+    const { dados: i, def: n } = t, s = o !== "dom", r = o !== "canvas", c = a.zoom;
+    this.prepararZoom(t, c);
+    const l = i.indice.consultar(this.caixaComFolga(a)), d = this.agrupadorAtivo(t, c), h = [], u = [], v = [], x = [], f = [], m = { total: i.loja.size, desenhadas: 0, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: 0 }, L = (g) => {
+      var D;
+      if (!r || !((D = g.estilo) != null && D.mostrarRotulo) || g.geometria.tipo === "Text") return;
+      const p = Ft(g, g.estilo.campoRotulo), P = i.indice.caixaDe(g.id);
+      !p || !P || (f.push({
+        camadaId: n.id,
+        id: `rotulo:${g.id}`,
+        forma: "rotulo",
+        geometriaEmPx: [],
+        raioPx: 0,
+        estilo: T,
+        selecionada: !1,
+        feicao: g,
+        texto: p,
+        coordenada: [(P.minLat + P.maxLat) / 2, (P.minLon + P.maxLon) / 2]
+      }), m.marcadoresDom++);
+    }, w = (g) => {
+      var D;
+      const p = g.geometria;
+      if (p.tipo !== "Point") return;
+      if ((D = g.estilo) != null && D.icone) {
+        if (!r) return;
+        f.push({ ...this.itemBase(t, g, "icone", [], 0, T), coordenada: p.coordenada }), m.marcadoresDom++;
+        return;
+      }
+      if (!s) return;
+      const P = this.geometriaProjetada(t, g, c);
+      P && (x.push(this.itemBase(t, g, "ponto", P.partes, P.raioPx, this.estiloDe(t, g))), m.desenhadas++);
+    };
+    for (const g of l) {
+      const p = i.loja.get(g);
+      if (!p || !i.desenhavel(p) || t.previas.has(g)) continue;
+      const P = p.geometria;
+      if (P.tipo === "Point") {
+        if (d && d.emCluster(g) && (!((y = p.estilo) != null && y.icone) || !r || !this.soltoDoCluster(t, d, g)))
+          continue;
+        w(p), L(p);
+        continue;
+      }
+      if (P.tipo === "Text") {
+        if (!r) continue;
+        f.push({ ...this.itemBase(t, p, "texto", [], 0, T), coordenada: P.coordenada }), m.marcadoresDom++;
+        continue;
+      }
+      if (dt(P)) {
+        if (!r) continue;
+        f.push(this.itemBase(t, p, "curva", [], 0, this.estiloDe(t, p))), m.marcadoresDom++, L(p);
+        continue;
+      }
+      if (!s) {
+        L(p);
+        continue;
+      }
+      const D = t.geom.get(g), C = D == null ? void 0 : D.item;
+      if (C && C.feicao === p && D.revEstilo === t.revEstilo && !this.emPar(t, p) && C.selecionada === i.selecionadas.has(g) && C.destaque === !0 === t.destaques.has(g)) {
+        h.push(C), m.marcasLOD++;
+        continue;
+      }
+      if (this.comoMarca(t, p, c)) {
+        const K = this.itemMarca(t, p, c);
+        K && (h.push(K), m.marcasLOD++);
+        continue;
+      }
+      const O = this.geometriaProjetada(t, p, c);
+      if (!O) continue;
+      const X = this.estiloDe(t, p);
+      P.tipo === "LineString" ? v.push(this.itemBase(t, p, "linha", O.partes, 0, X)) : P.tipo === "Circle" ? u.push(this.itemBase(t, p, "circulo", O.partes, O.raioPx, X)) : u.push(this.itemBase(t, p, "poligono", O.partes, 0, X)), m.desenhadas++, L(p);
+    }
+    d && r && this.listarClusters(t, a, d, f, m, r), m.avaliacoesLOD = t.avaliacoesLOD, o === "tudo" && (t.ultima = m);
+    const I = h;
+    for (const g of [u, v, x, f]) for (const p of g) I.push(p);
+    return { camadaId: n.id, zIndex: n.zIndex, opacidade: n.opacidade, itens: I, estatisticas: m };
+  }
+  /**
+   * Clusters da vista (marcadores DOM). Selecionado nunca entra em cluster; o cluster só aparece com o centro dentro da
+   * vista e com 2 ou mais restantes. Os pontos individuais que a seleção solta (o selecionado e o único restante de uma
+   * célula) são da sobreposição: o canvas base não depende da seleção.
+   */
+  listarClusters(t, a, o, i, n, s) {
+    const { dados: r, def: c } = t;
+    for (const [l, d] of o.celulasAgrupadas()) {
+      const h = d.membros.size;
+      let u = 0, v = d.somaLat, x = d.somaLon;
+      for (const L of d.membros.values())
+        r.selecionadas.has(L.id) && (u++, v -= L.coordenada[0], x -= L.coordenada[1]);
+      const f = h - u, m = [d.somaLat / h, d.somaLon / h];
+      m[0] >= a.caixa.minLat - _ && m[0] <= a.caixa.maxLat + _ && m[1] >= a.caixa.minLon - _ && m[1] <= a.caixa.maxLon + _ && (f < 2 || !s || (i.push({
+        camadaId: c.id,
+        id: l,
+        forma: "cluster",
+        geometriaEmPx: [],
+        raioPx: 0,
+        estilo: T,
+        selecionada: !1,
+        coordenada: [v / f, x / f],
+        total: h,
+        restantes: f
+      }), n.clusters++, n.marcadoresDom++));
+    }
+  }
+  /** O ponto está dentro de um cluster neste zoom (não é desenhado nem clicável individualmente)? */
+  pontoAgrupado(t, a) {
+    const o = this.camadas.get(t);
+    return !!(o != null && o.agrupador) && o.agrupador.emCluster(a) && !o.dados.selecionadas.has(a);
+  }
+  /** O ponto de uma célula de cluster aparece solto: está selecionado ou é o único restante não selecionado? */
+  soltoDoCluster(t, a, o) {
+    if (t.dados.selecionadas.has(o)) return !0;
+    const i = a.chaveDoPonto(o), n = i === void 0 ? void 0 : a.celula(i);
+    if (!n) return !1;
+    let s = 0;
+    for (const r of n.membros.keys()) t.dados.selecionadas.has(r) || s++;
+    return s === 1;
+  }
+  /** Membros (id e coordenada) da célula de cluster: o clique no cluster enquadra o grupo. */
+  membrosDoCluster(t, a) {
+    var n;
+    const o = this.camadas.get(t), i = (n = o == null ? void 0 : o.agrupador) == null ? void 0 : n.celula(a);
+    return i ? [...i.membros.values()].map((s) => ({ id: s.id, coordenada: s.coordenada })) : [];
+  }
+  // ---------------------------------------------------------------- sobreposição (seleção, destaque, edição)
+  /**
+   * Itens da sobreposição: feições selecionadas, em edição ou destacadas, sempre em detalhe completo e com o estilo
+   * de seleção. Custo O(selecionadas): selecionar não repinta o canvas base.
+   */
+  listaSobreposicao(t, a) {
+    var r;
+    const o = this.camadas.get(t);
+    if (!o || !H(a)) return null;
+    this.prepararZoom(o, a.zoom);
+    const i = [], n = /* @__PURE__ */ new Set([...o.dados.selecionadas, ...o.previas.keys(), ...o.destaques]), s = o.agrupador;
+    if (s && o.dados.selecionadas.size > 0) {
+      const c = /* @__PURE__ */ new Set();
+      for (const l of o.dados.selecionadas) {
+        const d = s.chaveDoPonto(l);
+        d !== void 0 && c.add(d);
+      }
+      for (const l of c) {
+        const d = s.celula(l);
+        if (!d || d.membros.size < 2) continue;
+        const h = [...d.membros.keys()].filter((u) => !o.dados.selecionadas.has(u));
+        h.length === 1 && n.add(h[0]);
+      }
+    }
+    for (const c of n) {
+      const l = o.dados.loja.get(c);
+      if (!l || !o.dados.desenhavel(l)) continue;
+      const d = o.previas.get(c), h = d ?? l, u = h.geometria;
+      if (u.tipo === "Text" || dt(u) || u.tipo === "Point" && ((r = h.estilo) != null && r.icone)) continue;
+      const v = d ? null : o.dados.indice.caixaDe(c);
+      if (v && !$(v, a.caixa)) continue;
+      const x = o.dados.selecionadas.has(c) || !!d;
+      if (!x && !o.destaques.has(c) && !(u.tipo === "Point" && (s != null && s.emCluster(c)))) continue;
+      const f = d ? this.construirGeometria(o, h, a.zoom, -1) : this.geometriaProjetada(o, h, a.zoom);
+      if (!f) continue;
+      const m = o.internador.interno(ut(h, o.def.estilo, x)), L = u.tipo === "LineString" ? "linha" : u.tipo === "Circle" ? "circulo" : u.tipo === "Point" ? "ponto" : "poligono";
+      i.push({
+        camadaId: t,
+        id: c,
+        forma: L,
+        geometriaEmPx: f.partes,
+        raioPx: f.raioPx,
+        estilo: m,
+        selecionada: x,
+        feicao: h,
+        ...o.destaques.has(c) ? { destaque: !0 } : {}
+      });
+    }
+    return {
+      camadaId: t,
+      zIndex: o.def.zIndex,
+      opacidade: o.def.opacidade,
+      itens: i,
+      estatisticas: { total: o.dados.loja.size, desenhadas: i.length, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: o.avaliacoesLOD }
+    };
+  }
+  /** A seleção da camada toca pontos sob agrupamento ativo? (então o conjunto de clusters muda e o base precisa refazer) */
+  selecaoAfetaAgrupamento(t, a) {
+    var i;
+    const o = this.camadas.get(t);
+    if (!o || !o.agrupador) return !1;
+    for (const n of a) if (((i = o.dados.loja.get(n)) == null ? void 0 : i.geometria.tipo) === "Point") return !0;
+    return !1;
+  }
+}
+export {
+  St as $,
+  Kt as A,
+  ca as B,
+  q as C,
+  Ft as D,
+  Fa as E,
+  wa as F,
+  Sa as G,
+  wt as H,
+  _t as I,
+  Et as J,
+  Ot as K,
+  Nt as L,
+  J as M,
+  Rt as N,
+  at as O,
+  Gt as P,
+  k as Q,
+  Aa as R,
+  ua as S,
+  da as T,
+  Wt as U,
+  Yt as V,
+  Lt as W,
+  Jt as X,
+  ia as Y,
+  pt as Z,
+  Oa as _,
+  Ct as a,
+  it as a0,
+  Ea as a1,
+  Qt as a2,
+  U as a3,
+  rt as a4,
+  ma as a5,
+  E as a6,
+  Dt as a7,
+  Y as a8,
+  ft as a9,
+  pa as aa,
+  Vt as ab,
+  gt as ac,
+  mt as ad,
+  $t as ae,
+  z as b,
+  Ia as c,
+  Pa as d,
+  La as e,
+  tt as f,
+  ya as g,
+  vt as h,
+  Zt as i,
+  Ca as j,
+  Na as k,
+  B as l,
+  ba as m,
+  dt as n,
+  sa as o,
+  Ht as p,
+  b as q,
+  Da as r,
+  S as s,
+  oa as t,
+  ea as u,
+  kt as v,
+  Pt as w,
+  xt as x,
+  $ as y,
+  ut as z
+};