@thibezer/ui-components-kit 2.12.5 → 2.13.0

package/dist/motor-By2te6PZ.js

@@ -0,0 +1,1400 @@
+var wt = Object.defineProperty;
+var Et = (o, t, a) => t in o ? wt(o, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : o[t] = a;
+var M = (o, t, a) => Et(o, typeof t != "symbol" ? t + "" : t, a);
+function F(o) {
+  return o.partes && o.partes.length > 1 ? o.partes : [o.coordenadas];
+}
+function Ta(o) {
+  return o.tipo === "LineString" && !!o.partes && o.partes.length > 1;
+}
+function Tt(o) {
+  return o.length > 1 ? { tipo: "LineString", coordenadas: o[0], partes: o } : { tipo: "LineString", coordenadas: o[0] };
+}
+const T = 6378137, k = 1 / 298.257222101, W = k * (2 - k), D = (o) => o * Math.PI / 180;
+function Y(o) {
+  const t = Math.sin(D(o)), a = 1 - W * t * t;
+  return { N: T / Math.sqrt(a), M: T * (1 - W) / (a * Math.sqrt(a)) };
+}
+function Fa(o) {
+  const { M: t, N: a } = Y(o);
+  return { lat: D(1) * t, lng: D(1) * a * Math.cos(D(o)) };
+}
+function Ft(o, t) {
+  const a = T * (1 - k), e = k, i = D(t[1] - o[1]), n = Math.atan((1 - e) * Math.tan(D(o[0]))), s = Math.atan((1 - e) * Math.tan(D(t[0]))), r = Math.sin(n), c = Math.cos(n), l = Math.sin(s), d = Math.cos(s);
+  let h = i, u = 0, g = 0, x = 0, f = 0, m = 0;
+  for (let v = 0; v < 100; v++) {
+    const p = Math.sin(h), P = Math.cos(h);
+    if (u = Math.hypot(d * p, c * l - r * d * P), u === 0) return 0;
+    g = r * l + c * d * P, x = Math.atan2(u, g);
+    const A = c * d * p / u;
+    f = 1 - A * A, m = f === 0 ? 0 : g - 2 * r * l / f;
+    const C = e / 16 * f * (4 + e * (4 - 3 * f)), N = h;
+    if (h = i + (1 - C) * e * A * (x + C * u * (m + C * g * (-1 + 2 * m * m))), Math.abs(h - N) < 1e-12) break;
+  }
+  const L = f * (T * T - a * a) / (a * a), w = 1 + L / 16384 * (4096 + L * (-768 + L * (320 - 175 * L))), S = L / 1024 * (256 + L * (-128 + L * (74 - 47 * L))), y = S * u * (m + S / 4 * (g * (-1 + 2 * m * m) - S / 6 * m * (-3 + 4 * u * u) * (-3 + 4 * m * m)));
+  return a * w * (x - y);
+}
+function tt(o, t) {
+  const a = t[0] - o[0], e = t[1] - o[1];
+  if (Math.abs(a) < 0.1 && Math.abs(e) < 0.1) {
+    const { M: i, N: n } = Y((o[0] + t[0]) / 2), s = D(a) * i, r = D(e) * n * Math.cos(D((o[0] + t[0]) / 2));
+    return Math.hypot(r, s);
+  }
+  return Ft(o, t);
+}
+function at(o, t = !1) {
+  let a = 0;
+  for (let e = 1; e < o.length; e++) a += tt(o[e - 1], o[e]);
+  return t && o.length > 2 && (a += tt(o[o.length - 1], o[0])), a;
+}
+function ot(o) {
+  const t = o.length;
+  if (t < 3) return 0;
+  let a = 0, e = 0;
+  for (let r = 0; r < t; r++) {
+    const c = o[(r - 1 + t) % t], l = o[r], d = o[(r + 1) % t];
+    a += D(d[1] - c[1]) * Math.sin(D(l[0])), e += l[0];
+  }
+  const { M: i, N: n } = Y(e / t), s = Math.abs(a * i * n / 2);
+  return Number.isFinite(s) ? s : 0;
+}
+function Rt(o) {
+  const [t, ...a] = o;
+  return t ? Math.max(0, ot(t) - a.reduce((e, i) => e + ot(i), 0)) : 0;
+}
+const zt = new Intl.NumberFormat("pt-BR", { minimumFractionDigits: 4, maximumFractionDigits: 4 }), et = new Intl.NumberFormat("pt-BR", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+function _t(o) {
+  return `${zt.format(o / 1e4)} ha`;
+}
+function $t(o) {
+  return o >= 1e3 ? `${et.format(o / 1e3)} km` : `${et.format(o)} m`;
+}
+function Bt(o) {
+  return o.tipo === "Polygon" ? Rt(o.aneis) : o.tipo === "Circle" ? Math.PI * o.raioMetros ** 2 : null;
+}
+function kt(o) {
+  return o.tipo === "LineString" ? F(o).reduce((t, a) => t + at(a), 0) : o.tipo === "Polygon" ? at(o.aneis[0] ?? [], !0) : o.tipo === "Circle" ? 2 * Math.PI * o.raioMetros : null;
+}
+function qt(o, t) {
+  var i;
+  const a = t ?? "name";
+  if (a === "area") {
+    const n = Bt(o.geometria);
+    return n === null ? "" : _t(n);
+  }
+  if (a === "extensao") {
+    const n = kt(o.geometria);
+    return n === null ? "" : $t(n);
+  }
+  if (a === "id") return o.id;
+  const e = (i = o.propriedades) == null ? void 0 : i[a];
+  return e != null && e !== "" ? String(e) : t ? "" : o.id;
+}
+function Ut(o) {
+  let t;
+  switch (o.tipo) {
+    case "Point":
+    case "Text":
+      t = [o.coordenada];
+      break;
+    case "LineString":
+      t = F(o).flat();
+      break;
+    case "Polygon":
+      t = o.aneis.flat();
+      break;
+    case "Circle": {
+      const i = o.raioMetros / 111320, n = i / Math.max(0.01, Math.cos(D(o.centro[0])));
+      t = [[o.centro[0] - i, o.centro[1] - n], [o.centro[0] + i, o.centro[1] + n]];
+      break;
+    }
+  }
+  const a = t.map((i) => i[0]), e = t.map((i) => i[1]);
+  return [[Math.min(...a), Math.min(...e)], [Math.max(...a), Math.max(...e)]];
+}
+const R = 16, Vt = 256;
+function it(o) {
+  const [[t, a], [e, i]] = Ut(o.geometria);
+  return { minLon: a, minLat: t, maxLon: i, maxLat: e };
+}
+function $(o, t) {
+  return o.minLon <= t.maxLon && o.maxLon >= t.minLon && o.minLat <= t.maxLat && o.maxLat >= t.minLat;
+}
+function nt(o) {
+  let t = 1 / 0, a = 1 / 0, e = -1 / 0, i = -1 / 0;
+  for (const n of o)
+    n.minLon < t && (t = n.minLon), n.minLat < a && (a = n.minLat), n.maxLon > e && (e = n.maxLon), n.maxLat > i && (i = n.maxLat);
+  return { minLon: t, minLat: a, maxLon: e, maxLat: i };
+}
+function st(o) {
+  const t = o.length, a = Math.ceil(t / R), i = Math.ceil(Math.sqrt(a)) * R, n = [...o].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 += R) s.push(c.slice(l, l + R));
+  }
+  return s;
+}
+function Xt(o) {
+  if (o.length === 0) return null;
+  let t = st(o).map((a) => ({ ...nt(a), folhas: a }));
+  for (; t.length > 1; )
+    t = st(t).map((a) => ({ ...nt(a), filhos: a }));
+  return t[0];
+}
+class Gt {
+  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 = [], e = this.raiz ? [this.raiz] : [];
+    for (; e.length > 0; ) {
+      const i = e.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 && e.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(Vt, this.itens.size * 0.1) && this.remontar();
+  }
+  remontar() {
+    this.raiz = Xt([...this.itens.values()]), this.delta.clear(), this.obsoletos.clear();
+  }
+}
+const At = 17, J = 9, Zt = 1.2;
+function Ht(o) {
+  return !Number.isFinite(o) || o >= At ? 0 : 360 / (256 * 2 ** o) * Zt;
+}
+function rt(o) {
+  return Number.isFinite(o) ? 1 / Math.max(0.05, Math.cos(Math.max(-85, Math.min(85, o)) * Math.PI / 180)) : 1;
+}
+function Jt(o, t, a, e) {
+  const i = a[1] - t[1], n = (a[0] - t[0]) * e, s = i * i + n * n, r = (o[0] - t[0]) * e;
+  let c = s === 0 ? 0 : ((o[1] - t[1]) * i + r * n) / s;
+  return c = Math.max(0, Math.min(1, c)), Math.hypot(o[1] - (t[1] + c * i), r - c * n);
+}
+function Dt(o, t, a = 1) {
+  if (!(t > 0) || o.length < 3) return o;
+  const e = Number.isFinite(a) && a > 0 ? a : 1, i = new Uint8Array(o.length);
+  i[0] = 1, i[o.length - 1] = 1;
+  const n = [[0, o.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 = Jt(o[d], o[s], o[r], e);
+      h > c && (c = h, l = d);
+    }
+    l !== -1 && c > t && (i[l] = 1, n.push([s, l], [l, r]));
+  }
+  return o.filter((s, r) => i[r] === 1);
+}
+function Qt(o, t, a = 1) {
+  if (!(t > 0) || o.length < 4) return o;
+  const e = [...o, o[0]], i = Dt(e, t, a);
+  return i.pop(), i.length >= 3 ? i : o;
+}
+function Yt(o) {
+  return (o.tipo === "LineString" || o.tipo === "Polygon") && o.curva ? 0 : o.tipo === "LineString" ? F(o).reduce((t, a) => t + a.length, 0) : o.tipo === "Polygon" ? o.aneis.reduce((t, a) => t + a.length, 0) : 0;
+}
+function Ra(o, t) {
+  var e, i, n, s;
+  const a = Ht(t);
+  if (a === 0 || Yt(o) < J) return o;
+  if (o.tipo === "LineString") {
+    const r = F(o), c = rt(((i = (e = r[0]) == null ? void 0 : e[0]) == null ? void 0 : i[0]) ?? NaN);
+    return Tt(r.map((l) => Dt(l, a, c)));
+  }
+  if (o.tipo === "Polygon") {
+    const r = rt(((s = (n = o.aneis[0]) == null ? void 0 : n[0]) == null ? void 0 : s[0]) ?? NaN);
+    return { tipo: "Polygon", aneis: o.aneis.map((c) => Qt(c, a, r)) };
+  }
+  return o;
+}
+const Kt = /* @__PURE__ */ new Set(["previa", "prévia", "preview", "rascunho", "draft", "proposta"]);
+function b(o) {
+  var a, e;
+  const t = [o.status, (a = o.propriedades) == null ? void 0 : a.status, (e = o.propriedades) == null ? void 0 : e.tipo_geometria];
+  for (const i of t)
+    if (typeof i == "string" && Kt.has(i.trim().toLowerCase())) return "previa";
+  return "oficial";
+}
+function O(o) {
+  var a;
+  const t = o.entidadeId ?? ((a = o.propriedades) == null ? void 0 : a.entidadeId);
+  return typeof t == "string" || typeof t == "number" ? String(t) : o.id;
+}
+const G = (o, t) => `${o}\0${t}`;
+class za {
+  constructor() {
+    /** Mostra as prévias de todas as entidades. */
+    M(this, "global", !1);
+    M(this, "individuais", /* @__PURE__ */ new Set());
+  }
+  alternarIndividual(t, a) {
+    const e = G(t, a);
+    return this.individuais.has(e) ? this.individuais.delete(e) : this.individuais.add(e), this.individuais.has(e);
+  }
+  definirIndividual(t, a, e) {
+    const i = G(t, a);
+    e ? 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 e of t) !e.excluida && b(e) === "oficial" && a.add(O(e));
+    return a;
+  }
+  /** A feição aparece? `comOficial` = entidades da camada com geometria oficial (ver `oficiais`). */
+  visivel(t, a) {
+    if (b(t) === "oficial") return !0;
+    const e = O(t);
+    return this.global || !a.has(e) || this.individualAtiva(t.camadaId, e);
+  }
+  /** 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, O(t));
+  }
+}
+const Wt = 24, ta = 2, ct = (o) => typeof o == "number" && Number.isFinite(o), Z = (o) => Array.isArray(o) && o.length === 2 && ct(o[0]) && ct(o[1]);
+function _a(o, t) {
+  return [2 * o[0] - t[0], 2 * o[1] - t[1]];
+}
+function aa(o) {
+  return o.some((t) => t.entrada !== void 0 || t.saida !== void 0);
+}
+function yt(o, t) {
+  return [o.saida ?? o.ponto, t.entrada ?? t.ponto];
+}
+function Ct(o, t) {
+  const a = [];
+  for (let e = 0; e < o - 1; e++) a.push([e, e + 1]);
+  return t && o > 2 && a.push([o - 1, 0]), a;
+}
+function oa(o, t, a, e, 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 * o[0] + r * t[0] + c * a[0] + l * e[0], s * o[1] + r * t[1] + c * a[1] + l * e[1]];
+}
+function $a(o, t = !1, a = Wt) {
+  if (o.length === 0) return [];
+  const e = [[o[0].ponto[0], o[0].ponto[1]]];
+  for (const [i, n] of Ct(o.length, t)) {
+    const s = o[i], r = o[n];
+    if (!(s.saida === void 0 && r.entrada === void 0)) {
+      const [l, d] = yt(s, r);
+      for (let h = 1; h < a; h++) e.push(oa(s.ponto, l, d, r.ponto, h / a));
+    }
+    n !== 0 && e.push([r.ponto[0], r.ponto[1]]);
+  }
+  return e;
+}
+function ea(o, t) {
+  if (o.length === 0) return [];
+  const a = [{ cmd: "M", pts: [o[0].ponto] }];
+  for (const [e, i] of Ct(o.length, t)) {
+    const n = o[e], s = o[i];
+    if (n.saida === void 0 && s.entrada === void 0)
+      a.push({ cmd: "L", pts: [s.ponto] });
+    else {
+      const [r, c] = yt(n, s);
+      a.push({ cmd: "C", pts: [r, c, s.ponto] });
+    }
+  }
+  return a;
+}
+function Ba(o, t, a) {
+  const e = (n) => String(Math.round(n * 100) / 100), i = ea(o, t).map((n) => n.cmd + n.pts.map((s) => {
+    const r = a(s);
+    return `${e(r.x)} ${e(r.y)}`;
+  }).join(" ")).join("");
+  return i && t ? `${i}Z` : i;
+}
+function ka(o, t = ta) {
+  if (!Array.isArray(o) || o.length < t) return null;
+  const a = [];
+  for (const e of o) {
+    if (!e || typeof e != "object" || !Z(e.ponto)) return null;
+    const i = e, 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 aa(a) ? a : null;
+}
+function qa(o, t) {
+  return o.map((a) => {
+    const e = { ponto: t(a.ponto) };
+    return a.entrada && (e.entrada = t(a.entrada)), a.saida && (e.saida = t(a.saida)), e;
+  });
+}
+function dt(o) {
+  return o.tipo === "LineString" ? o.curva && o.curva.length >= 2 && !(o.partes && o.partes.length > 1) ? o.curva : null : o.tipo === "Polygon" && o.curva && o.curva.length >= 3 && o.aneis.length === 1 ? o.curva : null;
+}
+const q = 55, ia = 17, na = 8;
+function St(o, t) {
+  return t < ia && o > na;
+}
+function sa(o) {
+  let t = 0, a = 0;
+  for (const e of o)
+    t += e.coordenada[0], a += e.coordenada[1];
+  return [t / o.length, a / o.length];
+}
+function Ua(o, t, a) {
+  if (!St(o.length, t)) return { clusters: [], isolados: o };
+  const e = /* @__PURE__ */ new Map();
+  for (const s of o) {
+    const { x: r, y: c } = a(s.coordenada), l = `${t}:${Math.floor(r / q)}:${Math.floor(c / q)}`, d = e.get(l);
+    d ? d.push(s) : e.set(l, [s]);
+  }
+  const i = [], n = [];
+  for (const [s, r] of e)
+    r.length === 1 ? n.push(r[0]) : i.push({ chave: s, coordenada: sa(r), membros: r });
+  return { clusters: i, isolados: n };
+}
+class ra {
+  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 e;
+    const a = this.celulaDe.get(t);
+    return a !== void 0 && (((e = this.celulas.get(a)) == null ? void 0 : e.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: e } = this.projetar(t.coordenada), i = `${this.zoom}:${Math.floor(a / q)}:${Math.floor(e / q)}`;
+    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 e = this.celulas.get(a), i = e == null ? void 0 : e.membros.get(t);
+    return e && i && (e.membros.delete(t), e.somaLat -= i.coordenada[0], e.somaLon -= i.coordenada[1], e.membros.size < 2 && this.multiplas.delete(a), e.membros.size === 0 && this.celulas.delete(a)), a;
+  }
+}
+const It = 3, bt = 0.75, lt = 85.0511287798, ca = 256;
+function Q(o, t, a) {
+  const e = ca * 2 ** a, i = Math.max(-lt, Math.min(lt, o)), n = Math.sin(i * Math.PI / 180);
+  return {
+    x: (t + 180) / 360 * e,
+    y: (0.5 - Math.log((1 + n) / (1 - n)) / (4 * Math.PI)) * e
+  };
+}
+const da = (o) => Number.isFinite(o.minLat) && Number.isFinite(o.maxLat) && Number.isFinite(o.minLon) && Number.isFinite(o.maxLon) && o.minLat <= o.maxLat && o.minLon <= o.maxLon;
+function Ot(o, t) {
+  if (!Number.isFinite(t) || t < 0 || !da(o)) return NaN;
+  const a = Q(o.minLat, o.minLon, t), e = Q(o.maxLat, o.maxLon, t);
+  return Math.hypot(e.x - a.x, e.y - a.y);
+}
+function la(o, t, a = It) {
+  if (!o) return !1;
+  const e = Ot(o, t);
+  return Number.isFinite(e) && e < a;
+}
+function ua(o) {
+  return Number.isFinite(o) && o < 1.5 ? 1 : 2;
+}
+function ha(o) {
+  const t = /* @__PURE__ */ new Map();
+  for (const a of o) {
+    const e = t.get(a.cor);
+    e ? e.push(a) : t.set(a.cor, [a]);
+  }
+  return t;
+}
+const fa = "#38bdf8";
+function Va(o, t, a, e, i, n, s) {
+  let r = 0;
+  const c = ha(t);
+  for (const [l, d] of c) {
+    let h = !1;
+    for (const u of d) {
+      const g = Q(u.lat, u.lon, a), x = g.x - e, f = g.y - i;
+      x >= -2 && f >= -2 && x <= n + 2 && f <= s + 2 && (h || (o.fillStyle = l || fa, o.globalAlpha = bt, h = !0), o.fillRect(Math.round(x - u.lado / 2), Math.round(f - u.lado / 2), u.lado, u.lado), r++);
+    }
+  }
+  return r;
+}
+const ma = [
+  "continua",
+  "tracejada",
+  "tracejada-curta",
+  "tracejada-longa",
+  "pontilhada",
+  "traco-ponto",
+  "traco-ponto-ponto",
+  "oculta",
+  "centro",
+  "fantasma",
+  "divisa"
+], pa = {
+  tracejada: [12, 6],
+  "tracejada-curta": [6, 4],
+  "tracejada-longa": [24, 8],
+  pontilhada: [0, 4],
+  "traco-ponto": [12, 4, 0, 4],
+  "traco-ponto-ponto": [12, 4, 0, 4, 0, 4],
+  oculta: [6, 3],
+  centro: [24, 4, 6, 4],
+  fantasma: [24, 4, 6, 4, 6, 4],
+  divisa: [12, 4, 12, 4, 0, 4]
+}, ut = { arredondada: "round", reta: "butt", quadrada: "square" }, ht = { arredondada: "round", chanfrada: "bevel", angular: "miter" }, ga = 0.05, va = 100, ft = {
+  continuous: "continua",
+  dashed: "tracejada",
+  dashed2: "tracejada-curta",
+  dashedx2: "tracejada-longa",
+  dot: "pontilhada",
+  dotted: "pontilhada",
+  dashdot: "traco-ponto",
+  divide: "traco-ponto-ponto",
+  hidden: "oculta",
+  center: "centro",
+  phantom: "fantasma",
+  border: "divisa"
+};
+function mt(o) {
+  return typeof o == "string" && ma.includes(o);
+}
+function Nt(o) {
+  if (mt(o)) return o;
+  if (typeof o != "string") return;
+  const t = o.trim().toLowerCase();
+  return mt(t) ? t : Object.prototype.hasOwnProperty.call(ft, t) ? ft[t] : void 0;
+}
+function pt(o) {
+  return typeof o == "string" && Object.prototype.hasOwnProperty.call(ut, o) ? ut[o] : void 0;
+}
+function gt(o) {
+  return typeof o == "string" && Object.prototype.hasOwnProperty.call(ht, o) ? ht[o] : void 0;
+}
+function Ma(o) {
+  return typeof o != "number" || !Number.isFinite(o) || o <= 0 ? 1 : Math.min(va, Math.max(ga, o));
+}
+function vt(o, t, a = 1, e = "round") {
+  const i = Nt(o);
+  if (!i || i === "continua") return;
+  const n = Number.isFinite(t) && t > 0 ? t : 1, s = Ma(a) * Math.max(1, n / 2), r = e === "butt" ? n : 0, c = e === "butt" ? 0 : n;
+  return pa[i].map((l, d) => {
+    const h = d % 2 === 0 ? l === 0 ? r : l * s : l * s + c;
+    return Math.round(h * 100) / 100;
+  }).join(" ");
+}
+const U = "#38bdf8", xa = "#38bdf8", La = /^(#[0-9a-f]{3,8}|(rgb|hsl)a?\([0-9.,%\s\/-]+\)|[a-z]{3,20})$/i;
+function B(o, t) {
+  return typeof o == "string" && La.test(o.trim()) ? o.trim() : t;
+}
+const I = (o) => typeof o == "number" && Number.isFinite(o);
+function Mt(o, t, a = !1) {
+  const e = o.estilo ?? {}, i = B(e.corTraco ?? t.corPrimaria, U), n = o.geometria.tipo, s = n === "Polygon" || n === "Circle", r = n === "Point", c = r && B(e.corContorno, "") || i, l = r && I(e.espessuraContorno) && e.espessuraContorno >= 0 ? e.espessuraContorno : void 0, d = l ?? (I(e.espessuraTraco) ? e.espessuraTraco : void 0) ?? (I(t.espessuraLinha) ? t.espessuraLinha : 2), h = I(e.opacidadePreenchimento) ? e.opacidadePreenchimento : s ? 0.2 : 0.85, u = a ? d + 2 : d, g = pt(e.terminacaoTraco) ?? pt(t.terminacaoLinha) ?? "round", x = I(e.opacidadeTraco) ? e.opacidadeTraco : I(t.opacidadeLinha) ? t.opacidadeLinha : 1;
+  return {
+    cor: a ? xa : c,
+    traco: !(l === 0 && !a),
+    peso: u,
+    dash: Pa(o, t, u, g),
+    // selecionada fica opaca: a seleção precisa aparecer mesmo numa linha quase transparente
+    opacidadeTraco: a ? 1 : Math.min(1, Math.max(0, x)),
+    terminacao: g,
+    juncao: gt(e.juncaoTraco) ?? gt(t.juncaoLinha) ?? "round",
+    deslocamentoDash: I(e.deslocamentoTracejado) ? e.deslocamentoTracejado : 0,
+    preencher: s || r,
+    corPreenchimento: B(e.corPreenchimento, i),
+    opacidadePreenchimento: a ? Math.min(1, h + 0.18) : h
+  };
+}
+function Pa(o, t, a, e) {
+  const i = o.estilo ?? {};
+  if (i.dashArray) return i.dashArray;
+  if (i.tipoLinha !== void 0 && i.tipoLinha !== null) {
+    const n = vt(i.tipoLinha, a, i.escalaTipoLinha ?? t.escalaTipoLinha, e);
+    if (n || Nt(i.tipoLinha) === "continua") return n;
+  }
+  return b(o) === "previa" ? "6 4" : t.dashArray ? t.dashArray : vt(t.tipoLinha, a, t.escalaTipoLinha, e);
+}
+function Aa(o, t) {
+  var e;
+  const a = ((e = o.estilo) == null ? void 0 : e.tamanhoIcone) ?? t.tamanhoMarcador ?? 8;
+  return (I(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.opacidadeTraco ?? 1}|${t.terminacao ?? ""}|${t.juncao ?? ""}|${t.deslocamentoDash ?? 0}|${t.preencher ? 1 : 0}|${t.corPreenchimento}|${t.opacidadePreenchimento}`, e = this.porChave.get(a);
+    return e || (this.porChave.set(a, t), t);
+  }
+  limpar() {
+    this.porChave.clear();
+  }
+}
+const ya = 0.3, xt = (o) => !!o && typeof o.id == "string" && !!o.geometria && typeof o.geometria.tipo == "string";
+class Ca {
+  constructor() {
+    M(this, "loja", /* @__PURE__ */ new Map());
+    M(this, "indice", new Gt());
+    /** 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) => xt(s) && !s.excluida), e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+    for (const s of a)
+      i.add(s.id), this.loja.get(s.id) !== s && e.add(s.id);
+    const n = [...this.loja.keys()].filter((s) => !i.has(s));
+    if (e.size > 0 || n.length > 0) {
+      if (this.revisao++, this.revisaoBase++, this.loja.size === 0 || e.size + n.length > a.length * ya)
+        this.indice.construir(a);
+      else {
+        for (const s of a) e.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 e) 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: [...e], 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 (b(t) !== "oficial") {
+        this.nPrevias++;
+        const e = O(t);
+        this.contPrevias.set(e, (this.contPrevias.get(e) ?? 0) + 1);
+        continue;
+      }
+      const a = O(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 e = /* @__PURE__ */ new Map(), i = (d, h) => {
+      if (!d || d.excluida || b(d) !== "oficial") return;
+      const u = O(d);
+      e.has(u) || e.set(u, this.oficiais.has(u));
+      const g = (this.contOficiais.get(u) ?? 0) + h;
+      g <= 0 ? (this.contOficiais.delete(u), this.oficiais.delete(u)) : (this.contOficiais.set(u, g), this.oficiais.add(u));
+    }, n = (d, h) => {
+      const u = O(d), g = (this.contPrevias.get(u) ?? 0) + h;
+      g <= 0 ? this.contPrevias.delete(u) : this.contPrevias.set(u, g);
+    }, s = [], r = [], c = (d) => {
+      const h = this.loja.get(d);
+      h && (b(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 (!xt(d)) continue;
+      if (d.excluida) {
+        c(d.id);
+        continue;
+      }
+      const h = this.loja.get(d.id);
+      b(d) === "previa" && (this.nPrevias++, n(d, 1)), h && (b(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 e) h !== this.oficiais.has(d) && (l = !0);
+    return this.listaSincronizada = t, this.revisao++, l && this.revisaoBase++, { mudadas: s, removidas: r, oficiaisMudou: l };
+  }
+}
+const Sa = 256, j = 85.0511287798, Ia = 4007501668557849e-8;
+function jt(o, t, a, e, i) {
+  const n = a > j ? j : a < -j ? -j : a, s = Math.sin(n * Math.PI / 180);
+  o[t] = (e + 180) / 360 * i, o[t + 1] = (0.5 - Math.log((1 + s) / (1 - s)) / (4 * Math.PI)) * i;
+}
+const V = (o) => Sa * 2 ** o;
+function Xa(o, t, a) {
+  const e = V(a);
+  return [Math.atan(Math.sinh(Math.PI * (1 - 2 * t / e))) * 180 / Math.PI, o / e * 360 - 180];
+}
+function Lt(o, t) {
+  const a = V(t), e = new Float64Array(o.length * 2);
+  for (let i = 0; i < o.length; i++) {
+    const n = o[i];
+    jt(e, i * 2, n[0], n[1], a);
+  }
+  return e;
+}
+function E(o, t, a) {
+  const e = new Float64Array(2);
+  return jt(e, 0, o, t, V(a)), e;
+}
+function ba(o, t) {
+  const a = Math.max(-j, Math.min(j, o));
+  return Ia * Math.cos(a * Math.PI / 180) / V(t);
+}
+function Oa(o, t, a) {
+  const e = ba(o, a), i = t / e;
+  return Number.isFinite(i) && i >= 0 ? i : 0;
+}
+function Ga(o) {
+  let t = 1 / 0, a = 1 / 0, e = -1 / 0, i = -1 / 0;
+  for (const n of o)
+    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 > e && (e = r), c < a && (a = c), c > i && (i = c));
+    }
+  return t <= e && a <= i ? { minX: t, minY: a, maxX: e, maxY: i } : null;
+}
+function Na(o, t, a, e, i, n) {
+  const s = i - a, r = n - e, c = s * s + r * r;
+  let l = c === 0 ? 0 : ((o - a) * s + (t - e) * r) / c;
+  return l = l < 0 ? 0 : l > 1 ? 1 : l, Math.hypot(o - (a + l * s), t - (e + l * r));
+}
+function Pt(o, t, a) {
+  const e = o.length >> 1;
+  if (!(t > 0) || e < 3) return o;
+  let i = o, n = e;
+  a && (i = new Float64Array((e + 1) * 2), i.set(o), i[e * 2] = o[0], i[e * 2 + 1] = o[1], n = e + 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(), g = r.pop();
+    let x = 0, f = -1;
+    const m = i[g * 2], L = i[g * 2 + 1], w = i[u * 2], S = i[u * 2 + 1];
+    for (let y = g + 1; y < u; y++) {
+      const v = Na(i[y * 2], i[y * 2 + 1], m, L, w, S);
+      v > x && (x = v, f = y);
+    }
+    f !== -1 && x > t && (s[f] = 1, r.push(g, 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 o;
+  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 ja = 1.2, z = 1e-9, wa = 6, _ = {
+  cor: U,
+  traco: !1,
+  peso: 0,
+  dash: void 0,
+  preencher: !1,
+  corPreenchimento: U,
+  opacidadePreenchimento: 0
+}, H = (o) => !!o && Number.isFinite(o.zoom) && o.zoom >= 0 && !!o.caixa && Number.isFinite(o.caixa.minLat) && Number.isFinite(o.caixa.maxLat) && Number.isFinite(o.caixa.minLon) && Number.isFinite(o.caixa.maxLon);
+class Za {
+  constructor() {
+    M(this, "camadas", /* @__PURE__ */ new Map());
+    M(this, "regra", null);
+    M(this, "limiteMarcaPx", It);
+    M(this, "toleranciaPx", ja);
+  }
+  /**
+   * Ajusta o LOD (diagonal em px abaixo da qual a feição vira marca) e a tolerância da simplificação em px (perfis de
+   * `qualidade.ts`). Valor inválido (NaN, <= 0) mantém o atual. Ao mudar de verdade, os caches por zoom são descartados.
+   */
+  definirQualidade(t) {
+    const a = Number.isFinite(t == null ? void 0 : t.limiteMarcaPx) && t.limiteMarcaPx > 0 ? t.limiteMarcaPx : this.limiteMarcaPx, e = Number.isFinite(t == null ? void 0 : t.toleranciaPx) && t.toleranciaPx > 0 ? t.toleranciaPx : this.toleranciaPx;
+    if (!(a === this.limiteMarcaPx && e === this.toleranciaPx)) {
+      this.limiteMarcaPx = a, this.toleranciaPx = e;
+      for (const i of this.camadas.values())
+        i.geom.clear(), i.lod.clear(), i.zoomCache = -1, i.dados.revisao++;
+    }
+  }
+  // ---------------------------------------------------------------- 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 Ca(),
+        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 e = JSON.stringify(a.def.estilo) !== JSON.stringify(t.estilo);
+    a.def = t, e && (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 e = this.camadas.get(t);
+    if (!e) return;
+    const i = Array.isArray(a) ? a : [], n = e.dados.sincronizar(i);
+    this.aposMudanca(e, 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, e) {
+    const i = this.camadas.get(t);
+    if (!i) return;
+    const n = Array.isArray(a) ? a : [], s = /* @__PURE__ */ new Map();
+    if (e) {
+      for (const l of e.removidas ?? []) s.set(l, this.pontoVisivel(i, i.dados.loja.get(l)));
+      for (const l of e.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, e);
+    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 e;
+    return !!a && ((e = a.geometria) == null ? void 0 : e.tipo) === "Point" && t.dados.desenhavel(a);
+  }
+  aposMudanca(t, a, e, 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 e)
+      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, e) {
+    const i = t.agrupador;
+    if (i) {
+      for (const n of e) 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 e = this.camadas.get(t);
+    if (!e) return { entrou: [], saiu: [] };
+    const i = /* @__PURE__ */ new Set();
+    for (const r of a) e.dados.loja.has(r) && i.add(r);
+    const n = [], s = [];
+    for (const r of i) e.dados.selecionadas.has(r) || n.push(r);
+    for (const r of e.dados.selecionadas) i.has(r) || s.push(r);
+    e.dados.selecionadas.clear();
+    for (const r of i) e.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 e = this.camadas.get(t);
+    !e || !a || typeof a.id != "string" || !e.dados.loja.has(a.id) || e.previas.set(a.id, a);
+  }
+  temPrevia(t, a) {
+    var e;
+    return ((e = this.camadas.get(t)) == null ? void 0 : e.previas.has(a)) ?? !1;
+  }
+  /** Realce temporário (hover): as feições entram na sobreposição com `destaque: true`. */
+  destacar(t, a) {
+    const e = this.camadas.get(t);
+    e && (e.destaques = new Set(a));
+  }
+  // ---------------------------------------------------------------- consultas (geometria original)
+  feicao(t, a) {
+    var e;
+    return (e = this.camadas.get(t)) == null ? void 0 : e.dados.loja.get(a);
+  }
+  caixaDe(t, a) {
+    var e;
+    return (e = this.camadas.get(t)) == null ? void 0 : e.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 e = this.camadas.get(t);
+    if (!e) return [];
+    const i = [];
+    for (const n of e.dados.indice.consultar(a)) {
+      const s = e.dados.loja.get(n);
+      s && !s.oculta && i.push(s);
+    }
+    return i;
+  }
+  feicaoVisivel(t, a) {
+    const e = this.camadas.get(t);
+    return !e || e.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 e = this.camadas.get(t);
+    return !!e && this.emPar(e, 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 e = this.origemDe(t), i = { vista: t, origem: e, 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 e = t.dados.revisaoDaFeicao(a.id), i = t.estilos.get(a.id);
+    if (i && i.rev === e && i.revEstilo === t.revEstilo) return i.estilo;
+    const n = t.internador.interno(Mt(a, t.def.estilo, !1));
+    return t.estilos.set(a.id, { rev: e, revEstilo: t.revEstilo, estilo: n }), n;
+  }
+  emPar(t, a) {
+    if (t.dados.contPrevias.size === 0) return !1;
+    const e = O(a);
+    return t.dados.contPrevias.has(e) && t.dados.oficiais.has(e);
+  }
+  /**
+   * 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, e) {
+    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 = la(t.dados.indice.caixaDe(a.id), e, this.limiteMarcaPx);
+    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, e) {
+    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, e, i);
+    return s && t.geom.set(a.id, s), s;
+  }
+  construirGeometria(t, a, e, i) {
+    const n = a.geometria, s = e < At ? this.toleranciaPx : 0;
+    if (n.tipo === "Polygon") {
+      const r = [];
+      for (const c of n.aneis ?? []) {
+        if (!Array.isArray(c) || c.length < 3) continue;
+        let l = Lt(c, e);
+        s > 0 && c.length >= J && (l = Pt(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 F(n)) {
+        if (!Array.isArray(c) || c.length < 2) continue;
+        let l = Lt(c, e);
+        s > 0 && c.length >= J && (l = Pt(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], e);
+      return { rev: i, partes: [c], raioPx: Oa(r[0], n.raioMetros, e), marca: !1 };
+    }
+    return n.tipo === "Point" || n.tipo === "Text" ? { rev: i, partes: [E(n.coordenada[0], n.coordenada[1], e)], raioPx: n.tipo === "Point" ? Aa(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, e) {
+    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, e);
+    if (!(Number.isFinite(r[0]) && Number.isFinite(r[1]))) return null;
+    const c = { rev: i, partes: [r], raioPx: ua(Ot(s, e)), 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, e) {
+    const i = this.marcaDe(t, a, e);
+    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 e = a.estilo ?? {}, i = B(e.corPreenchimento ?? e.corTraco ?? t.def.estilo.corPrimaria, U);
+    return t.internador.interno({ cor: i, traco: !1, peso: 0, dash: void 0, preencher: !0, corPreenchimento: i, opacidadePreenchimento: bt });
+  }
+  agrupadorAtivo(t, a) {
+    const { dados: e } = t;
+    if (t.nPontosRev !== e.revisaoBase) {
+      let s = 0;
+      for (const r of e.loja.values()) r.geometria.tipo === "Point" && e.desenhavel(r) && s++;
+      t.nPontos = s, t.nPontosRev = e.revisaoBase;
+    }
+    if (!St(t.nPontos, a))
+      return t.agrupador = null, null;
+    const i = t.agrupador;
+    if (i && i.zoom === a && t.agrupadorRev === e.revisaoBase) return i;
+    const n = new ra(a, (s) => {
+      const r = E(s[0], s[1], a);
+      return { x: r[0], y: r[1] };
+    });
+    for (const s of e.loja.values())
+      s.geometria.tipo === "Point" && e.desenhavel(s) && n.inserir({ id: s.id, coordenada: s.geometria.coordenada });
+    return t.agrupador = n, t.agrupadorRev = e.revisaoBase, n;
+  }
+  itemBase(t, a, e, i, n, s) {
+    return {
+      camadaId: t.def.id,
+      id: a.id,
+      forma: e,
+      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) * wa, 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, e) {
+    var y;
+    const { dados: i, def: n } = t, s = e !== "dom", r = e !== "canvas", c = a.zoom;
+    this.prepararZoom(t, c);
+    const l = i.indice.consultar(this.caixaComFolga(a)), d = this.agrupadorAtivo(t, c), h = [], u = [], g = [], x = [], f = [], m = { total: i.loja.size, desenhadas: 0, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: 0 }, L = (v) => {
+      var A;
+      if (!r || !((A = v.estilo) != null && A.mostrarRotulo) || v.geometria.tipo === "Text") return;
+      const p = qt(v, v.estilo.campoRotulo), P = i.indice.caixaDe(v.id);
+      !p || !P || (f.push({
+        camadaId: n.id,
+        id: `rotulo:${v.id}`,
+        forma: "rotulo",
+        geometriaEmPx: [],
+        raioPx: 0,
+        estilo: _,
+        selecionada: !1,
+        feicao: v,
+        texto: p,
+        coordenada: [(P.minLat + P.maxLat) / 2, (P.minLon + P.maxLon) / 2]
+      }), m.marcadoresDom++);
+    }, w = (v) => {
+      var A;
+      const p = v.geometria;
+      if (p.tipo !== "Point") return;
+      if ((A = v.estilo) != null && A.icone) {
+        if (!r) return;
+        f.push({ ...this.itemBase(t, v, "icone", [], 0, _), coordenada: p.coordenada }), m.marcadoresDom++;
+        return;
+      }
+      if (!s) return;
+      const P = this.geometriaProjetada(t, v, c);
+      P && (x.push(this.itemBase(t, v, "ponto", P.partes, P.raioPx, this.estiloDe(t, v))), m.desenhadas++);
+    };
+    for (const v of l) {
+      const p = i.loja.get(v);
+      if (!p || !i.desenhavel(p) || t.previas.has(v)) continue;
+      const P = p.geometria;
+      if (P.tipo === "Point") {
+        if (d && d.emCluster(v) && (!((y = p.estilo) != null && y.icone) || !r || !this.soltoDoCluster(t, d, v)))
+          continue;
+        w(p), L(p);
+        continue;
+      }
+      if (P.tipo === "Text") {
+        if (!r) continue;
+        f.push({ ...this.itemBase(t, p, "texto", [], 0, _), 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 A = t.geom.get(v), C = A == null ? void 0 : A.item;
+      if (C && C.feicao === p && A.revEstilo === t.revEstilo && !this.emPar(t, p) && C.selecionada === i.selecionadas.has(v) && C.destaque === !0 === t.destaques.has(v)) {
+        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 N = this.geometriaProjetada(t, p, c);
+      if (!N) continue;
+      const X = this.estiloDe(t, p);
+      P.tipo === "LineString" ? g.push(this.itemBase(t, p, "linha", N.partes, 0, X)) : P.tipo === "Circle" ? u.push(this.itemBase(t, p, "circulo", N.partes, N.raioPx, X)) : u.push(this.itemBase(t, p, "poligono", N.partes, 0, X)), m.desenhadas++, L(p);
+    }
+    d && r && this.listarClusters(t, a, d, f, m, r), m.avaliacoesLOD = t.avaliacoesLOD, e === "tudo" && (t.ultima = m);
+    const S = h;
+    for (const v of [u, g, x, f]) for (const p of v) S.push(p);
+    return { camadaId: n.id, zIndex: n.zIndex, opacidade: n.opacidade, itens: S, 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, e, i, n, s) {
+    const { dados: r, def: c } = t;
+    for (const [l, d] of e.celulasAgrupadas()) {
+      const h = d.membros.size;
+      let u = 0, g = d.somaLat, x = d.somaLon;
+      for (const L of d.membros.values())
+        r.selecionadas.has(L.id) && (u++, g -= L.coordenada[0], x -= L.coordenada[1]);
+      const f = h - u, m = [d.somaLat / h, d.somaLon / h];
+      m[0] >= a.caixa.minLat - z && m[0] <= a.caixa.maxLat + z && m[1] >= a.caixa.minLon - z && m[1] <= a.caixa.maxLon + z && (f < 2 || !s || (i.push({
+        camadaId: c.id,
+        id: l,
+        forma: "cluster",
+        geometriaEmPx: [],
+        raioPx: 0,
+        estilo: _,
+        selecionada: !1,
+        coordenada: [g / 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 e = this.camadas.get(t);
+    return !!(e != null && e.agrupador) && e.agrupador.emCluster(a) && !e.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, e) {
+    if (t.dados.selecionadas.has(e)) return !0;
+    const i = a.chaveDoPonto(e), 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 e = this.camadas.get(t), i = (n = e == null ? void 0 : e.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 e = this.camadas.get(t);
+    if (!e || !H(a)) return null;
+    this.prepararZoom(e, a.zoom);
+    const i = [], n = /* @__PURE__ */ new Set([...e.dados.selecionadas, ...e.previas.keys(), ...e.destaques]), s = e.agrupador;
+    if (s && e.dados.selecionadas.size > 0) {
+      const c = /* @__PURE__ */ new Set();
+      for (const l of e.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) => !e.dados.selecionadas.has(u));
+        h.length === 1 && n.add(h[0]);
+      }
+    }
+    for (const c of n) {
+      const l = e.dados.loja.get(c);
+      if (!l || !e.dados.desenhavel(l)) continue;
+      const d = e.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 g = d ? null : e.dados.indice.caixaDe(c);
+      if (g && !$(g, a.caixa)) continue;
+      const x = e.dados.selecionadas.has(c) || !!d;
+      if (!x && !e.destaques.has(c) && !(u.tipo === "Point" && (s != null && s.emCluster(c)))) continue;
+      const f = d ? this.construirGeometria(e, h, a.zoom, -1) : this.geometriaProjetada(e, h, a.zoom);
+      if (!f) continue;
+      const m = e.internador.interno(Mt(h, e.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,
+        ...e.destaques.has(c) ? { destaque: !0 } : {}
+      });
+    }
+    return {
+      camadaId: t,
+      zIndex: e.def.zIndex,
+      opacidade: e.def.opacidade,
+      itens: i,
+      estatisticas: { total: e.dados.loja.size, desenhadas: i.length, marcasLOD: 0, clusters: 0, marcadoresDom: 0, avaliacoesLOD: e.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 e = this.camadas.get(t);
+    if (!e || !e.agrupador) return !1;
+    for (const n of a) if (((i = e.dados.loja.get(n)) == null ? void 0 : i.geometria.tipo) === "Point") return !0;
+    return !1;
+  }
+}
+export {
+  ma as $,
+  ra as A,
+  Aa as B,
+  U as C,
+  qt as D,
+  Za as E,
+  Xa as F,
+  ka as G,
+  Bt as H,
+  Gt as I,
+  kt as J,
+  _t as K,
+  $t as L,
+  J as M,
+  Ut as N,
+  at as O,
+  aa as P,
+  gt as Q,
+  za as R,
+  pt as S,
+  Nt as T,
+  q as U,
+  Ca as V,
+  Da as W,
+  It as X,
+  na as Y,
+  At as Z,
+  bt as _,
+  Tt as a,
+  ia as a0,
+  ha as a1,
+  Ua as a2,
+  Rt as a3,
+  it as a4,
+  Ga as a5,
+  sa as a6,
+  vt as a7,
+  mt as a8,
+  V as a9,
+  rt as aa,
+  Ma as ab,
+  ba as ac,
+  E as ad,
+  jt as ae,
+  Q as af,
+  Lt as ag,
+  Oa as ah,
+  Qt as ai,
+  Dt as aj,
+  Pt as ak,
+  Ht as al,
+  F as b,
+  Ba as c,
+  Fa as d,
+  Ta as e,
+  tt as f,
+  yt as g,
+  oa as h,
+  _a as i,
+  $a as j,
+  Va as k,
+  B as l,
+  qa as m,
+  dt as n,
+  xa as o,
+  ea as p,
+  O as q,
+  Ra as r,
+  b as s,
+  la as t,
+  ua as u,
+  Yt as v,
+  Ot as w,
+  St as x,
+  $ as y,
+  Mt as z
+};