@nika-js/onlymap 0.7.6 → 0.8.0

package/dist/cartograph.js

@@ -0,0 +1,2768 @@
+let $t = null, Z = null;
+function ye(r) {
+  $t = r;
+}
+function Ze() {
+  return B !== null;
+}
+let B = null;
+function H() {
+  return B;
+}
+function we() {
+  return B ? Promise.resolve(B) : Z || ($t ? (Z = Promise.resolve($t()).then((r) => (B = r, B)).catch((r) => {
+    throw Z = null, r;
+  }), Z) : Promise.reject(
+    new Error(
+      '[onlymapjs/cartograph] No map runtime loader is configured. Import the cartograph entry ("@nika-js/onlymap/cartograph" or its standalone build) rather than a submodule — the entry installs it.'
+    )
+  ));
+}
+const Je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  isCoreLoaded: Ze,
+  loadCore: we,
+  peekCore: H,
+  setCoreLoader: ye
+}, Symbol.toStringTag, { value: "Module" }));
+function _t(r) {
+  return { scale: r / 96, pxPerMm: r / 25.4 };
+}
+function ft(r) {
+  return typeof r?.paintCartograph == "function";
+}
+const q = (r, t) => {
+  const e = r.getAttribute(t);
+  if (e == null || e.trim() === "") return null;
+  const n = Number(e);
+  return Number.isFinite(n) ? n : null;
+};
+function C(r) {
+  return {
+    x: q(r, "x") ?? 0,
+    y: q(r, "y") ?? 0,
+    w: q(r, "w") ?? 0,
+    h: q(r, "h") ?? 0,
+    rotation: q(r, "rotation") ?? 0,
+    z: q(r, "z")
+  };
+}
+function kt(r, t = 0) {
+  if (!r) return t;
+  const e = Number.parseFloat(r);
+  return Number.isFinite(e) ? e : t;
+}
+function L(r) {
+  if (!r) return null;
+  const t = r.trim().toLowerCase();
+  return t === "transparent" || t === "rgba(0, 0, 0, 0)" || t === "none" ? null : r;
+}
+const W = 96 / 25.4, Ot = {
+  A0: { widthMm: 841, heightMm: 1189 },
+  A1: { widthMm: 594, heightMm: 841 },
+  A2: { widthMm: 420, heightMm: 594 },
+  A3: { widthMm: 297, heightMm: 420 },
+  A4: { widthMm: 210, heightMm: 297 },
+  A5: { widthMm: 148, heightMm: 210 },
+  Letter: { widthMm: 215.9, heightMm: 279.4 },
+  Legal: { widthMm: 215.9, heightMm: 355.6 }
+}, Ut = "A4";
+function ct(r, t, e, n) {
+  const i = t != null ? Number(t) : NaN, s = e != null ? Number(e) : NaN;
+  if (Number.isFinite(i) && i > 0 && Number.isFinite(s) && s > 0) return { widthMm: i, heightMm: s };
+  const o = Ot[r ?? Ut] ?? Ot[Ut];
+  return n === "landscape" ? { widthMm: o.heightMm, heightMm: o.widthMm } : { ...o };
+}
+let tt = null;
+function Qe(r) {
+  if (!tt) {
+    tt = new Uint32Array(256);
+    for (let e = 0; e < 256; e++) {
+      let n = e;
+      for (let i = 0; i < 8; i++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+      tt[e] = n >>> 0;
+    }
+  }
+  let t = 4294967295;
+  for (let e = 0; e < r.length; e++) t = tt[(t ^ r[e]) & 255] ^ t >>> 8;
+  return (t ^ 4294967295) >>> 0;
+}
+function tr(r) {
+  const t = Math.max(1980, r.getFullYear());
+  return {
+    time: r.getHours() << 11 | r.getMinutes() << 5 | Math.floor(r.getSeconds() / 2),
+    date: t - 1980 << 9 | r.getMonth() + 1 << 5 | r.getDate()
+  };
+}
+async function er(r, t = /* @__PURE__ */ new Date()) {
+  const e = new TextEncoder(), { time: n, date: i } = tr(t), s = [], o = [];
+  let a = 0;
+  for (const u of r) {
+    const m = u.data instanceof Blob ? new Uint8Array(await u.data.arrayBuffer()) : u.data, d = e.encode(u.name), h = Qe(m), f = new DataView(new ArrayBuffer(30));
+    f.setUint32(0, 67324752, !0), f.setUint16(4, 20, !0), f.setUint16(6, 2048, !0), f.setUint16(8, 0, !0), f.setUint16(10, n, !0), f.setUint16(12, i, !0), f.setUint32(14, h, !0), f.setUint32(18, m.length, !0), f.setUint32(22, m.length, !0), f.setUint16(26, d.length, !0), f.setUint16(28, 0, !0), s.push(new Uint8Array(f.buffer), d, m), o.push({ name: u.name, bytes: m, crc: h, offset: a }), a += 30 + d.length + m.length;
+  }
+  const l = a;
+  for (const u of o) {
+    const m = e.encode(u.name), d = new DataView(new ArrayBuffer(46));
+    d.setUint32(0, 33639248, !0), d.setUint16(4, 20, !0), d.setUint16(6, 20, !0), d.setUint16(8, 2048, !0), d.setUint16(10, 0, !0), d.setUint16(12, n, !0), d.setUint16(14, i, !0), d.setUint32(16, u.crc, !0), d.setUint32(20, u.bytes.length, !0), d.setUint32(24, u.bytes.length, !0), d.setUint16(28, m.length, !0), d.setUint16(30, 0, !0), d.setUint16(32, 0, !0), d.setUint16(34, 0, !0), d.setUint16(36, 0, !0), d.setUint32(38, 0, !0), d.setUint32(42, u.offset, !0), s.push(new Uint8Array(d.buffer), m), a += 46 + m.length;
+  }
+  const c = new DataView(new ArrayBuffer(22));
+  return c.setUint32(0, 101010256, !0), c.setUint16(4, 0, !0), c.setUint16(6, 0, !0), c.setUint16(8, o.length, !0), c.setUint16(10, o.length, !0), c.setUint32(12, a - l, !0), c.setUint32(16, l, !0), c.setUint16(20, 0, !0), s.push(new Uint8Array(c.buffer)), new Blob(s, { type: "application/zip" });
+}
+const dt = ["protanopia", "deuteranopia", "tritanopia", "achromatopsia"], Me = {
+  protan: "protanopia",
+  deutan: "deuteranopia",
+  tritan: "tritanopia",
+  achroma: "achromatopsia"
+};
+function Lt(r) {
+  const t = r?.trim().toLowerCase();
+  return !t || t === "none" ? null : dt.includes(t) ? t : Me[t] ?? null;
+}
+const rr = ["none", ...dt, ...Object.keys(Me)], Ft = {
+  protanopia: [0.11238, 0.88762, 0, 0.11238, 0.88762, 0, 401e-5, -401e-5, 1],
+  deuteranopia: [0.29275, 0.70725, 0, 0.29275, 0.70725, 0, -0.02234, 0.02234, 1],
+  tritanopia: [1, 0.14461, -0.14461, 0, 0.85659, 0.14341, 0, 0.85659, 0.14341],
+  achromatopsia: [0.2126, 0.7152, 0.0722, 0.2126, 0.7152, 0.0722, 0.2126, 0.7152, 0.0722]
+}, D = (r) => {
+  const t = r / 255;
+  return t <= 0.04045 ? t / 12.92 : ((t + 0.055) / 1.055) ** 2.4;
+}, at = (r) => {
+  const t = Math.min(1, Math.max(0, r));
+  return 255 * (t <= 31308e-7 ? t * 12.92 : 1.055 * t ** (1 / 2.4) - 0.055);
+};
+function nr(r) {
+  const t = r.trim().toLowerCase(), e = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(t);
+  if (e) {
+    const i = e[1], s = (o) => parseInt(o.length === 1 ? o + o : o, 16);
+    return i.length === 3 ? { r: s(i[0]), g: s(i[1]), b: s(i[2]) } : { r: s(i.slice(0, 2)), g: s(i.slice(2, 4)), b: s(i.slice(4, 6)) };
+  }
+  const n = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/.exec(t);
+  return n ? { r: Number(n[1]), g: Number(n[2]), b: Number(n[3]) } : null;
+}
+function jt(r, t) {
+  const e = Ft[t], [n, i, s] = [D(r.r), D(r.g), D(r.b)];
+  return {
+    r: at(e[0] * n + e[1] * i + e[2] * s),
+    g: at(e[3] * n + e[4] * i + e[5] * s),
+    b: at(e[6] * n + e[7] * i + e[8] * s)
+  };
+}
+function zt({ r, g: t, b: e }) {
+  const [n, i, s] = [D(r), D(t), D(e)], o = (n * 0.4124564 + i * 0.3575761 + s * 0.1804375) / 0.95047, a = n * 0.2126729 + i * 0.7151522 + s * 0.072175, l = (n * 0.0193339 + i * 0.119192 + s * 0.9503041) / 1.08883, c = (h) => h > 216 / 24389 ? Math.cbrt(h) : 841 / 108 * h + 4 / 29, [u, m, d] = [c(o), c(a), c(l)];
+  return [116 * m - 16, 500 * (u - m), 200 * (m - d)];
+}
+function Dt(r, t) {
+  const [e, n, i] = zt(r), [s, o, a] = zt(t), l = Math.PI / 180, c = 180 / Math.PI, u = (Math.hypot(n, i) + Math.hypot(o, a)) / 2, m = 0.5 * (1 - Math.sqrt(u ** 7 / (u ** 7 + 25 ** 7))), [d, h] = [n * (1 + m), o * (1 + m)], [f, p] = [Math.hypot(d, i), Math.hypot(h, a)], g = (U, Q) => {
+    if (U === 0 && Q === 0) return 0;
+    const X = Math.atan2(Q, U) * c;
+    return X >= 0 ? X : X + 360;
+  }, [b, w] = [g(d, i), g(h, a)], y = s - e, S = p - f;
+  let M = 0;
+  f * p !== 0 && (M = w - b, M > 180 ? M -= 360 : M < -180 && (M += 360));
+  const F = 2 * Math.sqrt(f * p) * Math.sin(M * l / 2), _ = (e + s) / 2, $ = (f + p) / 2;
+  let N = b + w;
+  f * p !== 0 && (Math.abs(b - w) > 180 && (N += b + w < 360 ? 360 : -360), N /= 2);
+  const T = 1 - 0.17 * Math.cos((N - 30) * l) + 0.24 * Math.cos(2 * N * l) + 0.32 * Math.cos((3 * N + 6) * l) - 0.2 * Math.cos((4 * N - 63) * l), v = 1 + 0.015 * (_ - 50) ** 2 / Math.sqrt(20 + (_ - 50) ** 2), A = 1 + 0.045 * $, k = 1 + 0.015 * $ * T, E = -2 * Math.sqrt($ ** 7 / ($ ** 7 + 25 ** 7)) * Math.sin(60 * Math.exp(-(((N - 275) / 25) ** 2)) * l);
+  return Math.sqrt((y / v) ** 2 + (S / A) ** 2 + (F / k) ** 2 + E * (S / A) * (F / k));
+}
+const ir = 10;
+function or(r, t = ir) {
+  const e = /* @__PURE__ */ new Map();
+  for (const a of r) {
+    const l = nr(a.color);
+    if (!l) continue;
+    const c = a.layer ?? "", u = e.get(c);
+    u ? u.push({ entry: a, rgb: l }) : e.set(c, [{ entry: a, rgb: l }]);
+  }
+  const n = [], i = /* @__PURE__ */ new Map();
+  for (const a of dt)
+    for (const l of e.values())
+      for (let c = 0; c < l.length; c++)
+        for (let u = c + 1; u < l.length; u++) {
+          if (Dt(l[c].rgb, l[u].rgb) < t) continue;
+          const d = Dt(jt(l[c].rgb, a), jt(l[u].rgb, a));
+          d < t && (n.push({ type: a, a: l[c].entry, b: l[u].entry, distance: d }), i.set(a, (i.get(a) ?? 0) + 1));
+        }
+  let s = null, o = 0;
+  for (const [a, l] of i)
+    l > o && (o = l, s = a);
+  return { collapses: n, worstType: s };
+}
+function sr(r, t, e, n) {
+  if (t <= 0 || e <= 0) return !0;
+  let i;
+  try {
+    i = r.getImageData(0, 0, t, e);
+  } catch {
+    return !1;
+  }
+  const s = new Float64Array(256);
+  for (let m = 0; m < 256; m++) s[m] = D(m);
+  const o = 1024, a = new Float64Array(o + 1);
+  for (let m = 0; m <= o; m++) a[m] = at(m / o);
+  const l = (m) => {
+    const d = Math.min(1, Math.max(0, m)) * o, h = Math.floor(d);
+    return h >= o ? a[o] : a[h] + (a[h + 1] - a[h]) * (d - h);
+  }, c = Ft[n], u = i.data;
+  for (let m = 0; m < u.length; m += 4) {
+    const d = s[u[m]], h = s[u[m + 1]], f = s[u[m + 2]];
+    u[m] = l(c[0] * d + c[1] * h + c[2] * f), u[m + 1] = l(c[3] * d + c[4] * h + c[5] * f), u[m + 2] = l(c[6] * d + c[7] * h + c[8] * f);
+  }
+  return r.putImageData(i, 0, 0), !0;
+}
+const ve = (r) => `om-carto-cvd-${r}`;
+function ar(r) {
+  if (r.getElementById("om-carto-cvd-filters")) return;
+  const t = r.createElementNS("http://www.w3.org/2000/svg", "svg");
+  t.id = "om-carto-cvd-filters", t.setAttribute("aria-hidden", "true"), t.setAttribute("width", "0"), t.setAttribute("height", "0"), t.style.cssText = "position:absolute;width:0;height:0;overflow:hidden;";
+  for (const e of dt) {
+    const n = r.createElementNS("http://www.w3.org/2000/svg", "filter");
+    n.id = ve(e), n.setAttribute("color-interpolation-filters", "linearRGB");
+    const i = r.createElementNS("http://www.w3.org/2000/svg", "feColorMatrix");
+    i.setAttribute("type", "matrix");
+    const s = Ft[e];
+    i.setAttribute("values", [s[0], s[1], s[2], 0, 0, s[3], s[4], s[5], 0, 0, s[6], s[7], s[8], 0, 0, 0, 0, 0, 1, 0].join(" ")), n.appendChild(i), t.appendChild(n);
+  }
+  r.body.appendChild(t);
+}
+const Ae = 16384, Se = 134217728;
+async function lr(r) {
+  const t = [], e = [...r.querySelectorAll("img")];
+  return await Promise.all(
+    e.map(async (n) => {
+      if (!(n.complete && n.naturalWidth > 0))
+        try {
+          await n.decode();
+        } catch {
+          t.push(`Image did not load and was skipped: ${n.getAttribute("src") ?? "(no src)"}`);
+        }
+    })
+  ), t;
+}
+function cr(r) {
+  return [...r.children].filter(
+    (t) => !t.hasAttribute("hidden") && !t.hasAttribute("data-om-carto-marks") && !t.hasAttribute("data-om-carto-flattened") && t.tagName.toLowerCase() !== "style" && t.tagName.toLowerCase() !== "script"
+  ).map((t, e) => ({ el: t, index: e, z: C(t).z ?? 0 })).sort((t, e) => t.z - e.z || t.index - e.index).map((t) => t.el);
+}
+async function It(r, t = {}) {
+  const e = r ?? document.querySelector("om-cartograph");
+  if (!e) throw new Error("[onlymapjs/cartograph] renderCartograph: no <om-cartograph> to render.");
+  const n = [], i = t.dpi ?? (Number(e.getAttribute("dpi")) || 300);
+  if (!Number.isFinite(i) || i <= 0) throw new Error(`[onlymapjs/cartograph] renderCartograph: invalid dpi ${t.dpi}.`);
+  const { widthMm: s, heightMm: o } = ct(
+    e.getAttribute("size"),
+    e.getAttribute("width"),
+    e.getAttribute("height"),
+    e.getAttribute("orientation")
+  ), a = Math.max(0, Number(e.getAttribute("bleed")) || 0), l = s + a * 2, c = o + a * 2, u = t.maxDimension ?? Ae, m = t.maxArea ?? Se;
+  let d = i;
+  const h = Math.min(u / (l / 25.4), u / (c / 25.4)), f = Math.sqrt(m / (l / 25.4 * (c / 25.4))), p = Math.min(h, f);
+  d > p && (d = Math.floor(p), n.push(`Requested ${i} dpi exceeds this browser's canvas budget for a ${l.toFixed(0)}×${c.toFixed(0)}mm page; rendered at ${d} dpi instead.`)), n.push(...await lr(e)), typeof document < "u" && document.fonts?.ready && await document.fonts.ready;
+  const g = _t(d), b = Math.max(1, Math.round(l * g.pxPerMm)), w = Math.max(1, Math.round(c * g.pxPerMm)), y = cr(e);
+  for (const v of y)
+    if (!(!ft(v) || !v.prepareCartograph))
+      try {
+        await v.prepareCartograph(_t(d));
+      } catch (A) {
+        v.discardCartograph?.(), n.push(`${v.tagName.toLowerCase()}${v.id ? `#${v.id}` : ""} could not be captured: ${A.message}`);
+      }
+  const S = document.createElement("canvas");
+  S.width = b, S.height = w;
+  const M = S.getContext("2d");
+  if (!M) throw new Error("[onlymapjs/cartograph] renderCartograph: could not get a 2D canvas context.");
+  const F = typeof getComputedStyle == "function" ? getComputedStyle(e) : null;
+  M.fillStyle = L(F?.backgroundColor) ?? "#ffffff", M.fillRect(0, 0, b, w);
+  for (const v of y) {
+    if (!ft(v)) continue;
+    const A = C(v);
+    if (M.save(), M.translate((A.x + a) * g.pxPerMm, (A.y + a) * g.pxPerMm), A.rotation) {
+      const k = A.w / 2 * g.pxPerMm, E = A.h / 2 * g.pxPerMm;
+      M.translate(k, E), M.rotate(A.rotation * Math.PI / 180), M.translate(-k, -E);
+    }
+    try {
+      v.paintCartograph(M, g);
+    } catch (k) {
+      n.push(`${v.tagName.toLowerCase()}${v.id ? `#${v.id}` : ""} failed to render: ${k.message}`);
+    }
+    M.restore();
+  }
+  const _ = e.querySelector(":scope > [data-om-carto-marks]");
+  for (const v of _?.querySelectorAll("line") ?? []) {
+    const A = Number(v.getAttribute("x1")), k = Number(v.getAttribute("y1")), E = Number(v.getAttribute("x2")), U = Number(v.getAttribute("y2"));
+    [A, k, E, U].every(Number.isFinite) && (M.save(), M.strokeStyle = v.getAttribute("stroke") || "#000000", M.lineWidth = (Number(v.getAttribute("stroke-width")) || 0.2) * g.pxPerMm, M.beginPath(), M.moveTo((A + a) * g.pxPerMm, (k + a) * g.pxPerMm), M.lineTo((E + a) * g.pxPerMm, (U + a) * g.pxPerMm), M.stroke(), M.restore());
+  }
+  const $ = Lt(t.cvd === "page" ? e.getAttribute("cvd") : t.cvd);
+  $ && !sr(M, b, w, $) && n.push("Colour-vision simulation was skipped: a cross-origin image on the page makes the export canvas unreadable.");
+  for (const v of y) ft(v) && v.discardCartograph?.();
+  const N = t.format === "jpeg" ? "image/jpeg" : "image/png";
+  N === "image/jpeg" && e.querySelector("om-text") && n.push("JPEG compresses text edges — prefer PNG for a page carrying labels.");
+  const T = await new Promise((v) => S.toBlob(v, N, t.quality));
+  if (!T) throw new Error("[onlymapjs/cartograph] renderCartograph: the canvas produced no image (it may have exceeded a browser limit).");
+  return { blob: T, widthPx: b, heightPx: w, dpi: d, warnings: n };
+}
+async function Ce(r, t = {}) {
+  const e = r ?? document.querySelector("om-cartograph");
+  if (!e) throw new Error("[onlymapjs/cartograph] renderCartographAtlas: no <om-cartograph> to render.");
+  const n = e.querySelector("om-atlas") ?? null;
+  if (!n) throw new Error("[onlymapjs/cartograph] renderCartographAtlas: this cartograph has no <om-atlas>.");
+  if (n.problem)
+    throw new Error(`[onlymapjs/cartograph] renderCartographAtlas: the atlas layer cannot drive pages (${n.problem}).`);
+  const i = n.count;
+  if (i === 0) throw new Error("[onlymapjs/cartograph] renderCartographAtlas: the atlas layer produced no features.");
+  const s = t.format === "jpeg" ? "jpg" : "png", o = n.filenames(s), a = [], l = n.index;
+  try {
+    if (t.page != null) {
+      const m = Math.trunc(t.page);
+      if (!Number.isInteger(m) || m < 0 || m >= i)
+        throw new Error(`[onlymapjs/cartograph] renderCartographAtlas: page ${t.page} is out of range (this atlas has ${i}).`);
+      n.seek(m);
+      const d = await Gt(e, t, a);
+      return { blob: d.blob, filenames: [o[m]], pages: 1, dpi: d.dpi, warnings: a };
+    }
+    const c = [];
+    let u = t.dpi ?? 300;
+    for (let m = 0; m < i; m++) {
+      n.seek(m);
+      const d = await Gt(e, t, a);
+      u = d.dpi, c.push({ name: o[m], data: d.blob }), t.onPage?.(m + 1, i);
+    }
+    return { blob: await er(c), filenames: o, pages: i, dpi: u, warnings: a };
+  } finally {
+    n.seek(l);
+  }
+}
+async function Gt(r, t, e) {
+  for (const i of r.querySelectorAll("om-frame"))
+    await i.mapElement?.whenSettled?.({ timeout: 2e4 });
+  const n = await It(r, t);
+  return e.push(...n.warnings), n;
+}
+const ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MAX_CANVAS_AREA: Se,
+  MAX_CANVAS_DIMENSION: Ae,
+  renderCartograph: It,
+  renderCartographAtlas: Ce
+}, Symbol.toStringTag, { value: "Module" }));
+function qt(r, t, e = {}) {
+  const n = URL.createObjectURL(r), i = document.createElement("a");
+  i.href = n, i.download = t, document.body.appendChild(i), i.click(), i.remove();
+  const s = e.revokeAfterMs ?? 0;
+  s > 0 ? setTimeout(() => URL.revokeObjectURL(n), s) : URL.revokeObjectURL(n);
+}
+const hr = 3e4;
+async function Wt(r, t = hr) {
+  let e = !1;
+  const n = new Promise(
+    (s) => setTimeout(() => {
+      e = !0, s();
+    }, t)
+  ), i = (async () => {
+    const s = [...r.querySelectorAll("om-frame")];
+    await Promise.all(s.map((a) => a.ready ?? Promise.resolve()));
+    const o = [...r.querySelectorAll("img")];
+    await Promise.all(
+      o.map(async (a) => {
+        a.complete || await new Promise((l) => {
+          a.addEventListener("load", () => l(), { once: !0 }), a.addEventListener("error", () => l(), { once: !0 });
+        });
+      })
+    ), typeof document < "u" && document.fonts?.ready && document.fonts.status !== "loaded" && await document.fonts.ready;
+  })();
+  return await Promise.race([i, n]), { timedOut: e };
+}
+async function mr(r, t = {}) {
+  if (!r.hasAttribute("allow-url-actions") || typeof document < "u" && document.documentElement?.dataset?.omHost === "editor") return null;
+  const e = t.search ?? (typeof location < "u" ? location.search : "");
+  if (!e) return null;
+  const n = new URLSearchParams(e), i = n.get("cvd");
+  i && r.setAttribute("cvd", i);
+  const s = n.get("export");
+  if (s) {
+    await Wt(r, t.timeoutMs);
+    const o = s === "jpeg" ? "jpeg" : "png", a = Number(n.get("dpi")) || void 0, l = r.getAttribute("cartograph-id") || "cartograph", c = n.get("page");
+    if (c != null) {
+      const m = r.querySelector("om-atlas");
+      if (!m) throw new Error(`?page=${c} needs an <om-atlas>; this cartograph is a single sheet.`);
+      const d = Number(c);
+      if (!Number.isInteger(d) || d < 1) throw new Error(`?page=${c} is not a page number (they start at 1).`);
+      m.refresh?.();
+      const h = await Ce(r, { dpi: a, format: o, page: d - 1 });
+      for (const f of h.warnings) console.warn(`[onlymapjs/cartograph] ${f}`);
+      return qt(h.blob, h.filenames[0] ?? `${l}.${o === "jpeg" ? "jpg" : "png"}`, { revokeAfterMs: 1e4 }), "export";
+    }
+    const u = await It(r, { dpi: a, format: o });
+    for (const m of u.warnings) console.warn(`[onlymapjs/cartograph] ${m}`);
+    return qt(u.blob, `${l}.${o === "jpeg" ? "jpg" : "png"}`, { revokeAfterMs: 1e4 }), "export";
+  }
+  return n.get("print") === "1" ? (await Wt(r, t.timeoutMs), typeof r.print == "function" ? await r.print({ dpi: Number(n.get("dpi")) || void 0 }) : typeof window < "u" && window.print(), "print") : i ? "cvd" : null;
+}
+function dr() {
+  if (typeof document > "u") return;
+  const r = () => {
+    for (const t of document.querySelectorAll("om-cartograph[allow-url-actions]"))
+      mr(t).catch((e) => console.warn(`[onlymapjs/cartograph] URL action failed: ${e.message}`));
+  };
+  document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", r, { once: !0 }) : r();
+}
+const xe = typeof window < "u" && typeof document < "u" && typeof customElements < "u", fr = xe ? HTMLElement : class {
+};
+function x(r, t) {
+  xe && (customElements.get(r) || customElements.define(r, t));
+}
+function pr(r) {
+  if (typeof DOMParser > "u")
+    throw new Error(
+      "[onlymapjs] Parsing a manifest string needs a DOM implementation (DOMParser). In node, run under a DOM test environment — e.g. vitest with `environment: 'happy-dom'` (or jsdom) — or pass an already-parsed Element instead of a string."
+    );
+  return new DOMParser().parseFromString(r, "text/html");
+}
+class R extends fr {
+  renderQueued = !1;
+  connectedCallback() {
+    this.scheduleRender();
+  }
+  attributeChangedCallback() {
+    this.isConnected && this.scheduleRender();
+  }
+  /** Ask for a re-render — used when something this element DEPENDS on changed. */
+  requestCartographRender() {
+    this.scheduleRender();
+  }
+  scheduleRender() {
+    this.renderQueued || (this.renderQueued = !0, queueMicrotask(() => {
+      this.renderQueued = !1, this.isConnected && this.renderNow();
+    }));
+  }
+  /** Write the placed-element inline styles from the mm placement attributes. */
+  applyPlacement() {
+    const t = (l) => {
+      const c = this.getAttribute(l);
+      if (c == null || c === "") return null;
+      const u = Number(c);
+      return Number.isFinite(u) ? u : null;
+    }, e = t("x"), n = t("y"), i = t("w"), s = t("h");
+    this.style.position = "absolute", e != null && (this.style.left = `${e}mm`), n != null && (this.style.top = `${n}mm`), i != null && (this.style.width = `${i}mm`), s != null && (this.style.height = `${s}mm`);
+    const o = t("rotation");
+    o != null && o !== 0 ? (this.style.transform = `rotate(${o}deg)`, this.style.transformOrigin = "center") : this.style.removeProperty("transform");
+    const a = t("z");
+    a != null && Number.isInteger(a) ? this.style.zIndex = String(a) : this.style.removeProperty("z-index");
+  }
+}
+const pt = "cartograph/2", qn = ["default", "dark", "sepia", "blueprint", "minimal"], Bt = ["A0", "A1", "A2", "A3", "A4", "A5", "Letter", "Legal"], gr = /* @__PURE__ */ new Map([
+  ["projection", "live frames render Web Mercator (EPSG:3857) only — Globe support is design-only; use a static frame for other projections"]
+]), j = ["id", "x", "y", "w", "h", "rotation", "z", "locked", "hidden"], P = {
+  "om-cartograph": ["cartograph-id", "format", "size", "width", "height", "orientation", "theme", "title", "attribution", "notes", "cvd", "bleed", "crop-marks", "safe-zone", "dpi", "flatten", "color-profile", "allow-url-actions"],
+  "om-frame": [...j, "src", "mode", "center", "zoom", "bearing", "pitch", "dpi", "crs", "corners", "crs-def", "overview-of", "overview-stroke", "atlas-fit", "atlas-margin", "frame-stroke", "frame-bg"],
+  "om-legend": [...j, "for", "title", "columns", "derived"],
+  "om-legend-row": ["layer", "match", "label", "hide", "order", "color", "shape"],
+  // NOTE: the discriminator on furniture is `kind`, never `style` — `style` is
+  // the global HTML attribute the runtime itself writes for mm placement, so
+  // `style="double"` would be erased on the first render. `kind` also matches
+  // om-text/om-shape, so the whole vocabulary has ONE discriminator word.
+  "om-scalebar": [...j, "for", "units", "segments", "segment-length", "kind"],
+  "om-north": [...j, "for", "kind"],
+  "om-graticule": [...j, "for", "crs", "crs-def", "interval", "interval-x", "interval-y", "kind", "labels", "format"],
+  "om-text": [...j, "kind", "font-size", "weight", "align", "font", "color", "bg"],
+  "om-shape": [...j, "kind", "fill", "fill-opacity", "stroke", "stroke-width", "radius"],
+  "om-image": [...j, "src", "fit"],
+  "om-atlas": ["id", "for", "layer", "filter", "sort", "filename", "page-name"]
+}, gt = Object.keys(P), br = ["metric", "imperial", "nautical"], yr = 0.3048, wr = 1609.344, Mr = 1852;
+function vr(r) {
+  return r != null && br.includes(r) ? r : null;
+}
+function $e(r) {
+  if (!isFinite(r) || r <= 0) return 0;
+  const t = Math.pow(10, Math.floor(Math.log10(r))), e = r / t;
+  return (e >= 5 ? 5 : e >= 2 ? 2 : 1) * t;
+}
+const Vt = {
+  // Finest first; the largest tier whose snapped length is ≥ 1 unit wins.
+  metric: [
+    { metersPerUnit: 1, label: "m" },
+    { metersPerUnit: 1e3, label: "km" }
+  ],
+  imperial: [
+    { metersPerUnit: yr, label: "ft" },
+    { metersPerUnit: wr, label: "mi" }
+  ],
+  nautical: [{ metersPerUnit: Mr, label: "nmi" }]
+};
+function ke({ groundMetersPerMm: r, maxWidthMm: t, segments: e = 4, units: n = "metric", segmentLengthMeters: i }) {
+  if (!Number.isFinite(r) || r <= 0 || !Number.isFinite(t) || t <= 0) return null;
+  const s = Number.isInteger(e) && e > 0 ? e : 4, o = Vt[n] ?? Vt.metric, a = t / s * r;
+  let l, c;
+  if (i != null && Number.isFinite(i) && i > 0)
+    l = i, c = Ht(o, l);
+  else {
+    c = Ht(o, a);
+    const f = $e(a / c.metersPerUnit);
+    if (f <= 0) return null;
+    l = f * c.metersPerUnit;
+  }
+  const u = l / r;
+  if (!Number.isFinite(u) || u <= 0) return null;
+  const m = l / c.metersPerUnit, d = m < 1 ? 2 : m < 10 && !Number.isInteger(m) ? 1 : 0, h = Array.from({ length: s + 1 }, (f, p) => (p * m).toFixed(d));
+  return {
+    segmentMeters: l,
+    segmentMm: u,
+    segments: s,
+    totalMm: u * s,
+    labels: h,
+    unitLabel: c.label,
+    // 1 mm on the page is groundMetersPerMm metres on the ground; the RF is
+    // that ratio in consistent units (mm : mm).
+    scaleDenominator: r * 1e3
+  };
+}
+function Ar(r, t, e) {
+  const n = Math.min(2.6, Math.max(1.6, e * 0.34)), i = 0.2, s = n * 1.25, o = Math.max(0.6, Math.min(2.2, e - s - 0.4)), a = 0, l = r.segmentMm, c = [], u = [];
+  if (t === "single" || t === "double") {
+    const g = t === "double" ? 2 : 1, b = o / g;
+    for (let w = 0; w < g; w++)
+      for (let y = 0; y < r.segments; y++)
+        c.push({
+          x: y * l,
+          y: a + w * b,
+          w: l,
+          h: b,
+          // "double" is a checkerboard: the second row's phase is inverted.
+          filled: (y + w) % 2 === 0
+        });
+  } else {
+    u.push({ x1: 0, y1: a + o, x2: r.totalMm, y2: a + o });
+    const g = t === "ticks" ? r.segments : 1;
+    for (let b = 0; b <= g; b++) {
+      const w = b / g * r.totalMm;
+      u.push({ x1: w, y1: a, x2: w, y2: a + o });
+    }
+  }
+  const m = r.labels.length - 1, d = r.labels.map((g, b) => ({
+    // The end label carries the unit so the bar reads "0 2 4 6 8 km".
+    text: b === m ? `${g} ${r.unitLabel}` : g,
+    // Keep the end label inside the drawn width rather than hanging off it.
+    x: b === m ? r.totalMm : b * l,
+    y: a + o + n,
+    anchor: b === 0 ? "start" : b === m ? "end" : "middle",
+    index: b
+  })), h = (g) => g.length * n * 0.62, f = [];
+  let p = -1 / 0;
+  for (const g of d) {
+    const b = h(g.text) / 2, w = g.anchor === "start" ? g.x : g.anchor === "end" ? g.x - b * 2 : g.x - b, y = w + h(g.text);
+    if (!(!(g.index === 0 || g.index === m) && w < p + n * 0.4)) {
+      if (g.index === m && w < p + n * 0.4)
+        for (; f.length > 1 && f[f.length - 1].x + h(f[f.length - 1].text) / 2 > w - n * 0.4; ) f.pop();
+      f.push({ text: g.text, x: g.x, y: g.y, anchor: g.anchor }), p = y;
+    }
+  }
+  return { bars: c, strokes: u, labels: f, fontMm: n, strokeMm: i, segmentMeters: r.segmentMeters, unitLabel: r.unitLabel, scaleDenominator: r.scaleDenominator };
+}
+function Ht(r, t) {
+  let e = r[0];
+  for (const n of r)
+    t / n.metersPerUnit >= 1 && (e = n);
+  return e;
+}
+const Sr = " ";
+function Cr(r) {
+  return !Number.isFinite(r) || r <= 0 ? "" : Math.round(r).toString().replace(/\B(?=(\d{3})+(?!\d))/g, Sr);
+}
+const Ee = /\{\{\s*([\w.]+)\s*\}\}/g;
+function xr(r, t) {
+  if (r.startsWith("atlas.")) return t.atlas?.[r.slice(6)];
+  if (r.startsWith("frame.")) {
+    const e = r.slice(6), n = e.lastIndexOf(".");
+    return n <= 0 ? void 0 : t.frames?.get(e.slice(0, n))?.[e.slice(n + 1)];
+  }
+  if ((r === "scale" || r === "crs") && t.soleFrameId) {
+    const n = t.frames?.get(t.soleFrameId)?.[r];
+    if (n !== void 0) return n;
+  }
+  return t.page[r];
+}
+function Ne(r, t) {
+  const e = [];
+  return { text: r.replace(Ee, (i, s) => {
+    const o = xr(s, t);
+    return o === void 0 ? (e.push(s), i) : o;
+  }), unresolved: e };
+}
+function $r(r) {
+  return [...r.matchAll(Ee)].map((t) => t[1]);
+}
+const Yt = /* @__PURE__ */ new WeakMap();
+function kr(r, t) {
+  const e = [], n = r.ownerDocument ?? (typeof document < "u" ? document : null);
+  if (!n) return e;
+  const i = n.createTreeWalker(
+    r,
+    4
+    /* NodeFilter.SHOW_TEXT */
+  ), s = [];
+  for (let o = i.nextNode(); o; o = i.nextNode()) s.push(o);
+  for (const o of s) {
+    let a = Yt.get(o);
+    if (a === void 0) {
+      if (a = o.data, !a.includes("{{")) continue;
+      Yt.set(o, a);
+    }
+    const l = Ne(a, t);
+    o.data !== l.text && (o.data = l.text), e.push(...l.unresolved);
+  }
+  return e;
+}
+function Er(r = /* @__PURE__ */ new Date()) {
+  return `${r.getFullYear()}-${String(r.getMonth() + 1).padStart(2, "0")}-${String(r.getDate()).padStart(2, "0")}`;
+}
+const Et = "data-om-carto-unlinked";
+function Pe(r) {
+  return r.closest("om-cartograph");
+}
+function Te(r, t) {
+  const e = Pe(r);
+  if (!e || !t) return null;
+  for (const n of e.querySelectorAll("om-frame"))
+    if (n.id === t) return n;
+  return null;
+}
+function Le(r) {
+  return [...r.querySelectorAll("om-frame")];
+}
+function Nr(r) {
+  const t = Pe(r);
+  if (!t) return null;
+  const e = Le(t);
+  return e.length === 1 ? e[0] : null;
+}
+function O(r) {
+  const t = r.getAttribute("for");
+  return t ? Te(r, t) : Nr(r);
+}
+function G(r, t) {
+  let e = r.querySelector(`:scope > [${Et}]`);
+  if (!e) {
+    for (const n of [...r.children])
+      n.tagName.toLowerCase() !== "om-legend-row" && n.remove();
+    e = r.ownerDocument.createElement("div"), e.setAttribute(Et, ""), e.style.cssText = "font:italic 2.6mm/1.3 system-ui,sans-serif;color:var(--om-carto-ink);opacity:.7;", r.appendChild(e);
+  }
+  e.textContent !== t && (e.textContent = t);
+}
+function Pr(r) {
+  r.querySelector(`:scope > [${Et}]`)?.remove();
+}
+const Kt = "data-om-carto-page", Xt = "data-om-carto-marks", bt = "data-om-carto-credit", yt = "Built with OnlyMap by NIKA · free for non-commercial use", et = 2, Zt = 1.2, wt = 2.4, Jt = 1.5, Mt = 1.2, Qt = 0.3, te = 0.8, vt = "http://www.w3.org/2000/svg", Tr = 6e4;
+class Fe extends R {
+  static observedAttributes = [...P["om-cartograph"]];
+  frameListenerBound = !1;
+  /** Fields of the atlas page currently displayed, for {{atlas.<field>}}. */
+  atlasFields;
+  creditObserver = null;
+  unsubscribeLicense = null;
+  /** The resolved page box, mm — furniture and export read this, never the attributes. */
+  get pageSize() {
+    return ct(this.getAttribute("size"), this.getAttribute("width"), this.getAttribute("height"), this.getAttribute("orientation"));
+  }
+  /** Bleed in mm (0 when unset) — extends the printed sheet past the trim. */
+  get bleedMm() {
+    const t = Number(this.getAttribute("bleed"));
+    return Number.isFinite(t) && t > 0 ? t : 0;
+  }
+  connectedCallback() {
+    super.connectedCallback(), this.frameListenerBound || (this.frameListenerBound = !0, this.addEventListener("om-frame-ready", () => {
+      this.atlas?.refresh(), this.refreshTokens(), this.refreshFurniture(), this.renderCredit();
+    })), !this.creditObserver && typeof MutationObserver < "u" && (this.creditObserver = new MutationObserver(() => {
+      this.querySelector(`:scope > [${bt}]`) || this.renderCredit();
+    }), this.creditObserver.observe(this, { childList: !0 }));
+  }
+  disconnectedCallback() {
+    this.creditObserver?.disconnect(), this.creditObserver = null, this.unsubscribeLicense?.(), this.unsubscribeLicense = null;
+  }
+  /**
+   * The free-tier credit (issue #41 §6, decided 2026-09-11): a cartograph is
+   * a print/export artifact, and `snapshot()` deliberately excludes the map
+   * badge — so without this line a free-plan sheet would ship credit-free.
+   * Suppressed when the author placed their OWN OnlyMap credit in any
+   * `om-text` (the licensing condition is the credit, not this element), or
+   * when a loaded core reports a paid plan (`hideBadge`). A static-only page
+   * never loads the core and keeps the credit — key verification is the map
+   * runtime's job (issue #41 §9: the om-map carries the key).
+   */
+  renderCredit() {
+    const t = H();
+    t && !this.unsubscribeLicense && typeof t.subscribeLicense == "function" && (this.unsubscribeLicense = t.subscribeLicense(() => this.renderCredit()));
+    const e = t ? t.getEntitlements().hideBadge : !1, n = [...this.querySelectorAll("om-text")].some((o) => /onlymap/i.test(o.textContent ?? "")), i = this.querySelector(`:scope > [${bt}]`);
+    if (e || n) {
+      i?.remove();
+      return;
+    }
+    if (i) {
+      this.armCreditPainter(i);
+      return;
+    }
+    const s = this.ownerDocument.createElement("div");
+    s.setAttribute(bt, ""), s.setAttribute("z", "2147483644"), s.textContent = yt, s.style.cssText = `position:absolute;left:${et}mm;bottom:${Zt}mm;z-index:2147483644;font:${wt}mm/${Jt} system-ui,sans-serif;color:#374151;background:rgba(255,255,255,.72);padding:${Qt}mm ${Mt}mm;border-radius:${te}mm;pointer-events:none;`, this.armCreditPainter(s), this.appendChild(s);
+  }
+  /** Give the runtime-owned DOM credit the same canvas paint contract as authored furniture. */
+  armCreditPainter(t) {
+    t.paintCartograph = (e, n) => {
+      const i = (c) => c * n.pxPerMm, o = wt * Jt + Qt * 2, a = this.pageSize.heightMm - Zt - o;
+      e.save(), e.font = `${i(wt)}px system-ui, sans-serif`;
+      const l = e.measureText(yt).width / n.pxPerMm + Mt * 2;
+      e.fillStyle = "rgba(255,255,255,.72)", e.beginPath(), typeof e.roundRect == "function" ? e.roundRect(i(et), i(a), i(l), i(o), i(te)) : e.rect(i(et), i(a), i(l), i(o)), e.fill(), e.fillStyle = "#374151", e.textAlign = "left", e.textBaseline = "middle", e.fillText(yt, i(et + Mt), i(a + o / 2)), e.restore();
+    };
+  }
+  /**
+   * Print this page at `dpi`.
+   *
+   * A live map is a WebGL canvas, and WebGL canvases print blank or at screen
+   * resolution — the drawing buffer is not preserved, and the print rasterizer
+   * never re-renders it. So every live frame is swapped for a print-resolution
+   * capture first, and restored on `afterprint`. This is also why an
+   * unassisted Ctrl+P cannot produce a high-DPI page: the print dialog opens
+   * synchronously and captures are asynchronous.
+   */
+  async print(t = {}) {
+    const e = t.dpi ?? (Number(this.getAttribute("dpi")) || 300), n = [...this.querySelectorAll("om-frame")];
+    let i = null;
+    if (this.hasAttribute("flatten") && (i = await this.buildFlattenedImage(e).catch(() => null), i && this.appendChild(i)), !i) for (const a of n) await a.enterPrintMode?.(e);
+    let s = !1;
+    const o = () => {
+      if (!s) {
+        s = !0, i && URL.revokeObjectURL(i.src), i?.remove(), i = null;
+        for (const a of n) a.exitPrintMode?.();
+        window.removeEventListener("afterprint", o);
+      }
+    };
+    window.addEventListener("afterprint", o);
+    try {
+      window.print();
+    } finally {
+      s || setTimeout(o, Tr);
+    }
+  }
+  /** Render the whole page to one image, for `flatten`. */
+  async buildFlattenedImage(t) {
+    const { renderCartograph: e } = await Promise.resolve().then(() => ur), { blob: n } = await e(this, { dpi: t }), i = this.ownerDocument.createElement("img");
+    i.src = URL.createObjectURL(n), i.setAttribute("data-om-carto-flattened", "");
+    const s = this.bleedMm;
+    return i.style.cssText = `position:absolute;left:${-s}mm;top:${-s}mm;width:calc(100% + ${s * 2}mm);height:calc(100% + ${s * 2}mm);z-index:2147483645;`, await i.decode().catch(() => {
+    }), i;
+  }
+  /** The page's atlas controller, if it has one. */
+  get atlas() {
+    return this.querySelector("om-atlas");
+  }
+  /** Called by the atlas when it seeks — the source for {{atlas.<field>}}. */
+  setAtlasFields(t) {
+    this.atlasFields = t, this.refreshTokens();
+  }
+  /** Re-render every furniture element — called when a frame's georeference appears. */
+  refreshFurniture() {
+    for (const t of this.querySelectorAll("om-scalebar, om-north, om-graticule, om-legend, om-frame[overview-of]"))
+      t.requestCartographRender?.();
+  }
+  /** Values every `{{token}}` on this page resolves against. */
+  tokenContext() {
+    const t = /* @__PURE__ */ new Map(), e = Le(this);
+    for (const s of e) {
+      const o = s.georef, a = o?.groundMetersPerMm() ?? 0;
+      t.set(s.id, {
+        scale: a > 0 ? Cr(a * 1e3) : void 0,
+        crs: o?.crs
+      });
+    }
+    const n = { page: {}, frames: t, soleFrameId: e.length === 1 ? e[0].id : null, atlas: this.atlasFields }, i = (s) => Ne(this.getAttribute(s) ?? "", n).text;
+    return {
+      page: {
+        title: i("title"),
+        attribution: i("attribution"),
+        date: Er(),
+        notes: i("notes")
+      },
+      frames: t,
+      // Bare {{scale}}/{{crs}} only bind when there is exactly one frame —
+      // with two, there is no honest answer (the validator says so).
+      soleFrameId: e.length === 1 ? e[0].id : null,
+      atlas: this.atlasFields
+    };
+  }
+  /** Re-resolve `{{tokens}}` in every text block on the page. */
+  refreshTokens() {
+    for (const t of this.querySelectorAll("om-text"))
+      t.resolveTokens?.();
+  }
+  renderNow() {
+    const { widthMm: t, heightMm: e } = this.pageSize, n = this.bleedMm;
+    this.style.display = "block", this.style.position = "relative", this.style.width = `${t}mm`, this.style.height = `${e}mm`, this.style.margin = n > 0 ? `${n}mm` : "", this.style.overflow = n > 0 ? "visible" : "hidden";
+    let i = this.querySelector(`style[${Kt}]`);
+    i || (i = document.createElement("style"), i.setAttribute(Kt, ""), this.prepend(i));
+    const s = t + n * 2, o = e + n * 2;
+    i.textContent = `@page { size: ${s}mm ${o}mm; margin: 0; }
+@media print { html, body { margin: 0; padding: 0; } om-cartograph { break-after: page; } }`, this.renderPrintMarks(t, e, n), this.applyCvd(), this.refreshTokens(), this.renderCredit();
+  }
+  /**
+   * Crop marks and the safe-zone guide.
+   *
+   * Crop marks tell a trimmer where the sheet is cut, so they live OUTSIDE the
+   * trim box, in the bleed. The safe zone is the opposite: an on-screen guide
+   * showing where content is at risk of being trimmed off, and it must never
+   * reach paper or an exported image — a guide printed on the deliverable is
+   * worse than no guide.
+   */
+  renderPrintMarks(t, e, n) {
+    const i = this.hasAttribute("crop-marks") && n > 0, s = Number(this.getAttribute("safe-zone")), o = Number.isFinite(s) && s > 0, a = this.querySelector(`:scope > [${Xt}]`);
+    if (!i && !o) {
+      a?.remove();
+      return;
+    }
+    const l = this.ownerDocument, c = a ?? l.createElementNS(vt, "svg");
+    if (c.setAttribute(Xt, ""), c.setAttribute("viewBox", `${-n} ${-n} ${t + n * 2} ${e + n * 2}`), c.setAttribute("width", `${t + n * 2}mm`), c.setAttribute("height", `${e + n * 2}mm`), c.style.cssText = `position:absolute;left:${-n}mm;top:${-n}mm;pointer-events:none;z-index:2147483646;`, c.replaceChildren(), i) {
+      const u = Math.min(n, 4), m = Math.min(n * 0.35, 1.5), d = [];
+      for (const h of [0, t])
+        for (const f of [0, e]) {
+          const p = h === 0 ? -1 : 1, g = f === 0 ? -1 : 1;
+          d.push([h + p * m, f, h + p * (m + u), f]), d.push([h, f + g * m, h, f + g * (m + u)]);
+        }
+      for (const [h, f, p, g] of d) {
+        const b = l.createElementNS(vt, "line");
+        b.setAttribute("x1", String(h)), b.setAttribute("y1", String(f)), b.setAttribute("x2", String(p)), b.setAttribute("y2", String(g)), b.setAttribute("stroke", "#000"), b.setAttribute("stroke-width", "0.15"), c.appendChild(b);
+      }
+    }
+    if (o) {
+      const u = l.createElementNS(vt, "rect");
+      u.setAttribute("x", String(s)), u.setAttribute("y", String(s)), u.setAttribute("width", String(Math.max(0, t - s * 2))), u.setAttribute("height", String(Math.max(0, e - s * 2))), u.setAttribute("fill", "none"), u.setAttribute("stroke", "#22aaff"), u.setAttribute("stroke-width", "0.2"), u.setAttribute("stroke-dasharray", "2 1.5"), u.setAttribute("data-om-carto-screen-only", ""), c.appendChild(u);
+    }
+    a || this.appendChild(c);
+  }
+  /**
+   * Colour-vision simulation over the whole page — a review aid, so an author
+   * can see what a red/green categorical scheme does to roughly 1 in 12 male
+   * readers BEFORE it is printed, when nothing can be toggled back.
+   *
+   * CSS cannot express a colour matrix, so the filters are real SVG elements,
+   * injected only when a page actually asks for one.
+   */
+  applyCvd() {
+    const t = Lt(this.getAttribute("cvd"));
+    if (!t) {
+      this.style.removeProperty("filter");
+      return;
+    }
+    ar(this.ownerDocument), this.style.filter = `url(#${ve(t)})`;
+  }
+}
+x("om-cartograph", Fe);
+function Lr({ text: r, maxWidth: t, fontSizePx: e, lineHeightPx: n, measure: i }) {
+  const s = n > 0 ? n : e * 1.2, o = [];
+  for (const c of r.split(/\r?\n/)) {
+    const u = c.split(/\s+/).filter((h) => h !== "");
+    if (u.length === 0) {
+      o.push({ text: "", baselineY: 0, width: 0 });
+      continue;
+    }
+    const m = (h) => {
+      let f = h;
+      for (; i(f) > t && f.length > 1; ) {
+        let p = f.length - 1;
+        for (; p > 1 && i(f.slice(0, p)) > t; ) p--;
+        o.push({ text: f.slice(0, p), baselineY: 0, width: i(f.slice(0, p)) }), f = f.slice(p);
+      }
+      return f;
+    };
+    let d = "";
+    for (const h of u) {
+      const f = d === "" ? h : `${d} ${h}`;
+      d === "" ? d = m(h) : i(f) > t ? (o.push({ text: d, baselineY: 0, width: i(d) }), d = m(h)) : d = f;
+    }
+    o.push({ text: d, baselineY: 0, width: i(d) });
+  }
+  const a = e * 0.8;
+  let l = 0;
+  return o.forEach((c, u) => {
+    c.baselineY = a + u * s, c.width > l && (l = c.width);
+  }), { lines: o, lineHeight: s, maxWidth: l };
+}
+function Wn(r) {
+  if (typeof document > "u") return null;
+  const e = document.createElement("canvas").getContext("2d");
+  return e ? (e.font = r, (n) => e.measureText(n).width) : null;
+}
+function Fr(r, t, e) {
+  return r === "center" ? (t - e) / 2 : r === "end" || r === "right" ? t - e : 0;
+}
+class Ie extends R {
+  static observedAttributes = [...P["om-text"]];
+  renderNow() {
+    this.applyPlacement(), this.style.display = "block", this.style.boxSizing = "border-box", this.style.overflow = "hidden";
+    const t = this.getAttribute("font-size");
+    t != null && Number.isFinite(Number(t)) && Number(t) > 0 ? this.style.fontSize = `${Number(t)}pt` : this.style.removeProperty("font-size");
+    const e = this.getAttribute("weight");
+    e ? this.style.fontWeight = e : this.style.removeProperty("font-weight");
+    const n = this.getAttribute("align");
+    n === "start" || n === "center" || n === "end" ? this.style.textAlign = n : this.style.removeProperty("text-align");
+    const i = this.getAttribute("font");
+    i ? this.style.fontFamily = i : this.style.removeProperty("font-family");
+    const s = this.getAttribute("color");
+    s ? this.style.color = s : this.style.removeProperty("color");
+    const o = this.getAttribute("bg");
+    o ? this.style.background = o : this.style.removeProperty("background"), this.resolveTokens();
+  }
+  /** Re-run token substitution from the authored templates. */
+  resolveTokens() {
+    const t = this.closest("om-cartograph");
+    t && typeof t.tokenContext == "function" && kr(this, t.tokenContext());
+  }
+  paintCartograph(t, e) {
+    const { w: n, h: i } = C(this), s = n * e.pxPerMm, o = i * e.pxPerMm;
+    if (s <= 0 || o <= 0) return;
+    const a = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, l = L(a?.backgroundColor);
+    l && (t.fillStyle = l, t.fillRect(0, 0, s, o));
+    const c = (this.textContent ?? "").trim();
+    if (c === "") return;
+    const u = kt(a?.fontSize, 12), m = a?.lineHeight === "normal" ? u * 1.4 : kt(a?.lineHeight, u * 1.4), d = a?.fontFamily || "system-ui, sans-serif", h = a?.fontWeight || "400", f = u * e.scale, p = m * e.scale, g = `${h} ${f}px ${d}`;
+    t.save(), t.font = g, t.fillStyle = L(a?.color) ?? "#000", t.textBaseline = "alphabetic", t.textAlign = "left";
+    const b = Lr({
+      text: c,
+      maxWidth: s,
+      fontSizePx: f,
+      lineHeightPx: p,
+      measure: (y) => t.measureText(y).width
+    }), w = a?.textAlign || "start";
+    for (const y of b.lines) {
+      if (y.baselineY > o + p) break;
+      t.fillText(y.text, Fr(w, s, y.width), y.baselineY);
+    }
+    t.restore();
+  }
+}
+x("om-text", Ie);
+const Ir = 63710087714e-4;
+let Rr = Ir;
+const rt = Math.PI / 180;
+function Re(r, t, e = Rr) {
+  const n = (t[1] - r[1]) * rt, i = (t[0] - r[0]) * rt, s = r[1] * rt, o = t[1] * rt, a = Math.sin(n / 2) ** 2 + Math.cos(s) * Math.cos(o) * Math.sin(i / 2) ** 2;
+  return 2 * e * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+const ut = 6378137, ee = Math.PI / 180, Nt = 180 / Math.PI, re = 85.0511287798066;
+function _r([r, t]) {
+  const e = Math.max(-re, Math.min(re, t));
+  return [ut * r * ee, ut * Math.log(Math.tan(Math.PI / 4 + e * ee / 2))];
+}
+function Or([r, t]) {
+  return [r / ut * Nt, (2 * Math.atan(Math.exp(t / ut)) - Math.PI / 2) * Nt];
+}
+const _e = { code: "EPSG:3857", forward: _r, inverse: Or }, Ur = { code: "EPSG:4326", forward: ([r, t]) => [r, t], inverse: ([r, t]) => [r, t] };
+function Y(r) {
+  if (r == null) return null;
+  const t = r.trim();
+  if (t === "") return null;
+  const e = /^(?:epsg:{1,2})?(\d{4,6})$/i.exec(t);
+  return e ? `EPSG:${e[1]}` : t.toUpperCase();
+}
+function K(r) {
+  const t = Y(r) ?? "EPSG:3857";
+  return t === "EPSG:3857" || t === "EPSG:900913" ? _e : t === "EPSG:4326" || t === "CRS:84" || t === "OGC:CRS84" ? Ur : null;
+}
+async function Oe(r, t) {
+  const e = K(r);
+  if (e && !t) return e;
+  const n = Y(r) ?? "EPSG:3857", i = t?.trim() || await jr(n);
+  if (!i) return null;
+  const s = (await import("./index-CcLC9jE5.js")).default, a = s(i, "+proj=longlat +datum=WGS84 +no_defs");
+  return {
+    code: n,
+    forward: (l) => a.inverse(l),
+    inverse: (l) => a.forward(l)
+  };
+}
+function ne(r, t) {
+  return !Number.isInteger(r) || r < 1 || r > 60 ? null : `+proj=utm +zone=${r}${t === "S" ? " +south" : ""} +datum=WGS84 +units=m +no_defs`;
+}
+async function jr(r) {
+  const t = Number(/^EPSG:(\d+)$/.exec(r)?.[1]);
+  if (!Number.isFinite(t)) return null;
+  if (t >= 32601 && t <= 32660) return ne(t - 32600, "N");
+  if (t >= 32701 && t <= 32760) return ne(t - 32700, "S");
+  const { CRS_DEFS: e } = await import("./crs-DsDQ4Q4i.js");
+  return e[t]?.def ?? null;
+}
+function zr(r, t) {
+  const e = t.length, n = r.map((i, s) => [...i, t[s]]);
+  for (let i = 0; i < e; i++) {
+    let s = i;
+    for (let o = i + 1; o < e; o++) Math.abs(n[o][i]) > Math.abs(n[s][i]) && (s = o);
+    if (Math.abs(n[s][i]) < 1e-12) return null;
+    [n[i], n[s]] = [n[s], n[i]];
+    for (let o = 0; o < e; o++) {
+      if (o === i) continue;
+      const a = n[o][i] / n[i][i];
+      if (a !== 0)
+        for (let l = i; l <= e; l++) n[o][l] -= a * n[i][l];
+    }
+  }
+  return n.map((i, s) => i[e] / i[s]);
+}
+function Dr(r, t) {
+  if (r.length !== 4 || t.length !== 4) return null;
+  const e = r.reduce((m, d) => m + d[0], 0) / 4, n = r.reduce((m, d) => m + d[1], 0) / 4, i = r.reduce((m, d) => m + Math.hypot(d[0] - e, d[1] - n), 0) / 4, s = i > 1e-12 ? Math.SQRT2 / i : 1, o = (m) => [(m[0] - e) * s, (m[1] - n) * s], a = [], l = [];
+  for (let m = 0; m < 4; m++) {
+    const [d, h] = o(r[m]), [f, p] = t[m];
+    a.push([d, h, 1, 0, 0, 0, -d * f, -h * f]), l.push(f), a.push([0, 0, 0, d, h, 1, -d * p, -h * p]), l.push(p);
+  }
+  const c = zr(a, l);
+  if (!c || c.some((m) => !Number.isFinite(m))) return null;
+  const u = (m) => [m[0] / s + e, m[1] / s + n];
+  return { matrix: [c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], 1], normalize: o, denormalize: u };
+}
+function ie(r, [t, e]) {
+  const n = r[6] * t + r[7] * e + r[8];
+  return Math.abs(n) < 1e-12 ? null : [(r[0] * t + r[1] * e + r[2]) / n, (r[3] * t + r[4] * e + r[5]) / n];
+}
+function Gr(r) {
+  const [t, e, n, i, s, o, a, l, c] = r, u = t * (s * c - o * l) - e * (i * c - o * a) + n * (i * l - s * a);
+  return !Number.isFinite(u) || Math.abs(u) < 1e-15 ? null : [
+    (s * c - o * l) / u,
+    (n * l - e * c) / u,
+    (e * o - n * s) / u,
+    (o * a - i * c) / u,
+    (t * c - n * a) / u,
+    (n * i - t * o) / u,
+    (i * l - s * a) / u,
+    (e * a - t * l) / u,
+    (t * s - e * i) / u
+  ];
+}
+function oe(r, t) {
+  let e = r;
+  for (; e - t > 180; ) e -= 360;
+  for (; t - e > 180; ) e += 360;
+  return e;
+}
+const qr = (r) => {
+  let t = ((r + 180) % 360 + 360) % 360 - 180;
+  return t === -180 && (t = 180), t;
+};
+function ht({ corners: r, widthMm: t, heightMm: e, crsForward: n }) {
+  const i = n ?? _e, s = r[0][0], o = r.map(([h, f]) => [oe(h, s), f]), a = o.map((h) => i.forward(h)), l = [
+    [0, 0],
+    [t, 0],
+    [t, e],
+    [0, e]
+  ], c = t > 0 && e > 0 ? Dr(a, l) : null, u = c ? Gr(c.matrix) : null, m = !c || !u, d = {
+    crs: i.code,
+    corners: o,
+    widthMm: t,
+    heightMm: e,
+    degenerate: m,
+    project(h) {
+      if (!c) return null;
+      const f = i.forward([oe(h[0], s), h[1]]), p = ie(c.matrix, c.normalize(f));
+      return p && Number.isFinite(p[0]) && Number.isFinite(p[1]) ? { xMm: p[0], yMm: p[1] } : null;
+    },
+    unproject(h, f) {
+      if (!c || !u) return null;
+      const p = ie(u, [h, f]);
+      if (!p) return null;
+      const g = i.inverse(c.denormalize(p));
+      return Number.isFinite(g[0]) && Number.isFinite(g[1]) ? [qr(g[0]), g[1]] : null;
+    },
+    groundMetersPerMm() {
+      if (m || t <= 0) return 0;
+      const h = d.unproject(0, e / 2), f = d.unproject(t, e / 2);
+      return !h || !f ? 0 : Re(h, f) / t;
+    }
+  };
+  return d;
+}
+function mt(r) {
+  if (r == null || r.trim() === "") return null;
+  let t;
+  try {
+    t = JSON.parse(r);
+  } catch {
+    const n = r.trim().split(/[\s,]+/).map(Number);
+    if (n.length !== 8 || n.some((i) => !Number.isFinite(i))) return null;
+    t = [
+      [n[0], n[1]],
+      [n[2], n[3]],
+      [n[4], n[5]],
+      [n[6], n[7]]
+    ];
+  }
+  if (!Array.isArray(t)) return null;
+  if (t.length === 8 && t.every((n) => typeof n == "number" && Number.isFinite(n))) {
+    const n = t;
+    return [n[1], n[3], n[5], n[7]].some((i) => i < -90 || i > 90) ? null : [
+      [n[0], n[1]],
+      [n[2], n[3]],
+      [n[4], n[5]],
+      [n[6], n[7]]
+    ];
+  }
+  if (t.length !== 4) return null;
+  const e = [];
+  for (const n of t) {
+    if (!Array.isArray(n) || n.length < 2) return null;
+    const [i, s] = n;
+    if (typeof i != "number" || typeof s != "number" || !Number.isFinite(i) || !Number.isFinite(s) || s < -90 || s > 90) return null;
+    e.push([i, s]);
+  }
+  return e;
+}
+function Wr(r) {
+  if (r.degenerate) return null;
+  const t = r.unproject(r.widthMm / 2, r.heightMm / 2);
+  if (!t) return null;
+  const n = [t[0], Math.min(89.9, Math.max(-89.9, t[1] + 0.01))], i = r.project(t), s = r.project(n);
+  if (!i || !s) return null;
+  const o = s.xMm - i.xMm, a = s.yMm - i.yMm;
+  return Math.abs(o) < 1e-12 && Math.abs(a) < 1e-12 ? null : (Math.atan2(o, -a) * Nt % 360 + 360) % 360;
+}
+function Br(r) {
+  if (r.degenerate) return null;
+  const { widthMm: t, heightMm: e } = r, n = [];
+  for (const o of [0.02, 0.5, 0.98]) {
+    const a = r.unproject(0, e * o), l = r.unproject(t, e * o);
+    if (!a || !l) return null;
+    n.push(Re(a, l) / t);
+  }
+  const i = Math.min(...n), s = Math.max(...n);
+  return i > 0 ? (s - i) / i : null;
+}
+function Bn(r, t, e, n) {
+  return [
+    [r, n],
+    [e, n],
+    [e, t],
+    [r, t]
+  ];
+}
+const Vr = (r) => r.toLowerCase().startsWith("on");
+function Hr(r, t) {
+  const e = (n) => {
+    const i = n.tagName.toLowerCase();
+    if (i === "script") {
+      if ((n.getAttribute("type") ?? "").toLowerCase() !== "application/json") return null;
+      const a = t.createElement("script");
+      return a.setAttribute("type", "application/json"), a.textContent = n.textContent, a;
+    }
+    if (i === "style" || i === "link" || i === "iframe" || i === "object" || i === "embed") return null;
+    const s = t.createElement(i);
+    for (const o of n.attributes)
+      Vr(o.name) || /^\s*javascript:/i.test(o.value) || s.setAttribute(o.name, o.value);
+    for (const o of n.childNodes)
+      if (o.nodeType === 3) s.appendChild(t.createTextNode(o.textContent ?? ""));
+      else if (o.nodeType === 1) {
+        const a = e(o);
+        a && s.appendChild(a);
+      }
+    return s;
+  };
+  return e(r);
+}
+async function Yr(r, t = document) {
+  const e = await fetch(r, { credentials: "same-origin" });
+  if (!e.ok) throw new Error(`fetching ${r} failed with HTTP ${e.status}`);
+  const n = await e.text(), s = new DOMParser().parseFromString(n, "text/html").querySelector("om-map");
+  if (!s) throw new Error(`${r} contains no <om-map>`);
+  const o = Hr(s, t);
+  if (!o) throw new Error(`${r} could not be adopted`);
+  return o;
+}
+function lt(r) {
+  const t = r.getAttribute("center"), e = r.getAttribute("zoom");
+  if (!t || e == null || e.trim() === "") return null;
+  const n = Number(e);
+  if (!Number.isFinite(n)) return null;
+  let i;
+  try {
+    i = JSON.parse(t);
+  } catch {
+    const a = t.split(/[\s,]+/).map(Number);
+    i = a.length === 2 ? a : null;
+  }
+  if (!Array.isArray(i) || i.length < 2) return null;
+  const [s, o] = i;
+  return !Number.isFinite(s) || !Number.isFinite(o) ? null : {
+    center: [s, o],
+    zoom: n,
+    bearing: Number(r.getAttribute("bearing")) || 0,
+    pitch: Number(r.getAttribute("pitch")) || 0
+  };
+}
+function se(r, t, e, n) {
+  if (!(e > 0) || !(n > 0)) return null;
+  const i = new r.WebMercatorViewport({
+    width: e,
+    height: n,
+    longitude: t.center[0],
+    latitude: t.center[1],
+    zoom: t.zoom,
+    bearing: t.bearing,
+    pitch: t.pitch
+  }), s = [
+    [0, 0],
+    [e, 0],
+    [e, n],
+    [0, n]
+  ], o = [];
+  for (const a of s) {
+    const l = i.unproject(a);
+    if (!l || !Number.isFinite(l[0]) || !Number.isFinite(l[1]) || Math.abs(l[1]) > 85.06) return null;
+    o.push([l[0], l[1]]);
+  }
+  return o;
+}
+async function Kr(r) {
+  const t = await we(), e = r.querySelector(":scope > om-map");
+  if (e) return { core: t, map: e };
+  const n = r.getAttribute("src");
+  if (!n) throw new Error("a live frame needs src= or an inline <om-map> child");
+  const i = await Yr(n, r.ownerDocument);
+  return { core: t, map: i };
+}
+function At(r, t) {
+  r.setAttribute("center", JSON.stringify(t.center)), r.setAttribute("zoom", String(t.zoom)), r.setAttribute("bearing", String(t.bearing)), r.setAttribute("pitch", String(t.pitch)), Xr(r, t);
+}
+function Xr(r, t) {
+  const e = r;
+  typeof e.setViewInternal == "function" ? e.setViewInternal({ longitude: t.center[0], latitude: t.center[1], zoom: t.zoom, pitch: t.pitch, bearing: t.bearing }) : typeof e.flyTo == "function" && e.flyTo(t.center, t.zoom, { duration: 0 });
+}
+const St = "data-om-carto-placeholder", Ct = "data-om-carto-overview", ae = "http://www.w3.org/2000/svg", le = 24, ce = 0.25;
+class Ue extends R {
+  static observedAttributes = [...P["om-frame"]];
+  /** Resolved non-builtin CRS planes, so a re-render does not re-await proj4. */
+  resolvedForward = null;
+  resolvedForwardKey = null;
+  resolveToken = 0;
+  lastError = null;
+  readyFired = !1;
+  readySettled = !1;
+  readyPromise = null;
+  readyResolve = null;
+  /**
+   * Settles when the frame has either rendered its map or given up on it —
+   * mirroring `<om-map>`'s own `ready`. It RESOLVES on error rather than
+   * rejecting, because every caller (export, print, the URL triggers) wants
+   * "stop waiting", and a frame that failed still shows a visible placeholder
+   * that belongs on the page.
+   */
+  get ready() {
+    return this.readyPromise || (this.readyPromise = new Promise((t) => {
+      this.readyResolve = t;
+    }), this.readySettled && this.settleReady()), this.readyPromise;
+  }
+  settleReady() {
+    this.readySettled = !0, this.readyResolve?.(), this.readyResolve = null;
+  }
+  /** Live-mode state. */
+  liveMap = null;
+  liveCorners = null;
+  mountToken = 0;
+  mounting = !1;
+  mountingSource = null;
+  mountedSource = null;
+  liveMapOwned = !1;
+  /** A capture standing in for the live map during export/print. */
+  captureImage = null;
+  printing = !1;
+  get mode() {
+    return this.getAttribute("mode") === "static" ? "static" : "live";
+  }
+  /** The mounted `<om-map>`, once a live frame has one. */
+  get mapElement() {
+    return this.liveMap;
+  }
+  /**
+   * The frame's georeference, or null when it has none yet (malformed corners,
+   * a CRS still resolving, a live map not yet mounted, a view too pitched to
+   * georeference). Recomputed on demand — the fit is an 8×8 solve, far cheaper
+   * than caching it correctly.
+   */
+  get georef() {
+    const { w: t, h: e } = C(this);
+    if (t <= 0 || e <= 0) return null;
+    if (this.mode === "live")
+      return this.liveCorners ? ht({ corners: this.liveCorners, widthMm: t, heightMm: e }) : null;
+    const n = mt(this.getAttribute("corners"));
+    if (!n) return null;
+    const i = Y(this.getAttribute("crs")) ?? "EPSG:3857", s = this.getAttribute("crs-def");
+    let o = s ? null : K(i);
+    return !o && this.resolvedForwardKey === `${i}|${s ?? ""}` && (o = this.resolvedForward), o ? ht({ corners: n, widthMm: t, heightMm: e, crsForward: o }) : null;
+  }
+  /** The raster a static frame draws — its first <img> child, if any. */
+  get raster() {
+    return this.querySelector(":scope > img");
+  }
+  disconnectedCallback() {
+    this.abandonMount();
+  }
+  /**
+   * Bump the generation token so a mount already in flight cannot adopt its
+   * map into this frame when it lands. The token is the whole cancellation
+   * protocol, so it lives in one place — three copies of it is three chances
+   * for a stale map to arrive after a src= change.
+   */
+  abandonMount() {
+    this.mountToken++, this.mounting = !1, this.mountingSource = null;
+  }
+  renderNow() {
+    this.applyPlacement(), this.style.display = "block", this.style.overflow = "hidden", this.style.boxSizing = "border-box";
+    const t = this.getAttribute("frame-stroke");
+    this.style.border = "0", this.style.boxShadow = `inset 0 0 0 ${ce}mm ${t || "var(--om-carto-frame-stroke)"}`;
+    const e = this.getAttribute("frame-bg");
+    this.style.background = e || "var(--om-carto-frame-bg)", this.mode === "static" ? (this.suspendLiveMode(), this.renderStatic()) : this.renderLive(), this.renderOverview();
+  }
+  // -------------------------------------------------------------------------
+  // Static
+  // -------------------------------------------------------------------------
+  renderStatic() {
+    const t = this.raster;
+    if (!t) {
+      this.showPlaceholder("no-raster", "Static frame has no <img> child to place.");
+      return;
+    }
+    t.style.position = "absolute", t.style.inset = "0", t.style.width = "100%", t.style.height = "100%", t.style.objectFit = "fill", t.style.display = "block";
+    const e = Y(this.getAttribute("crs")) ?? "EPSG:3857", n = this.getAttribute("crs-def"), i = `${e}|${n ?? ""}`;
+    if ((n != null || K(e) == null) && this.resolvedForwardKey !== i) {
+      const o = ++this.resolveToken;
+      this.resolvedForward = null, this.resolvedForwardKey = null, Oe(e, n).then((a) => {
+        if (o === this.resolveToken) {
+          if (!a) {
+            this.showPlaceholder("unknown-crs", `Unknown CRS "${e}" — supply crs-def="+proj=…".`);
+            return;
+          }
+          this.resolvedForward = a, this.resolvedForwardKey = i, this.scheduleRender();
+        }
+      }).catch(() => {
+        o === this.resolveToken && this.showPlaceholder("unknown-crs", `Could not resolve CRS "${e}".`);
+      });
+      return;
+    }
+    if (!mt(this.getAttribute("corners"))) {
+      this.showPlaceholder("bad-corners", 'Static frame needs corners="[[lng,lat] × 4]" (tl, tr, br, bl).');
+      return;
+    }
+    this.clearPlaceholder(), this.signalStaticReady(t);
+  }
+  // -------------------------------------------------------------------------
+  // Live
+  // -------------------------------------------------------------------------
+  renderLive() {
+    const t = lt(this);
+    if (!t) {
+      this.showPlaceholder("no-camera", 'Live frame needs its own camera — center="[lng, lat]" and zoom=.');
+      return;
+    }
+    this.updateLiveCorners(t);
+    const e = this.liveSource();
+    if (this.liveMap)
+      if (this.mountedSource !== e)
+        this.releaseLiveMap();
+      else {
+        At(this.liveMap, t), this.sizeLiveMap();
+        return;
+      }
+    if (this.mounting) {
+      if (this.mountingSource === e) return;
+      this.abandonMount();
+    }
+    this.mountLive(e);
+  }
+  /** Inline maps are identified by node identity; fetched maps by their src=. */
+  liveSource() {
+    return [...this.children].find(
+      (e) => e.tagName.toLowerCase() === "om-map" && (!this.liveMapOwned || e !== this.liveMap)
+    ) ?? `src:${this.getAttribute("src") ?? ""}`;
+  }
+  /** Leave live mode without deleting an authored inline map. */
+  suspendLiveMode() {
+    this.mounting && this.abandonMount(), this.captureImage = null, this.liveMap && (this.liveMapOwned ? this.releaseLiveMap() : this.liveMap.hidden = !0);
+  }
+  releaseLiveMap() {
+    this.liveMapOwned ? this.liveMap?.remove() : this.liveMap && (this.liveMap.hidden = !0), this.liveMap = null, this.liveMapOwned = !1, this.mountedSource = null, this.liveCorners = null, this.captureImage = null;
+  }
+  updateLiveCorners(t = lt(this)) {
+    if (!t) return;
+    const e = H();
+    if (!e) return;
+    const { w: n, h: i } = C(this), s = se(e, t, n * W, i * W);
+    this.liveCorners = s, s ? this.lastError === "degenerate-view" && this.clearPlaceholder() : this.showPlaceholder(
+      "degenerate-view",
+      "This camera cannot be georeferenced — the frame's top edge reaches the horizon. Reduce pitch below ~60°."
+    );
+  }
+  async mountLive(t) {
+    const e = ++this.mountToken;
+    this.mounting = !0, this.mountingSource = t;
+    try {
+      const { core: n, map: i } = await Kr(this);
+      if (e !== this.mountToken || !this.isConnected || this.mode !== "live" || this.liveSource() !== t) return;
+      const s = lt(this);
+      if (!s) return;
+      At(i, s);
+      const o = i;
+      o.style.position = "absolute", o.style.inset = "0", o.style.display = "block", this.liveMapOwned = i.parentElement !== this, this.liveMapOwned && this.appendChild(i), i.setAttribute("data-om-carto-frame", ""), this.liveMap = o, this.mountedSource = t, this.sizeLiveMap(), this.clearPlaceholder();
+      const { w: a, h: l } = C(this);
+      if (this.liveCorners = se(n, s, a * W, l * W), await o.ready, e !== this.mountToken || (At(i, s), await o.whenSettled?.({ timeout: 2e4 }), e !== this.mountToken)) return;
+      this.signalReady();
+    } catch (n) {
+      if (e !== this.mountToken) return;
+      const i = n.message ?? String(n);
+      this.showPlaceholder(i.includes("src=") || i.includes("no <om-map>") ? "no-source" : "load-failed", `Live frame could not load: ${i}`);
+    } finally {
+      e === this.mountToken && (this.mounting = !1, this.mountingSource = null);
+    }
+  }
+  sizeLiveMap() {
+    this.liveMap && (this.liveMap.style.width = "100%", this.liveMap.style.height = "100%", this.liveMap.hidden = this.printing);
+  }
+  // -------------------------------------------------------------------------
+  // Locator inset (overview-of)
+  // -------------------------------------------------------------------------
+  /**
+   * Draw another frame's footprint on this one. The outline is DENSIFIED —
+   * sampled along each edge and projected point by point — because a
+   * rectangle in one projection is a curve in another, and four straight
+   * segments would visibly cut the corners on a wide-extent inset.
+   */
+  renderOverview() {
+    const t = this.getAttribute("overview-of"), e = this.querySelector(`:scope > [${Ct}]`);
+    if (!t) {
+      e?.remove();
+      return;
+    }
+    const n = Te(this, t), i = this.georef, s = n?.georef;
+    if (!n || !i || !s) {
+      e?.remove();
+      return;
+    }
+    const { w: o, h: a } = C(this), l = [], [c, u, m, d] = s.corners, h = [
+      [c, u],
+      [u, m],
+      [m, d],
+      [d, c]
+    ];
+    for (const [b, w] of h)
+      for (let y = 0; y < le; y++) {
+        const S = y / le, M = [b[0] + (w[0] - b[0]) * S, b[1] + (w[1] - b[1]) * S], F = i.project(M);
+        F && l.push(`${F.xMm.toFixed(3)},${F.yMm.toFixed(3)}`);
+      }
+    if (l.length < 3) {
+      e?.remove();
+      return;
+    }
+    const f = this.ownerDocument, p = e ?? f.createElementNS(ae, "svg");
+    p.setAttribute(Ct, ""), p.setAttribute("width", `${o}mm`), p.setAttribute("height", `${a}mm`), p.setAttribute("viewBox", `0 0 ${o} ${a}`), p.style.cssText = "position:absolute;inset:0;pointer-events:none;", p.replaceChildren();
+    const g = f.createElementNS(ae, "polygon");
+    g.setAttribute("points", l.join(" ")), g.setAttribute("fill", "none"), g.setAttribute("stroke", this.getAttribute("overview-stroke") || "#e63946"), g.setAttribute("stroke-width", "0.4"), p.appendChild(g), e || this.appendChild(p);
+  }
+  // -------------------------------------------------------------------------
+  // Readiness and errors
+  // -------------------------------------------------------------------------
+  signalStaticReady(t) {
+    this.readyFired || (t.complete && t.naturalWidth > 0 ? this.signalReady() : (t.addEventListener("load", () => this.signalReady(), { once: !0 }), t.addEventListener(
+      "error",
+      () => this.showPlaceholder("raster-decode", `Could not load the frame's raster (${t.getAttribute("src") ?? "no src"}).`),
+      { once: !0 }
+    )));
+  }
+  signalReady() {
+    this.readyFired || (this.readyFired = !0, this.settleReady(), this.dispatchEvent(new CustomEvent("om-frame-ready", { bubbles: !0, detail: { id: this.id, mode: this.mode } })));
+  }
+  /**
+   * Frames fail loudly and visibly. A silent empty box on a printed page is
+   * the worst outcome — it looks like a design choice.
+   */
+  showPlaceholder(t, e) {
+    let n = this.querySelector(`:scope > [${St}]`);
+    n || (n = document.createElement("div"), n.setAttribute(St, ""), n.style.cssText = "position:absolute;inset:0;display:grid;place-content:center;padding:4mm;text-align:center;font:italic 3mm/1.4 system-ui,sans-serif;color:var(--om-carto-ink);opacity:.75;", this.appendChild(n)), n.textContent !== e && (n.textContent = e), this.lastError !== t && (this.lastError = t, this.settleReady(), this.dispatchEvent(new CustomEvent("om-frame-error", { bubbles: !0, detail: { id: this.id, reason: t, message: e } })));
+  }
+  clearPlaceholder() {
+    this.querySelector(`:scope > [${St}]`)?.remove(), this.lastError = null;
+  }
+  // -------------------------------------------------------------------------
+  // Capture, export and print
+  // -------------------------------------------------------------------------
+  /**
+   * Capture this frame's map at `scale` captured pixels per CSS pixel.
+   * Static frames need no capture (their raster IS the picture); a live frame
+   * re-renders at the requested resolution through the core.
+   */
+  async captureAt(t) {
+    if (this.mode !== "live" || !this.liveMap) return null;
+    const e = await this.liveMap.snapshot({ scale: t }), n = new Image();
+    return n.decoding = "sync", n.src = e, await n.decode().catch(() => {
+    }), n;
+  }
+  /**
+   * Point this frame's camera at a lon/lat box — the atlas's per-page refit.
+   * Solves for the zoom that fits the box in the frame's own pixel size, in
+   * the Mercator plane (where the projection is linear), then writes the
+   * camera attributes so everything downstream — corners, scale bar, tokens —
+   * follows from the same source as any authored camera.
+   */
+  fitBounds(t) {
+    const [e, n, i, s] = t, { w: o, h: a } = C(this);
+    if (o <= 0 || a <= 0) return;
+    const l = H();
+    if (!l) return;
+    const c = new l.WebMercatorViewport({ width: o * W, height: a * W, longitude: 0, latitude: 0, zoom: 0 }).fitBounds([
+      [e, n],
+      [i, s]
+    ]);
+    [c.longitude, c.latitude, c.zoom].every(Number.isFinite) && (this.setAttribute("center", JSON.stringify([Number(c.longitude.toFixed(8)), Number(c.latitude.toFixed(8))])), this.setAttribute("zoom", String(Number(c.zoom.toFixed(4)))), this.updateLiveCorners());
+  }
+  /** Export hook: capture before the page paints (see render.ts). */
+  async prepareCartograph(t) {
+    this.mode === "live" && (this.captureImage = await this.captureAt(t.scale));
+  }
+  /** Export hook: forget the capture, so a failed pre-pass never reuses it. */
+  discardCartograph() {
+    this.captureImage = null;
+  }
+  /**
+   * Swap the live canvas for a print-resolution bitmap. A WebGL canvas prints
+   * blank or at screen resolution — the drawing buffer is not preserved and
+   * the print rasterizer does not re-render it — so the printed page shows a
+   * captured `<img>` instead, restored afterwards.
+   */
+  async enterPrintMode(t) {
+    if (this.mode !== "live" || !this.liveMap) return;
+    const e = await this.captureAt(t / 96);
+    e && (this.printing = !0, e.setAttribute("data-om-carto-print", ""), e.style.cssText = "position:absolute;inset:0;width:100%;height:100%;object-fit:fill;display:block;", this.appendChild(e), this.liveMap.hidden = !0);
+  }
+  exitPrintMode() {
+    this.printing = !1, this.querySelector(":scope > img[data-om-carto-print]")?.remove(), this.liveMap && (this.liveMap.hidden = !1);
+  }
+  paintCartograph(t, e) {
+    const { w: n, h: i } = C(this), s = n * e.pxPerMm, o = i * e.pxPerMm;
+    if (s <= 0 || o <= 0) return;
+    const a = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, l = L(a?.backgroundColor);
+    l && (t.fillStyle = l, t.fillRect(0, 0, s, o));
+    const c = this.mode === "static" ? this.raster : this.captureImage;
+    c && c.complete && c.naturalWidth > 0 && t.drawImage(c, 0, 0, s, o), this.paintOverview(t, e);
+    const u = this.getAttribute("frame-stroke") || L(a?.getPropertyValue("--om-carto-frame-stroke")?.trim()) || "#333333", m = ce * e.pxPerMm;
+    m > 0 && (t.strokeStyle = u, t.lineWidth = m, t.strokeRect(m / 2, m / 2, s - m, o - m));
+  }
+  paintOverview(t, e) {
+    const n = this.querySelector(`:scope > [${Ct}] polygon`), i = n?.getAttribute("points");
+    i && (t.save(), t.strokeStyle = n.getAttribute("stroke") || "#e63946", t.lineWidth = Number(n.getAttribute("stroke-width") || 0.4) * e.pxPerMm, t.beginPath(), i.split(/\s+/).forEach((s, o) => {
+      const [a, l] = s.split(",").map(Number);
+      !Number.isFinite(a) || !Number.isFinite(l) || (o === 0 ? t.moveTo(a * e.pxPerMm, l * e.pxPerMm) : t.lineTo(a * e.pxPerMm, l * e.pxPerMm));
+    }), t.closePath(), t.stroke(), t.restore());
+  }
+}
+x("om-frame", Ue);
+const nt = "http://www.w3.org/2000/svg", Zr = ["single", "double", "line", "ticks"];
+class je extends R {
+  static observedAttributes = [...P["om-scalebar"]];
+  /** The geometry currently drawn — reused by the canvas exporter. */
+  get drawing() {
+    const e = O(this)?.georef;
+    if (!e) return null;
+    const { w: n, h: i } = C(this), s = ke({
+      groundMetersPerMm: e.groundMetersPerMm(),
+      maxWidthMm: n,
+      segments: Number(this.getAttribute("segments")) || void 0,
+      units: this.unitSystem,
+      segmentLengthMeters: this.getAttribute("segment-length") ? Number(this.getAttribute("segment-length")) : null
+    });
+    return s ? Ar(s, this.barStyle, i) : null;
+  }
+  get barStyle() {
+    const t = this.getAttribute("kind");
+    return Zr.includes(t) ? t : "single";
+  }
+  get unitSystem() {
+    return vr(this.getAttribute("units")) ?? "metric";
+  }
+  renderNow() {
+    if (this.applyPlacement(), this.style.display = "block", !O(this)) {
+      const n = this.getAttribute("for");
+      G(this, n ? `Scale bar references no frame with id "${n}".` : "Scale bar has no frame to measure (set for=).");
+      return;
+    }
+    const e = this.drawing;
+    if (!e) {
+      G(this, "Scale bar cannot derive a scale from this frame yet.");
+      return;
+    }
+    this.renderSvg(e);
+  }
+  renderSvg(t) {
+    const { w: e, h: n } = C(this), i = this.ownerDocument, s = i.createElementNS(nt, "svg");
+    s.setAttribute("width", `${e}mm`), s.setAttribute("height", `${n}mm`), s.setAttribute("viewBox", `0 0 ${e} ${n}`), s.setAttribute("part", "scalebar"), s.style.display = "block", s.style.overflow = "visible";
+    const o = "var(--om-carto-scalebar-ink)";
+    for (const a of t.bars) {
+      const l = i.createElementNS(nt, "rect");
+      l.setAttribute("x", String(a.x)), l.setAttribute("y", String(a.y)), l.setAttribute("width", String(a.w)), l.setAttribute("height", String(a.h)), l.setAttribute("fill", a.filled ? o : "none"), l.setAttribute("stroke", o), l.setAttribute("stroke-width", String(t.strokeMm)), s.appendChild(l);
+    }
+    for (const a of t.strokes) {
+      const l = i.createElementNS(nt, "line");
+      l.setAttribute("x1", String(a.x1)), l.setAttribute("y1", String(a.y1)), l.setAttribute("x2", String(a.x2)), l.setAttribute("y2", String(a.y2)), l.setAttribute("stroke", o), l.setAttribute("stroke-width", String(t.strokeMm)), s.appendChild(l);
+    }
+    for (const a of t.labels) {
+      const l = i.createElementNS(nt, "text");
+      l.setAttribute("x", String(a.x)), l.setAttribute("y", String(a.y)), l.setAttribute("font-size", String(t.fontMm)), l.setAttribute("fill", o), l.setAttribute("text-anchor", a.anchor), l.setAttribute("font-family", "var(--om-carto-font)"), l.textContent = a.text, s.appendChild(l);
+    }
+    this.replaceChildren(s);
+  }
+  paintCartograph(t, e) {
+    const n = this.drawing;
+    if (!n) return;
+    const i = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, s = L(i?.color) ?? "#000", o = (l) => l * e.pxPerMm;
+    t.strokeStyle = s, t.fillStyle = s, t.lineWidth = o(n.strokeMm);
+    for (const l of n.bars)
+      l.filled && t.fillRect(o(l.x), o(l.y), o(l.w), o(l.h)), t.strokeRect(o(l.x), o(l.y), o(l.w), o(l.h));
+    t.beginPath();
+    for (const l of n.strokes)
+      t.moveTo(o(l.x1), o(l.y1)), t.lineTo(o(l.x2), o(l.y2));
+    t.stroke();
+    const a = i?.fontFamily || "system-ui, sans-serif";
+    t.font = `${o(n.fontMm)}px ${a}`, t.textBaseline = "alphabetic";
+    for (const l of n.labels)
+      t.textAlign = l.anchor === "middle" ? "center" : l.anchor === "end" ? "right" : "left", t.fillText(l.text, o(l.x), o(l.y));
+  }
+}
+x("om-scalebar", je);
+const J = "http://www.w3.org/2000/svg";
+class ze extends R {
+  static observedAttributes = [...P["om-north"]];
+  /** Degrees clockwise from the page's "up", or null when unknowable. */
+  get bearing() {
+    const t = O(this)?.georef;
+    return t ? Wr(t) : null;
+  }
+  get indicatorKind() {
+    return this.getAttribute("kind") === "rose" ? "rose" : "arrow";
+  }
+  renderNow() {
+    if (this.applyPlacement(), this.style.display = "block", !O(this)) {
+      const l = this.getAttribute("for");
+      G(this, l ? `North indicator references no frame with id "${l}".` : "North indicator has no frame (set for=).");
+      return;
+    }
+    const e = this.bearing;
+    if (e == null) {
+      G(this, "North indicator cannot derive a direction from this frame yet.");
+      return;
+    }
+    const { w: n, h: i } = C(this), s = this.ownerDocument, o = s.createElementNS(J, "svg");
+    o.setAttribute("width", `${n}mm`), o.setAttribute("height", `${i}mm`), o.setAttribute("viewBox", `0 0 ${n} ${i}`), o.style.display = "block";
+    const a = s.createElementNS(J, "g");
+    a.setAttribute("transform", `rotate(${e.toFixed(3)} ${n / 2} ${i / 2})`);
+    for (const l of this.buildGeometry(s, n, i)) a.appendChild(l);
+    o.appendChild(a), this.replaceChildren(o);
+  }
+  buildGeometry(t, e, n) {
+    const i = "var(--om-carto-compass-ink)", s = [], o = e / 2, a = Math.min(3, n * 0.24), l = n - a * 1.2;
+    if (this.indicatorKind === "rose") {
+      const f = Math.min(e, l) / 2, p = t.createElementNS(J, "circle");
+      p.setAttribute("cx", String(o)), p.setAttribute("cy", String(l / 2)), p.setAttribute("r", String(f)), p.setAttribute("fill", "none"), p.setAttribute("stroke", i), p.setAttribute("stroke-width", "0.2"), s.push(p);
+    }
+    const c = 0, u = l, m = Math.min(e * 0.3, 4), d = t.createElementNS(J, "path");
+    d.setAttribute("d", `M ${o} ${c} L ${o + m} ${u} L ${o} ${u - m * 0.55} L ${o - m} ${u} Z`), d.setAttribute("fill", i), s.push(d);
+    const h = t.createElementNS(J, "text");
+    return h.setAttribute("x", String(o)), h.setAttribute("y", String(n)), h.setAttribute("font-size", String(a)), h.setAttribute("text-anchor", "middle"), h.setAttribute("fill", i), h.setAttribute("font-family", "var(--om-carto-font)"), h.textContent = "N", s.push(h), s;
+  }
+  paintCartograph(t, e) {
+    const n = this.bearing;
+    if (n == null) return;
+    const { w: i, h: s } = C(this), o = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, a = L(o?.color) ?? "#000", l = (h) => h * e.pxPerMm, c = Math.min(3, s * 0.24), u = s - c * 1.2, m = i / 2, d = Math.min(i * 0.3, 4);
+    t.save(), t.translate(l(m), l(s / 2)), t.rotate(n * Math.PI / 180), t.translate(-l(m), -l(s / 2)), t.fillStyle = a, t.strokeStyle = a, this.indicatorKind === "rose" && (t.lineWidth = l(0.2), t.beginPath(), t.arc(l(m), l(u / 2), l(Math.min(i, u) / 2), 0, Math.PI * 2), t.stroke()), t.beginPath(), t.moveTo(l(m), 0), t.lineTo(l(m + d), l(u)), t.lineTo(l(m), l(u - d * 0.55)), t.lineTo(l(m - d), l(u)), t.closePath(), t.fill(), t.font = `${l(c)}px ${o?.fontFamily || "system-ui, sans-serif"}`, t.textAlign = "center", t.textBaseline = "alphabetic", t.fillText("N", l(m), l(s)), t.restore();
+  }
+}
+x("om-north", ze);
+const it = "http://www.w3.org/2000/svg", Jr = ["rect", "ellipse", "line", "arrow"];
+class De extends R {
+  static observedAttributes = [...P["om-shape"]];
+  get kind() {
+    const t = this.getAttribute("kind");
+    return Jr.includes(t) ? t : "rect";
+  }
+  get fill() {
+    return this.getAttribute("fill") || "var(--om-carto-shape-fill)";
+  }
+  get stroke() {
+    return this.getAttribute("stroke") || "var(--om-carto-shape-stroke)";
+  }
+  get strokeWidthMm() {
+    const t = this.getAttribute("stroke-width");
+    if (t == null || t.trim() === "") return 0.3;
+    const e = Number(t);
+    return Number.isFinite(e) && e >= 0 ? e : 0.3;
+  }
+  get fillOpacity() {
+    const t = this.getAttribute("fill-opacity");
+    if (t == null || t.trim() === "") return 1;
+    const e = Number(t);
+    return Number.isFinite(e) && e >= 0 && e <= 1 ? e : 1;
+  }
+  get radiusMm() {
+    const t = Number(this.getAttribute("radius"));
+    return Number.isFinite(t) && t > 0 ? t : 0;
+  }
+  renderNow() {
+    this.applyPlacement(), this.style.display = "block";
+    const { w: t, h: e } = C(this), n = this.ownerDocument, i = n.createElementNS(it, "svg");
+    i.setAttribute("width", `${t}mm`), i.setAttribute("height", `${e}mm`), i.setAttribute("viewBox", `0 0 ${t} ${e}`), i.style.display = "block", i.style.overflow = "visible";
+    const s = this.strokeWidthMm / 2, o = this.kind;
+    let a;
+    o === "ellipse" ? (a = n.createElementNS(it, "ellipse"), a.setAttribute("cx", String(t / 2)), a.setAttribute("cy", String(e / 2)), a.setAttribute("rx", String(Math.max(0, t / 2 - s))), a.setAttribute("ry", String(Math.max(0, e / 2 - s)))) : o === "line" || o === "arrow" ? (a = n.createElementNS(it, "path"), a.setAttribute("d", o === "arrow" ? this.arrowPath(t, e) : `M 0 0 L ${t} ${e}`)) : (a = n.createElementNS(it, "rect"), a.setAttribute("x", String(s)), a.setAttribute("y", String(s)), a.setAttribute("width", String(Math.max(0, t - this.strokeWidthMm))), a.setAttribute("height", String(Math.max(0, e - this.strokeWidthMm))), this.radiusMm > 0 && a.setAttribute("rx", String(this.radiusMm)));
+    const l = o === "rect" || o === "ellipse" || o === "arrow";
+    a.setAttribute("fill", l ? this.fill : "none"), l && a.setAttribute("fill-opacity", String(this.fillOpacity)), a.setAttribute("stroke", this.stroke), a.setAttribute("stroke-width", String(this.strokeWidthMm)), i.appendChild(a), this.replaceChildren(i);
+  }
+  /** A line from the box's top-left to its bottom-right, with a solid head. */
+  arrowPath(t, e) {
+    const n = Math.min(t, e) * 0.28, i = Math.atan2(e, t), s = t, o = e, a = { x: s - n * Math.cos(i - 0.4), y: o - n * Math.sin(i - 0.4) }, l = { x: s - n * Math.cos(i + 0.4), y: o - n * Math.sin(i + 0.4) };
+    return `M 0 0 L ${s} ${o} M ${s} ${o} L ${a.x} ${a.y} L ${l.x} ${l.y} Z`;
+  }
+  paintCartograph(t, e) {
+    const { w: n, h: i } = C(this);
+    if (n <= 0 || i <= 0) return;
+    const s = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, o = (d) => d * e.pxPerMm, a = this.getAttribute("fill") || s?.getPropertyValue("--om-carto-shape-fill")?.trim() || "#cccccc", l = this.getAttribute("stroke") || s?.getPropertyValue("--om-carto-shape-stroke")?.trim() || "#333333", c = o(this.strokeWidthMm), u = c / 2, m = this.kind;
+    if (t.save(), t.globalAlpha = this.fillOpacity, t.fillStyle = a, t.strokeStyle = l, t.lineWidth = c, m === "ellipse")
+      t.beginPath(), t.ellipse(o(n / 2), o(i / 2), Math.max(0, o(n / 2) - u), Math.max(0, o(i / 2) - u), 0, 0, Math.PI * 2), t.fill(), t.globalAlpha = 1, c > 0 && t.stroke();
+    else if (m === "line" || m === "arrow") {
+      if (t.globalAlpha = 1, t.beginPath(), t.moveTo(0, 0), t.lineTo(o(n), o(i)), c > 0 && t.stroke(), m === "arrow") {
+        const d = Math.min(o(n), o(i)) * 0.28, h = Math.atan2(o(i), o(n));
+        t.beginPath(), t.moveTo(o(n), o(i)), t.lineTo(o(n) - d * Math.cos(h - 0.4), o(i) - d * Math.sin(h - 0.4)), t.lineTo(o(n) - d * Math.cos(h + 0.4), o(i) - d * Math.sin(h + 0.4)), t.closePath(), t.fillStyle = l, t.fill();
+      }
+    } else {
+      const d = o(this.radiusMm);
+      t.beginPath(), d > 0 && typeof t.roundRect == "function" ? t.roundRect(u, u, o(n) - c, o(i) - c, d) : t.rect(u, u, o(n) - c, o(i) - c), t.fill(), t.globalAlpha = 1, c > 0 && t.stroke();
+    }
+    t.restore();
+  }
+}
+x("om-shape", De);
+const ue = "data-om-carto-owned", Qr = ["contain", "cover", "fill"];
+class Ge extends R {
+  static observedAttributes = [...P["om-image"]];
+  get fit() {
+    const t = this.getAttribute("fit");
+    return Qr.includes(t ?? "") ? t : "contain";
+  }
+  get image() {
+    return this.querySelector(":scope > img");
+  }
+  renderNow() {
+    this.applyPlacement(), this.style.display = "block", this.style.overflow = "hidden";
+    const t = this.getAttribute("src");
+    let e = this.image;
+    !e && t && (e = this.ownerDocument.createElement("img"), e.setAttribute(ue, ""), e.alt = "", e.crossOrigin = "anonymous", this.appendChild(e)), e && (t && e.hasAttribute(ue) && e.getAttribute("src") !== t && e.setAttribute("src", t), e.style.width = "100%", e.style.height = "100%", e.style.objectFit = this.fit, e.style.display = "block");
+  }
+  paintCartograph(t, e) {
+    const n = this.image;
+    if (!n || !n.complete || n.naturalWidth === 0) return;
+    const { w: i, h: s } = C(this), o = i * e.pxPerMm, a = s * e.pxPerMm;
+    if (o <= 0 || a <= 0) return;
+    const l = this.fit;
+    if (l === "fill") {
+      t.drawImage(n, 0, 0, o, a);
+      return;
+    }
+    const c = n.naturalWidth / n.naturalHeight, u = o / a, m = l === "contain" ? c > u : c < u, d = m ? o : a * c, h = m ? o / c : a;
+    l === "cover" && (t.save(), t.beginPath(), t.rect(0, 0, o, a), t.clip()), t.drawImage(n, (o - d) / 2, (a - h) / 2, d, h), l === "cover" && t.restore();
+  }
+}
+x("om-image", Ge);
+const tn = /* @__PURE__ */ new Set(["PathLayer", "LineLayer", "ArcLayer", "TripsLayer", "GreatCircleLayer", "PathStyleLayer"]), en = /* @__PURE__ */ new Set(["ScatterplotLayer", "IconLayer", "TextLayer", "PointCloudLayer", "HeatmapLayer", "ScreenGridLayer"]), rn = /* @__PURE__ */ new Set(["COGLayer", "ZarrLayer", "BitmapLayer", "TerrainLayer", "ImageOverlay"]);
+function nn(r) {
+  const t = r.type ?? "";
+  if (rn.has(t)) return "ramp";
+  if (tn.has(t)) return "line";
+  if (en.has(t)) return "point";
+  if (t === "GeoJsonLayer") {
+    const e = r.props ?? {}, n = e.getFillColor !== void 0, i = e.getLineColor !== void 0;
+    if (n && !i) return "polygon";
+    if (i && !n || e.filled === !1 && e.stroked !== !1) return "line";
+  }
+  return "polygon";
+}
+function on(r) {
+  const t = r.meta?.legend;
+  return r.meta?.color ?? (t?.kind === "ramp" ? t.colors[0] : t?.entries[0]?.color) ?? "#999";
+}
+const xt = 12;
+function sn(r, t = []) {
+  const e = [];
+  for (const n of r) {
+    if (n.props?.visible === !1) continue;
+    const i = t.filter((a) => a.layer === n.id), s = i.find((a) => a.match == null);
+    if (s?.hide) continue;
+    const o = an(n.meta?.legend);
+    e.push({
+      layerId: n.id,
+      label: s?.label ?? n.meta?.label ?? n.id,
+      color: s?.color ?? on(n),
+      shape: s?.shape ?? nn(n),
+      legend: ln(o, i),
+      order: s?.order
+    });
+  }
+  return e.map((n, i) => ({ row: n, index: i })).sort((n, i) => {
+    const s = n.row.order ?? Number.POSITIVE_INFINITY, o = i.row.order ?? Number.POSITIVE_INFINITY;
+    return s - o || n.index - i.index;
+  }).map((n) => n.row);
+}
+function an(r) {
+  if (!r || r.kind !== "categories" || r.entries.length <= xt) return r;
+  const t = r.entries.slice(0, xt), e = r.entries.length - xt;
+  return {
+    ...r,
+    entries: [...t, { color: r.defaultColor ?? "#999", label: `+${e} more` }]
+  };
+}
+function ln(r, t) {
+  const e = t.filter((i) => i.match != null);
+  if (!r || r.kind === "ramp" || e.length === 0) return r;
+  const n = [];
+  for (const i of r.entries) {
+    const s = e.find((o) => o.match === i.label);
+    s?.hide || n.push({ color: s?.color ?? i.color, label: s?.label ?? i.label });
+  }
+  return { ...r, entries: n };
+}
+function cn(r) {
+  const t = [];
+  for (const e of r.querySelectorAll(":scope > om-legend-row")) {
+    const n = e.getAttribute("layer");
+    if (!n) continue;
+    const i = e.getAttribute("order"), s = i == null || i.trim() === "" ? void 0 : Number(i);
+    t.push({
+      layer: n,
+      match: e.getAttribute("match") ?? void 0,
+      label: e.getAttribute("label") ?? void 0,
+      hide: e.hasAttribute("hide"),
+      order: s != null && Number.isFinite(s) ? s : void 0,
+      color: e.getAttribute("color") ?? void 0,
+      shape: e.getAttribute("shape") ?? void 0
+    });
+  }
+  return t;
+}
+function qe(r) {
+  const t = [];
+  for (const e of r.querySelectorAll(":scope > om-legend-row")) {
+    if (e.hasAttribute("hide")) continue;
+    const n = e.getAttribute("order"), i = n == null || n.trim() === "" ? void 0 : Number(n);
+    t.push({
+      layerId: e.getAttribute("layer") ?? "",
+      label: e.getAttribute("label") ?? e.getAttribute("layer") ?? "",
+      color: e.getAttribute("color") ?? "#999",
+      shape: e.getAttribute("shape") ?? "polygon",
+      order: i != null && Number.isFinite(i) ? i : void 0
+    });
+  }
+  return t.sort((e, n) => (e.order ?? Number.POSITIVE_INFINITY) - (n.order ?? Number.POSITIVE_INFINITY));
+}
+const he = "data-om-carto-legend-rows";
+class We extends R {
+  static observedAttributes = [...P["om-legend"]];
+  get derived() {
+    return this.getAttribute("derived") !== "false";
+  }
+  /** The rows this legend currently shows — recomputed on demand, never stored. */
+  get rows() {
+    if (!this.derived) return qe(this);
+    const n = O(this)?.mapElement?.getLayers?.();
+    return n ? sn(n, cn(this)) : [];
+  }
+  renderNow() {
+    if (this.applyPlacement(), this.style.display = "block", this.style.boxSizing = "border-box", this.style.overflow = "hidden", this.derived && !O(this)) {
+      const e = this.getAttribute("for");
+      G(this, e ? `Legend references no frame with id "${e}".` : "Legend has no frame to derive from (set for=).");
+      return;
+    }
+    const t = this.rows;
+    if (t.length === 0 && this.derived) {
+      G(this, "Legend is waiting for its frame's layers.");
+      return;
+    }
+    this.renderRows(t);
+  }
+  renderRows(t) {
+    const e = this.ownerDocument;
+    this.querySelector(`:scope > [${he}]`)?.remove(), Pr(this);
+    const n = e.createElement("div");
+    n.setAttribute(he, ""), n.style.cssText = "padding:2mm;font-size:2.6mm;line-height:1.35;";
+    const i = this.getAttribute("title");
+    if (i) {
+      const o = e.createElement("div");
+      o.textContent = i, o.style.cssText = "font-weight:600;margin-bottom:1.2mm;color:var(--om-carto-legend-title-ink);", n.appendChild(o);
+    }
+    const s = Number(this.getAttribute("columns"));
+    Number.isFinite(s) && s > 1 && (n.style.columnCount = String(Math.floor(s)), n.style.columnGap = "3mm");
+    for (const o of t)
+      n.appendChild(this.buildRow(e, o)), o.legend && n.appendChild(this.buildSymbology(e, o));
+    this.appendChild(n);
+  }
+  buildRow(t, e) {
+    const n = t.createElement("div");
+    n.style.cssText = "display:flex;align-items:center;gap:1.5mm;margin:0.6mm 0;break-inside:avoid;", n.appendChild(this.buildSwatch(t, e.color, e.shape));
+    const i = t.createElement("span");
+    return i.textContent = e.label, n.appendChild(i), n;
+  }
+  /** The swatch geometry carries meaning: an area, a line and a point read differently. */
+  buildSwatch(t, e, n) {
+    const i = t.createElement("span"), s = "display:inline-block;flex:none;width:3.2mm;height:3.2mm;";
+    return n === "line" ? i.style.cssText = `${s}height:0.9mm;background:${e};` : n === "point" ? i.style.cssText = `${s}border-radius:50%;background:${e};` : n === "ramp" ? i.style.cssText = `${s}width:6mm;background:linear-gradient(to right, ${e}, transparent);` : i.style.cssText = `${s}background:${e};border:0.15mm solid rgba(0,0,0,.35);`, i;
+  }
+  buildSymbology(t, e) {
+    const n = t.createElement("div");
+    n.style.cssText = "margin:0.4mm 0 1.6mm 4.7mm;break-inside:avoid;";
+    const i = e.legend, s = t.createElement("div");
+    if (s.textContent = i.field, s.style.cssText = "font-size:2.1mm;opacity:.7;margin-bottom:0.5mm;", n.appendChild(s), i.kind === "ramp") {
+      const o = t.createElement("div");
+      o.style.cssText = `height:2.4mm;background:linear-gradient(to right, ${i.colors.join(", ")});border:0.15mm solid rgba(0,0,0,.25);`, n.appendChild(o);
+      const a = t.createElement("div");
+      return a.style.cssText = "display:flex;justify-content:space-between;font-size:2.1mm;opacity:.75;", a.append(ot(t, i.domain[0].toLocaleString("en-US")), ot(t, i.domain[1].toLocaleString("en-US"))), n.appendChild(a), n;
+    }
+    for (const o of i.entries) {
+      const a = t.createElement("div");
+      a.style.cssText = "display:flex;align-items:center;gap:1.2mm;margin:0.3mm 0;font-size:2.3mm;", a.appendChild(this.buildSwatch(t, o.color, "polygon")), a.appendChild(ot(t, o.label)), n.appendChild(a);
+    }
+    if (i.kind === "categories" && i.defaultColor) {
+      const o = t.createElement("div");
+      o.style.cssText = "display:flex;align-items:center;gap:1.2mm;margin:0.3mm 0;font-size:2.3mm;", o.appendChild(this.buildSwatch(t, i.defaultColor, "polygon")), o.appendChild(ot(t, "other")), n.appendChild(o);
+    }
+    return n;
+  }
+  paintCartograph(t, e) {
+    const { w: n, h: i } = C(this), s = n * e.pxPerMm, o = i * e.pxPerMm;
+    if (s <= 0 || o <= 0) return;
+    const a = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, l = L(a?.backgroundColor);
+    l && (t.fillStyle = l, t.fillRect(0, 0, s, o));
+    const c = L(a?.borderTopColor), u = kt(a?.borderTopWidth) * e.scale;
+    c && u > 0 && (t.strokeStyle = c, t.lineWidth = u, t.strokeRect(u / 2, u / 2, s - u, o - u));
+    const m = L(a?.color) ?? "#111", d = a?.fontFamily || "system-ui, sans-serif", h = (N) => N * e.pxPerMm;
+    let f = h(2);
+    const p = this.getAttribute("title");
+    p && (t.fillStyle = m, t.font = `600 ${h(2.6)}px ${d}`, t.textBaseline = "top", t.fillText(p, h(2), f), f += h(4));
+    const g = this.rows, b = Number(this.getAttribute("columns")), w = Math.min(g.length || 1, Number.isFinite(b) && b > 1 ? Math.floor(b) : 1), y = Math.max(1, Math.ceil(g.length / w)), S = 3, M = Math.max(1, (n - 4 - S * (w - 1)) / w), F = f;
+    let _ = -1, $ = 2;
+    t.font = `${h(2.6)}px ${d}`;
+    for (const [N, T] of g.entries()) {
+      const v = Math.min(w - 1, Math.floor(N / y));
+      if (v !== _ && (_ = v, $ = 2 + _ * (M + S), f = _ === 0 ? F : h(2)), f > o || (t.fillStyle = T.color, T.shape === "line" ? t.fillRect(h($), f + h(1.2), h(3.2), h(0.9)) : T.shape === "point" ? (t.beginPath(), t.arc(h($ + 1.6), f + h(1.6), h(1.6), 0, Math.PI * 2), t.fill()) : t.fillRect(h($), f, h(3.2), h(3.2)), t.fillStyle = m, t.textBaseline = "top", t.fillText(T.label, h($ + 4.7), f + h(0.3)), f += h(4.2), !T.legend)) continue;
+      const A = T.legend;
+      if (t.save(), t.font = `${h(2.1)}px ${d}`, t.globalAlpha = 0.7, t.fillText(A.field, h($ + 2.7), f), t.globalAlpha = 1, f += h(2.8), A.kind === "ramp") {
+        const k = Math.min(24, Math.max(1, M - 2.7)), E = $ + 2.7, U = t.createLinearGradient(h(E), 0, h(E + k), 0);
+        A.colors.forEach((X, Xe) => U.addColorStop(A.colors.length === 1 ? 0 : Xe / (A.colors.length - 1), X)), t.fillStyle = U, t.fillRect(h(E), f, h(k), h(2.4)), f += h(3.4), t.fillStyle = m, t.font = `${h(2.1)}px ${d}`, t.fillText(A.domain[0].toLocaleString("en-US"), h(E), f);
+        const Q = A.domain[1].toLocaleString("en-US");
+        t.textAlign = "right", t.fillText(Q, h(E + k), f), t.textAlign = "left", f += h(3.2);
+      } else {
+        const k = [...A.entries];
+        A.kind === "categories" && A.defaultColor && k.push({ color: A.defaultColor, label: "other" }), t.font = `${h(2.3)}px ${d}`;
+        for (const E of k) {
+          if (f > o) break;
+          t.fillStyle = E.color, t.fillRect(h($ + 2.7), f, h(2.6), h(2.6)), t.fillStyle = m, t.fillText(E.label, h($ + 6.3), f + h(0.2)), f += h(3.2);
+        }
+        f += h(1);
+      }
+      t.restore(), t.font = `${h(2.6)}px ${d}`;
+    }
+  }
+}
+const ot = (r, t) => {
+  const e = r.createElement("span");
+  return e.textContent = t, e;
+};
+x("om-legend", We);
+const me = 48, Be = {
+  toLngLat: (r, t) => [r, t],
+  fromLngLat: (r) => [r[0], r[1]]
+};
+function de(r, t = 5) {
+  return !Number.isFinite(r) || r <= 0 ? 0 : $e(r / Math.max(1, t));
+}
+function un({ georef: r, plane: t = Be, interval: e, intervalX: n, intervalY: i, labels: s = "outside", format: o }) {
+  if (r.degenerate) return null;
+  const a = r.corners.map((y) => t.fromLngLat(y)), l = a.map((y) => y[0]), c = a.map((y) => y[1]);
+  if (l.some((y) => !Number.isFinite(y)) || c.some((y) => !Number.isFinite(y))) return null;
+  const u = Math.min(...l), m = Math.max(...l), d = Math.min(...c), h = Math.max(...c), f = fe(n ?? e, de(m - u)), p = fe(i ?? e, de(h - d));
+  if (f <= 0 || p <= 0 || (m - u) / f > 500 || (h - d) / p > 500) return null;
+  const g = [], b = [], w = o ?? mn;
+  for (let y = Math.ceil(u / f) * f; y <= m + 1e-9; y += f) {
+    const S = pe(r, t, y, d, h, "x");
+    S && (g.push(S), s !== "none" && be(b, S, r, w(y, "x"), "x", s));
+  }
+  for (let y = Math.ceil(d / p) * p; y <= h + 1e-9; y += p) {
+    const S = pe(r, t, y, u, m, "y");
+    S && (g.push(S), s !== "none" && be(b, S, r, w(y, "y"), "y", s));
+  }
+  return { lines: g, labels: b, intervalX: f, intervalY: p };
+}
+const fe = (r, t) => r != null && Number.isFinite(r) && r > 0 ? r : t;
+function pe(r, t, e, n, i, s) {
+  const o = [];
+  for (let l = 0; l <= me; l++) {
+    const c = n + (i - n) * l / me, u = s === "x" ? t.toLngLat(e, c) : t.toLngLat(c, e);
+    if (!Number.isFinite(u[0]) || !Number.isFinite(u[1])) continue;
+    const m = r.project(u);
+    m && o.push(m);
+  }
+  const a = hn(o, r.widthMm, r.heightMm);
+  return a.length >= 2 ? { points: a, value: e, axis: s } : null;
+}
+function hn(r, t, e) {
+  const n = (a) => a.xMm >= -0.01 && a.xMm <= t + 0.01 && a.yMm >= -0.01 && a.yMm <= e + 0.01, i = r.findIndex(n);
+  if (i === -1) return [];
+  let s = r.length - 1;
+  for (; s > i && !n(r[s]); ) s--;
+  return r.slice(Math.max(0, i - 1), Math.min(r.length, s + 2)).map((a) => ({ xMm: ge(a.xMm, 0, t), yMm: ge(a.yMm, 0, e) }));
+}
+const ge = (r, t, e) => Math.min(e, Math.max(t, r));
+function be(r, t, e, n, i, s) {
+  if (i === "x") {
+    const o = t.points.reduce((a, l) => l.yMm > a.yMm ? l : a);
+    if (Math.abs(o.yMm - e.heightMm) > 0.5) return;
+    r.push({ text: n, xMm: o.xMm, yMm: e.heightMm + (s === "outside" ? 3 : -1), edge: "bottom", axis: i });
+  } else {
+    const o = t.points.reduce((a, l) => l.xMm < a.xMm ? l : a);
+    if (Math.abs(o.xMm) > 0.5) return;
+    r.push({ text: n, xMm: s === "outside" ? -1.2 : 1.2, yMm: o.yMm, edge: "left", axis: i });
+  }
+}
+function mn(r, t) {
+  if (Math.abs(r) >= 1e3) return Math.round(r).toLocaleString("en-US");
+  const e = Math.abs(r) < 1 ? 3 : Math.abs(r) < 10 ? 2 : 1;
+  return `${Number(r.toFixed(e))}°`;
+}
+function dn(r, t) {
+  const e = t === "x" ? r < 0 ? "W" : "E" : r < 0 ? "S" : "N", n = Math.abs(r), i = Math.floor(n), s = (n - i) * 60, o = Math.floor(s), a = Math.round((s - o) * 60), l = a === 60 ? o + 1 : o, c = l === 60 ? i + 1 : i, u = l === 60 ? 0 : l, m = a === 60 ? 0 : a;
+  return `${c}°${String(u).padStart(2, "0")}′${String(m).padStart(2, "0")}″${e}`;
+}
+const st = "http://www.w3.org/2000/svg", fn = ["solid", "cross", "markers"], z = 1.4;
+class Ve extends R {
+  static observedAttributes = [...P["om-graticule"]];
+  resolvedPlane = null;
+  resolvedPlaneKey = null;
+  resolveToken = 0;
+  get kind() {
+    const t = this.getAttribute("kind");
+    return fn.includes(t) ? t : "solid";
+  }
+  get labelPlacement() {
+    const t = this.getAttribute("labels");
+    return t === "none" || t === "inside" ? t : "outside";
+  }
+  /** The grid this element currently draws, or null when it cannot yet. */
+  get graticule() {
+    const t = O(this)?.georef;
+    if (!t) return null;
+    const e = this.gridPlane();
+    if (!e) return null;
+    const n = (i) => {
+      const s = Number(this.getAttribute(i));
+      return Number.isFinite(s) && s > 0 ? s : null;
+    };
+    return un({
+      georef: t,
+      plane: e,
+      interval: n("interval"),
+      intervalX: n("interval-x"),
+      intervalY: n("interval-y"),
+      labels: this.labelPlacement,
+      format: this.getAttribute("format") === "dms" ? dn : void 0
+    });
+  }
+  /**
+   * The coordinate system the lattice is walked in. Geographic needs nothing;
+   * a projected grid needs proj4, which resolves asynchronously and triggers
+   * a re-render when it lands.
+   */
+  gridPlane() {
+    const t = Y(this.getAttribute("crs"));
+    if (!t || t === "EPSG:4326" || t === "CRS:84" || t === "OGC:CRS84") return Be;
+    const e = `${t}|${this.getAttribute("crs-def") ?? ""}`;
+    if (this.resolvedPlaneKey === e) return this.resolvedPlane;
+    const n = K(t);
+    if (n) {
+      const s = { toLngLat: (o, a) => n.inverse([o, a]), fromLngLat: (o) => n.forward(o) };
+      return this.resolvedPlane = s, this.resolvedPlaneKey = e, s;
+    }
+    const i = ++this.resolveToken;
+    return Oe(t, this.getAttribute("crs-def")).then((s) => {
+      i !== this.resolveToken || !s || (this.resolvedPlane = { toLngLat: (o, a) => s.inverse([o, a]), fromLngLat: (o) => s.forward(o) }, this.resolvedPlaneKey = e, this.scheduleRender());
+    }).catch(() => {
+    }), null;
+  }
+  renderNow() {
+    if (this.applyPlacement(), this.style.display = "block", this.style.pointerEvents = "none", !O(this)) {
+      const n = this.getAttribute("for");
+      G(this, n ? `Graticule references no frame with id "${n}".` : "Graticule has no frame to cover (set for=).");
+      return;
+    }
+    const e = this.graticule;
+    if (!e) {
+      this.replaceChildren();
+      return;
+    }
+    this.renderSvg(e);
+  }
+  renderSvg(t) {
+    const { w: e, h: n } = C(this), i = this.ownerDocument, s = i.createElementNS(st, "svg");
+    s.setAttribute("width", `${e}mm`), s.setAttribute("height", `${n}mm`), s.setAttribute("viewBox", `0 0 ${e} ${n}`), s.style.cssText = "display:block;overflow:visible;";
+    const o = "var(--om-carto-graticule-ink)", a = this.kind;
+    for (const l of t.lines)
+      if (a === "solid") {
+        const c = i.createElementNS(st, "polyline");
+        c.setAttribute("points", l.points.map((u) => `${u.xMm.toFixed(3)},${u.yMm.toFixed(3)}`).join(" ")), c.setAttribute("fill", "none"), c.setAttribute("stroke", o), c.setAttribute("stroke-width", "0.15"), s.appendChild(c);
+      } else
+        for (const c of this.tickPoints(l, a, t)) {
+          const u = i.createElementNS(st, "path");
+          u.setAttribute("d", `M ${c.xMm - z} ${c.yMm} H ${c.xMm + z} M ${c.xMm} ${c.yMm - z} V ${c.yMm + z}`), u.setAttribute("stroke", o), u.setAttribute("stroke-width", "0.15"), s.appendChild(u);
+        }
+    for (const l of t.labels) {
+      const c = i.createElementNS(st, "text");
+      c.setAttribute("x", String(l.xMm)), c.setAttribute("y", String(l.yMm)), c.setAttribute("font-size", "2.2"), c.setAttribute("fill", o), c.setAttribute("font-family", "var(--om-carto-font)"), c.setAttribute("text-anchor", l.edge === "left" ? "end" : "middle"), c.textContent = l.text, s.appendChild(c);
+    }
+    this.replaceChildren(s);
+  }
+  /** Intersections of this line with the perpendicular family. */
+  tickPoints(t, e, n) {
+    if (e === "markers") return [t.points[0], t.points[t.points.length - 1]];
+    const i = n.lines.filter((o) => o.axis !== t.axis), s = [];
+    for (const o of i) {
+      const a = pn(t.points, o.points);
+      a && s.push(a);
+    }
+    return s;
+  }
+  paintCartograph(t, e) {
+    const n = this.graticule;
+    if (!n) return;
+    const i = typeof getComputedStyle == "function" ? getComputedStyle(this) : null, s = L(i?.color) ?? "#ffffff", o = (l) => l * e.pxPerMm, a = this.kind;
+    t.save(), t.strokeStyle = s, t.fillStyle = s, t.lineWidth = o(0.15);
+    for (const l of n.lines)
+      if (a === "solid")
+        t.beginPath(), l.points.forEach((c, u) => u === 0 ? t.moveTo(o(c.xMm), o(c.yMm)) : t.lineTo(o(c.xMm), o(c.yMm))), t.stroke();
+      else
+        for (const c of this.tickPoints(l, a, n))
+          t.beginPath(), t.moveTo(o(c.xMm - z), o(c.yMm)), t.lineTo(o(c.xMm + z), o(c.yMm)), t.moveTo(o(c.xMm), o(c.yMm - z)), t.lineTo(o(c.xMm), o(c.yMm + z)), t.stroke();
+    t.font = `${o(2.2)}px ${i?.fontFamily || "system-ui, sans-serif"}`, t.textBaseline = "alphabetic";
+    for (const l of n.labels)
+      t.textAlign = l.edge === "left" ? "right" : "center", t.fillText(l.text, o(l.xMm), o(l.yMm));
+    t.restore();
+  }
+}
+function pn(r, t) {
+  let e = null, n = Number.POSITIVE_INFINITY;
+  for (const i of r)
+    for (const s of t) {
+      const o = (i.xMm - s.xMm) ** 2 + (i.yMm - s.yMm) ** 2;
+      o < n && (n = o, e = i);
+    }
+  return n <= 1 ? e : null;
+}
+x("om-graticule", Ve);
+function gn(r, t) {
+  if (r == null || typeof r != "object") return;
+  const e = r.properties;
+  return e && t in e ? e[t] : r[t];
+}
+function Pt(r, t) {
+  if (Array.isArray(r)) {
+    if (typeof r[0] == "number") {
+      t.push([r[0], r[1]]);
+      return;
+    }
+    for (const e of r) Pt(e, t);
+  }
+}
+function bn(r) {
+  return r ? r.tileData != null ? "tiled" : r.asset != null ? "asset" : null : "empty";
+}
+function I(r, t) {
+  return gn(r, t);
+}
+function Tt(r) {
+  const t = {}, e = (i) => {
+    for (const [s, o] of Object.entries(i))
+      o == null || typeof o == "object" || (t[s] = String(o));
+  };
+  e(r);
+  const n = r.properties;
+  return n && typeof n == "object" && e(n), t;
+}
+function yn(r) {
+  let t = 1 / 0, e = 1 / 0, n = -1 / 0, i = -1 / 0;
+  const s = [], o = r.geometry;
+  if (o?.coordinates != null) Pt(o.coordinates, s);
+  else if (Array.isArray(r.coordinates)) Pt(r.coordinates, s);
+  else {
+    const a = Number(I(r, "lng") ?? I(r, "longitude") ?? I(r, "lon") ?? I(r, "x")), l = Number(I(r, "lat") ?? I(r, "latitude") ?? I(r, "y"));
+    Number.isFinite(a) && Number.isFinite(l) && s.push([a, l]);
+  }
+  for (const [a, l] of s)
+    !Number.isFinite(a) || !Number.isFinite(l) || (t = Math.min(t, a), n = Math.max(n, a), e = Math.min(e, l), i = Math.max(i, l));
+  return !Number.isFinite(t) || !Number.isFinite(e) ? null : [t, e, n, i];
+}
+function wn(r, t) {
+  const [e, n, i, s] = r, o = Math.max(i - e, 1e-4), a = Math.max(s - n, 1e-4), l = o * t, c = a * t;
+  return [e - l, n - c, i + l, s + c];
+}
+const Vn = ([r, t, e, n]) => Math.max(0, e - r) * Math.max(0, n - t);
+function Mn({ features: r, filter: t, sort: e }) {
+  let n = t ? r.filter((s) => vn(t, s)) : [...r];
+  const i = An(e);
+  return i.length > 0 && (n = [...n].sort((s, o) => {
+    for (const { field: a, descending: l } of i) {
+      const c = I(s, a), u = I(o, a);
+      if (c == null && u == null) continue;
+      if (c == null) return 1;
+      if (u == null) return -1;
+      const m = Sn(c, u);
+      if (m !== 0) return l ? -m : m;
+    }
+    return 0;
+  })), n;
+}
+function vn(r, t) {
+  try {
+    return !!r(t);
+  } catch {
+    return !1;
+  }
+}
+function An(r) {
+  return r ? r.split(",").map((t) => t.trim()).filter(Boolean).map((t) => t.startsWith("-") ? { field: t.slice(1), descending: !0 } : { field: t, descending: !1 }) : [];
+}
+function Sn(r, t) {
+  return typeof r == "number" && typeof t == "number" ? r - t : String(r).localeCompare(String(t), void 0, { numeric: !0, sensitivity: "base" });
+}
+function Cn(r) {
+  const t = r.replace(/[\x00-\x1f<>:"/\\|?*]+/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 100);
+  return t === "" ? "page" : t;
+}
+function xn(r, t, e) {
+  const n = /* @__PURE__ */ new Map();
+  return t.map((i, s) => {
+    const o = Tt(i), a = (r ?? "page-{{atlas.index}}").replace(/\{\{\s*atlas\.([\w]+)\s*\}\}/g, (u, m) => m === "index" ? String(s + 1) : m === "count" ? String(t.length) : o[m] ?? u), l = Cn(a), c = n.get(l) ?? 0;
+    return n.set(l, c + 1), `${c === 0 ? l : `${l}-${c + 1}`}.${e}`;
+  });
+}
+class He extends R {
+  static observedAttributes = [...P["om-atlas"]];
+  /**
+   * Pages are SNAPSHOTTED when iteration first starts. A streaming or polling
+   * layer would otherwise change the page count halfway through an export,
+   * producing an archive whose contents do not match its own index.
+   */
+  pages = null;
+  currentIndex = 0;
+  rejection = null;
+  /** The frame whose layer drives the iteration — the same `for=` rule every furniture element follows. */
+  get frame() {
+    return O(this);
+  }
+  get count() {
+    return this.ensurePages().length;
+  }
+  get index() {
+    return this.currentIndex;
+  }
+  get current() {
+    return this.ensurePages()[this.currentIndex] ?? null;
+  }
+  /** Why this atlas cannot run, if it cannot. */
+  get problem() {
+    return this.ensurePages(), this.rejection;
+  }
+  /** Export filenames, one per page, already de-duplicated. */
+  filenames(t = "png") {
+    return xn(this.getAttribute("filename"), this.ensurePages(), t);
+  }
+  /** Human page labels, for an editor's stepper and PDF bookmarks. */
+  pageName(t) {
+    const e = this.ensurePages()[t];
+    if (!e) return `Page ${t + 1}`;
+    const n = Tt(e), i = this.getAttribute("page-name");
+    return i ? i.replace(
+      /\{\{\s*atlas\.([\w]+)\s*\}\}/g,
+      (s, o) => o === "index" ? String(t + 1) : o === "count" ? String(this.count) : n[o] ?? s
+    ) : n.name ?? n.title ?? `Page ${t + 1}`;
+  }
+  /**
+   * Recompute the page list from the layer as it stands now, and apply the
+   * current page. Applying is part of refreshing because the page list first
+   * becomes non-empty when the frame mounts its map: without it, page 1 would
+   * never be applied and a cartograph would print `{{atlas.*}}` literally with
+   * the authored camera, until something else happened to seek.
+   */
+  refresh() {
+    this.pages = null, this.rejection = null, this.ensurePages().length > 0 && this.applyPage();
+  }
+  ensurePages() {
+    if (this.pages) return this.pages;
+    const e = this.frame?.mapElement?.getLayers?.(), n = this.getAttribute("layer"), i = e?.find((a) => a.id === n), s = e ? bn(i) : null;
+    if (!e || s)
+      return this.rejection = e ? s : null, this.pages = [];
+    const o = this.materialize(i);
+    return this.pages = Mn({ features: o, filter: this.compileFilter(), sort: this.getAttribute("sort") }), this.currentIndex = Math.min(this.currentIndex, Math.max(0, this.pages.length - 1)), this.pages;
+  }
+  /**
+   * Rows from the layer, with the layer's OWN declarative filters applied —
+   * the coherence rule. An atlas that paged over unfiltered rows would print
+   * sheets for features the map itself is hiding.
+   */
+  materialize(t) {
+    const e = H(), n = t.data;
+    if (!n) return [];
+    const i = e?.asRows ? e.asRows(n) : Array.isArray(n) ? n : [], s = [t.filter, t.categoryFilter].filter(Boolean);
+    return s.length === 0 ? i : i.filter(
+      (o) => s.every((a) => {
+        if (!a.field) return !0;
+        const l = I(o, a.field);
+        if (a.range) {
+          const c = Number(l);
+          return Number.isFinite(c) && c >= a.range[0] && c <= a.range[1];
+        }
+        return a.categories ? a.categories.includes(l) : !0;
+      })
+    );
+  }
+  /** `filter=` uses the CORE expression language — the syntax authors already know from om-layer. */
+  compileFilter() {
+    const t = this.getAttribute("filter");
+    if (!t) return;
+    const e = H();
+    if (e?.compileExpression)
+      try {
+        const n = e.compileExpression(t, { shape: "geojson", paramName: "d" });
+        return (i) => !!n.fn(i);
+      } catch (n) {
+        console.warn(`[onlymapjs/cartograph] <om-atlas filter="${t}"> did not compile: ${n.message}`);
+        return;
+      }
+  }
+  /** Move to a page: refit the following frames, re-resolve tokens, announce it. */
+  seek(t) {
+    const e = this.ensurePages();
+    e.length !== 0 && (this.currentIndex = Math.min(Math.max(0, Math.trunc(t)), e.length - 1), this.applyPage());
+  }
+  next() {
+    this.seek(this.currentIndex + 1);
+  }
+  applyPage() {
+    const t = this.current;
+    if (!t) return;
+    const e = this.closest("om-cartograph");
+    for (const n of e?.querySelectorAll("om-frame") ?? []) {
+      if (n.getAttribute("atlas-fit") !== "feature") continue;
+      const i = yn(t);
+      if (!i) continue;
+      const s = Number(n.getAttribute("atlas-margin")), o = wn(i, Number.isFinite(s) && s > 0 ? s : 0.15);
+      n.fitBounds?.(o);
+    }
+    e?.setAtlasFields({ ...Tt(t), index: String(this.currentIndex + 1), count: String(this.count) }), e?.refreshFurniture(), this.dispatchEvent(
+      new CustomEvent("om-atlas-page", {
+        bubbles: !0,
+        detail: { index: this.currentIndex, count: this.count, name: this.pageName(this.currentIndex), feature: t }
+      })
+    );
+  }
+  renderNow() {
+    this.style.display = "none", this.refresh();
+  }
+}
+x("om-atlas", He);
+const $n = /* @__PURE__ */ new Set(["class", "style", "id", "hidden", "title", "lang", "dir", "slot", "part", "role", "tabindex"]), kn = /* @__PURE__ */ new Set(["style", "script", "img", "template", "om-map"]), En = ["data-om-carto-credit", "data-om-carto-marks", "data-om-carto-flattened"], Nn = /* @__PURE__ */ new Set(["om-text", "om-legend", "om-scalebar", "om-north", "om-shape", "om-image"]), Pn = /* @__PURE__ */ new Set(["om-frame", "om-legend", "om-scalebar", "om-north", "om-graticule", "om-text", "om-shape", "om-image"]), Tn = 0.02, Ln = (r) => Math.max(0, Number(r.getAttribute("bleed")) || 0);
+function Ye(r) {
+  const t = r.tagName.toLowerCase();
+  return r.id ? `${t}#${r.id}` : t;
+}
+function V(r, t) {
+  const e = r.getAttribute(t);
+  if (e == null || e.trim() === "") return null;
+  const n = Number(e);
+  return Number.isFinite(n) ? n : null;
+}
+function Fn(r, t) {
+  return r.x < t.x + t.w && t.x < r.x + r.w && r.y < t.y + t.h && t.y < r.y + r.h;
+}
+function In(r, t) {
+  const e = r.getAttribute("style");
+  if (!e) return null;
+  const n = new RegExp(`(?:^|;)\\s*${t}\\s*:\\s*(-?[\\d.]+)mm`, "i").exec(e);
+  return n ? Number(n[1]) : null;
+}
+function Ke(r) {
+  const t = [], e = (o, a, l, c, u) => {
+    t.push({ severity: o, element: Ye(a), ...u ? { attribute: u } : {}, message: l, fix: c });
+  }, n = [...r.querySelectorAll("om-cartograph")];
+  if (n.length === 0 && r.tagName?.toLowerCase() === "om-cartograph" && n.push(r), n.length === 0)
+    return { valid: !0, errors: [], warnings: [] };
+  for (const o of n) Rn(o, e);
+  const i = t.filter((o) => o.severity === "error"), s = t.filter((o) => o.severity === "warning");
+  return { valid: i.length === 0, errors: i, warnings: s };
+}
+function Rn(r, t) {
+  const e = r.getAttribute("size"), n = V(r, "width") != null && V(r, "height") != null;
+  e && !Bt.includes(e) && !n && t(
+    "error",
+    r,
+    `Unknown page size "${e}" and no width/height to fall back on.`,
+    `Use one of ${Bt.join(", ")}, or give width= and height= in millimetres.`,
+    "size"
+  );
+  const i = r.getAttribute("cvd");
+  i && i.trim().toLowerCase() !== "none" && !Lt(i) && t("warning", r, `Unknown cvd="${i}" — no simulation applied.`, `Use one of ${rr.join(", ")}.`, "cvd"), r.hasAttribute("crop-marks") && Ln(r) <= 0 && t("warning", r, "crop-marks needs bleed to draw into — trim marks sit outside the page box.", 'Add bleed="3" (mm), or drop crop-marks.', "crop-marks");
+  const s = V(r, "safe-zone");
+  if (s != null && s > 0) {
+    const h = ct(r.getAttribute("size"), r.getAttribute("width"), r.getAttribute("height"), r.getAttribute("orientation"));
+    s * 2 >= Math.min(h.widthMm, h.heightMm) && t("warning", r, `safe-zone=${s}mm leaves no usable area on a ${h.widthMm} × ${h.heightMm} mm page.`, "Use a smaller inset — 5–10mm is typical.", "safe-zone");
+  }
+  const o = r.getAttribute("format");
+  o == null ? t("warning", r, "No format= on the cartograph root.", `Add format="${pt}" so future runtimes can migrate this document.`, "format") : o !== pt && t("warning", r, `Unrecognised document format "${o}".`, `This build understands "${pt}".`, "format");
+  const { widthMm: a, heightMm: l } = ct(e, r.getAttribute("width"), r.getAttribute("height"), r.getAttribute("orientation")), c = Math.max(0, V(r, "bleed") ?? 0), u = /* @__PURE__ */ new Set(), m = [...r.querySelectorAll("om-frame")];
+  for (const h of m)
+    h.id ? u.add(h.id) : t("error", h, "Frame has no id.", "Give every frame an id so furniture can reference it with for=.", "id");
+  for (const h of r.children) {
+    if (En.some((p) => h.hasAttribute(p))) continue;
+    const f = h.tagName.toLowerCase();
+    !gt.includes(f) && !kn.has(f) && t("error", h, `<${f}> is not a cartograph element.`, `Use one of ${gt.join(", ")}, or move this content inside an <om-text>.`);
+  }
+  const d = [];
+  for (const h of [r, ...r.querySelectorAll("*")]) {
+    const f = h.tagName.toLowerCase();
+    if (gt.includes(f) && !h.closest("om-map")) {
+      if (_n(h, f, t), Pn.has(f)) {
+        const p = C(h);
+        On(h, p, a, l, c, t), Nn.has(f) && !h.hasAttribute("hidden") && d.push({ el: h, box: p });
+      }
+      f === "om-frame" && Un(h, t), f === "om-legend" && jn(h, m, t), f === "om-atlas" && zn(h, m, t), f === "om-scalebar" && Dn(h, m, t), f === "om-text" && Gn(h, m, t);
+      for (const p of ["for", "overview-of"]) {
+        const g = h.getAttribute(p);
+        g && !u.has(g) && t("error", h, `${p}="${g}" references no frame on this page.`, `Point it at one of: ${[...u].join(", ") || "(no frames)"}.`, p);
+      }
+    }
+  }
+  for (let h = 0; h < d.length; h++)
+    for (let f = h + 1; f < d.length; f++) {
+      const p = d[h], g = d[f];
+      p.box.w <= 0 || p.box.h <= 0 || g.box.w <= 0 || g.box.h <= 0 || Fn(p.box, g.box) && t(
+        "warning",
+        p.el,
+        `Overlaps ${Ye(g.el)} on the page.`,
+        "Move one of them — furniture overlapping furniture usually means a stale layout (frames may sit under anything)."
+      );
+    }
+}
+function _n(r, t, e) {
+  const n = new Set(P[t] ?? []);
+  for (const i of r.attributes) {
+    const s = i.name.toLowerCase();
+    if (n.has(s) || $n.has(s) || s.startsWith("data-") || s.startsWith("aria-")) continue;
+    const o = gr.get(s);
+    if (o) {
+      e("warning", r, `Attribute "${s}" has no effect: ${o}`, "Remove it, or use the documented alternative.", s);
+      continue;
+    }
+    e("warning", r, `Unknown attribute "${s}" on <${t}> — likely a typo.`, `Valid attributes: ${[...n].join(", ")}.`, s);
+  }
+}
+function On(r, t, e, n, i, s) {
+  if (t.w <= 0 || t.h <= 0) {
+    s("error", r, `Element has no size (w=${t.w}, h=${t.h}).`, "Give w= and h= in millimetres — both greater than zero.", t.w <= 0 ? "w" : "h");
+    return;
+  }
+  const o = -i, a = e + i, l = n + i;
+  (t.x < o || t.y < o || t.x + t.w > a + 1e-6 || t.y + t.h > l + 1e-6) && s(
+    "error",
+    r,
+    `Element box (${t.x}, ${t.y}, ${t.w} × ${t.h} mm) falls outside the ${e} × ${n} mm page${i ? ` (+${i}mm bleed)` : ""}.`,
+    "Move or resize it so the whole box sits on the sheet."
+  );
+  const c = [
+    ["left", t.x],
+    ["top", t.y],
+    ["width", t.w],
+    ["height", t.h]
+  ];
+  for (const [u, m] of c) {
+    const d = In(r, u);
+    d != null && Math.abs(d - m) > 0.01 && s(
+      "error",
+      r,
+      `Inline style ${u}:${d}mm disagrees with the placement attribute (${m}mm).`,
+      "The attributes are authoritative — make the inline style match, or drop it and let the runtime write it.",
+      "style"
+    );
+  }
+}
+function Un(r, t) {
+  if ((r.getAttribute("mode") === "static" ? "static" : "live") === "static") {
+    const n = r.getAttribute("corners"), i = mt(n);
+    i || t(
+      "error",
+      r,
+      n == null ? "Static frame has no corners=." : `Static frame has malformed corners= ("${n}").`,
+      'Give four lon/lat pairs in tl, tr, br, bl order — corners="[[lng,lat],[lng,lat],[lng,lat],[lng,lat]]".',
+      "corners"
+    ), r.querySelector(":scope > img") || t("error", r, "Static frame has no <img> child to place.", "Add the georeferenced raster as an <img> child — it is also what renders with JavaScript disabled.");
+    const s = C(r), o = K(r.getAttribute("crs"));
+    if (i && o && s.w > 0 && s.h > 0) {
+      const a = ht({ corners: i, widthMm: s.w, heightMm: s.h, crsForward: o });
+      if (a.degenerate)
+        t("error", r, "Frame corners are degenerate (collinear or coincident) — nothing can be placed on this frame.", "Check the corner order: tl, tr, br, bl.", "corners");
+      else {
+        const l = Br(a);
+        l != null && l > Tn && t(
+          "warning",
+          r,
+          `Ground scale varies ${(l * 100).toFixed(1)}% across this frame, so a single scale bar is only true near its anchor.`,
+          "Shrink the frame's latitude span, or drop the scale bar in favour of a stated representative fraction."
+        );
+      }
+    }
+  } else {
+    lt(r) || t(
+      "error",
+      r,
+      "Live frame has no valid camera.",
+      'Give it center="[lng,lat]" and an explicit numeric zoom= (zoom 0 is valid).',
+      r.hasAttribute("center") ? "zoom" : "center"
+    ), !r.getAttribute("src") && !r.querySelector(":scope > om-map") && t("error", r, "Live frame has no map source.", "Give it src= or add an inline <om-map> child.", "src");
+    for (const i of ["crs", "corners"])
+      r.hasAttribute(i) && t(
+        "warning",
+        r,
+        `${i}= is ignored on a live frame — live frames are always EPSG:3857 and derive their corners from the camera.`,
+        'Remove it, or set mode="static" if this frame is a georeferenced raster.',
+        i
+      );
+    const n = Y(r.getAttribute("crs"));
+    n && n !== "EPSG:3857" && t("error", r, `Live frame declares ${n}, but live frames render EPSG:3857.`, 'Use mode="static" with a georeferenced raster for other projections.', "crs");
+  }
+}
+function Rt(r, t) {
+  const e = r.getAttribute("for");
+  return e ? t.find((n) => n.id === e) : t.length === 1 ? t[0] : void 0;
+}
+function jn(r, t, e) {
+  const n = r.getAttribute("derived") !== "false", i = Rt(r, t);
+  n && i?.getAttribute("mode") === "static" && e(
+    "warning",
+    r,
+    "This legend derives from a static frame, which has no layers to derive from.",
+    'Write the rows as <om-legend-row color= label= shape=> children and set derived="false".',
+    "derived"
+  );
+  const s = qe(r);
+  if (s.length < 2) return;
+  const o = or(s.map((a) => ({ label: a.label, color: a.color, layer: a.layerId })));
+  if (o.collapses.length > 0 && o.worstType) {
+    const a = o.collapses.filter((c) => c.type === o.worstType), l = a.slice(0, 3).map((c) => `"${c.a.label}"/"${c.b.label}"`).join(", ");
+    e(
+      "warning",
+      r,
+      `Under ${o.worstType}, ${a.length === 1 ? "one legend pair becomes" : `${a.length} legend pairs become`} indistinguishable: ${l}.`,
+      "Pick colours that differ in lightness as well as hue, or add a pattern or label to separate them."
+    );
+  }
+}
+function zn(r, t, e) {
+  const n = r.getAttribute("layer");
+  n || e("error", r, "Atlas has no layer= to iterate.", 'Name a layer inside the frame, e.g. layer="parcels".', "layer");
+  const i = r.getAttribute("for"), s = Rt(r, t);
+  if (!s) {
+    !i && t.length !== 1 && e("error", r, `Atlas does not say which frame drives it, and the page has ${t.length} frames.`, 'Add for="<frame id>".', "for");
+    return;
+  }
+  if (s.getAttribute("mode") === "static") {
+    e(
+      "error",
+      r,
+      "An atlas cannot iterate a static frame — a raster has no features.",
+      "Point the atlas at a live frame whose map carries the layer.",
+      "for"
+    );
+    return;
+  }
+  const o = s.querySelector(":scope > om-map");
+  if (o && n) {
+    const a = [...o.querySelectorAll("om-layer")].find((c) => c.id === n);
+    if (!a) {
+      e("error", r, `Atlas layer "${n}" is not in frame #${s.id}'s map.`, "Check the layer id, or point the atlas at the frame that has it.", "layer");
+      return;
+    }
+    const l = a.getAttribute("data") ?? "";
+    /\{z\}|\{x\}|\{y\}/.test(l) && e(
+      "error",
+      r,
+      `Atlas layer "${n}" is tiled, so its features live on a server rather than in this document.`,
+      "Iterate a layer whose data is loaded locally (GeoJSON, CSV, inline JSON).",
+      "layer"
+    );
+  }
+}
+function Dn(r, t, e) {
+  const n = V(r, "segment-length");
+  if (n == null) return;
+  const i = Rt(r, t);
+  if (!i) return;
+  const s = mt(i.getAttribute("corners")), o = K(i.getAttribute("crs")), a = C(i);
+  if (!s || !o || a.w <= 0 || a.h <= 0) return;
+  const l = ht({ corners: s, widthMm: a.w, heightMm: a.h, crsForward: o }), c = C(r), u = ke({
+    groundMetersPerMm: l.groundMetersPerMm(),
+    maxWidthMm: c.w,
+    segments: V(r, "segments") ?? void 0,
+    segmentLengthMeters: n
+  });
+  u && u.totalMm > c.w + 1e-6 && e(
+    "warning",
+    r,
+    `segment-length=${n}m makes the bar ${u.totalMm.toFixed(1)}mm wide, wider than its ${c.w}mm box.`,
+    "Widen the bar's box, use fewer segments, or drop segment-length and let it snap to a 1-2-5 length that fits.",
+    "segment-length"
+  );
+}
+function Gn(r, t, e) {
+  const n = r.textContent ?? "", i = /* @__PURE__ */ new Set(["title", "attribution", "date", "notes", "scale", "crs"]), s = new Set(t.map((o) => o.id).filter(Boolean));
+  for (const o of $r(n))
+    if (!o.startsWith("atlas.")) {
+      if (o.startsWith("frame.")) {
+        const a = o.slice(6), l = a.lastIndexOf("."), c = l > 0 ? a.slice(0, l) : "", u = l > 0 ? a.slice(l + 1) : "";
+        s.has(c) ? u !== "scale" && u !== "crs" && e("warning", r, `{{${o}}} — frames provide scale and crs.`, `Use {{frame.${c}.scale}} or {{frame.${c}.crs}}.`) : e("warning", r, `{{${o}}} references no frame with id "${c}".`, `Frames on this page: ${[...s].join(", ") || "(none)"}.`);
+        continue;
+      }
+      if ((o === "scale" || o === "crs") && t.length !== 1) {
+        e(
+          "warning",
+          r,
+          `{{${o}}} is ambiguous with ${t.length} frames on the page.`,
+          `Name the frame: {{frame.<id>.${o}}}.`
+        );
+        continue;
+      }
+      i.has(o) || e("warning", r, `Unknown token {{${o}}} — it will render literally.`, `Known tokens: ${[...i].join(", ")}, frame.<id>.scale, frame.<id>.crs, atlas.<field>.`);
+    }
+}
+function Hn(r) {
+  return Ke(pr(r));
+}
+async function Yn(r) {
+  const t = Ke(r), e = [...r.querySelectorAll("om-frame")].filter((a) => a.querySelector(":scope > om-map"));
+  if (e.length === 0) return t;
+  const { loadCore: n } = await Promise.resolve().then(() => Je), i = await n(), s = [...t.errors], o = [...t.warnings];
+  for (const a of e) {
+    const l = a.id ? `om-frame#${a.id}` : "om-frame", c = i.validateManifest(a);
+    for (const u of c.errors) s.push({ ...u, element: `${l} > ${u.element}` });
+    for (const u of c.warnings) o.push({ ...u, element: `${l} > ${u.element}` });
+  }
+  return { valid: s.length === 0, errors: s, warnings: o };
+}
+function Kn() {
+  x("om-cartograph", Fe), x("om-text", Ie), x("om-frame", Ue), x("om-scalebar", je), x("om-north", ze), x("om-shape", De), x("om-image", Ge), x("om-legend", We), x("om-graticule", Ve), x("om-atlas", He);
+}
+ye(() => import("@nika-js/onlymap"));
+dr();
+export {
+  P as CARTOGRAPH_ELEMENT_ATTRS,
+  pt as CARTOGRAPH_FORMAT,
+  gt as CARTOGRAPH_TAG_NAMES,
+  qn as CARTOGRAPH_THEMES,
+  ir as COLLAPSE_THRESHOLD,
+  Ft as CVD_MATRICES,
+  dt as CVD_TYPES,
+  rr as CVD_VALUES,
+  Be as GEOGRAPHIC_PLANE,
+  gr as INERT_RESERVED_CARTOGRAPH_ATTRS,
+  Se as MAX_CANVAS_AREA,
+  Ae as MAX_CANVAS_DIMENSION,
+  xt as MAX_CATEGORY_ENTRIES,
+  He as OmAtlasElement,
+  Fe as OmCartographElement,
+  Ue as OmFrameElement,
+  Ve as OmGraticuleElement,
+  Ge as OmImageElement,
+  We as OmLegendElement,
+  ze as OmNorthElement,
+  je as OmScalebarElement,
+  De as OmShapeElement,
+  Ie as OmTextElement,
+  Ot as PAGE_PRESETS,
+  Bt as PAGE_SIZE_NAMES,
+  j as PLACED_ATTR_NAMES,
+  W as PX_PER_MM,
+  Sr as SCALE_GROUP_SEPARATOR,
+  hr as URL_ACTION_TIMEOUT_MS,
+  Fr as alignOffset,
+  Le as allFrames,
+  sr as applyCvdToCanvas,
+  kr as applyTokens,
+  mr as applyUrlActions,
+  Tt as atlasFields,
+  Vn as boundsArea,
+  C as boxMm,
+  un as buildGraticule,
+  Mn as buildPages,
+  ke as buildScalebar,
+  Ar as buildScalebarDrawing,
+  K as builtinCrsForward,
+  Wn as canvasMeasurer,
+  Pr as clearUnlinked,
+  Bn as cornersFromBounds,
+  se as cornersFromCamera,
+  ht as createFrameGeoref,
+  er as createZip,
+  Kn as defineCartographElements,
+  Dt as deltaE00,
+  sn as deriveLegendRows,
+  ar as ensureCvdFilters,
+  yn as featureBounds,
+  I as fieldOf,
+  Te as findFrame,
+  dn as formatDms,
+  Cr as formatScaleDenominator,
+  dr as installUrlActions,
+  Ze as isCoreLoaded,
+  Er as isoDate,
+  Lr as layoutText,
+  or as lintLegendColours,
+  we as loadCore,
+  _r as mercatorForward,
+  Or as mercatorInverse,
+  de as niceInterval,
+  $e as niceNumberBelow,
+  Y as normalizeCrs,
+  Wr as northBearingDegrees,
+  Pe as ownerCartograph,
+  wn as padBounds,
+  _t as paintEnvForDpi,
+  nr as parseColor,
+  mt as parseCorners,
+  An as parseSort,
+  H as peekCore,
+  lt as readCamera,
+  qe as readLiteralRows,
+  cn as readOverrides,
+  O as referencedFrame,
+  bn as rejectionFor,
+  It as renderCartograph,
+  Ce as renderCartographAtlas,
+  Oe as resolveCrsForward,
+  Lt as resolveCvdType,
+  xn as resolveFilenames,
+  ct as resolvePageSize,
+  xr as resolveToken,
+  Ne as resolveTokens,
+  on as rowColorFor,
+  Hr as sanitizeAdoptedMap,
+  Cn as sanitizeFilename,
+  Br as scaleVariation,
+  ye as setCoreLoader,
+  jt as simulate,
+  nn as swatchShapeFor,
+  $r as tokensIn,
+  ne as utmDef,
+  Ke as validateCartograph,
+  Yn as validateCartographDeep,
+  Hn as validateCartographString,
+  Wt as whenPageReady
+};