@fxi/zartigl 0.14.1 → 0.15.0

package/dist/geovideo-index-D-BHqpO6.js

@@ -0,0 +1,2991 @@
+import { inflate as Ae } from "pako";
+import Me from "numcodecs/blosc";
+const Se = { label: "Thermal", tags: ["sequential", "temperature"], colors: ["#042333", "#2c3395", "#744796", "#b15f82", "#eb7958", "#fbb43d", "#e8fa5b"] }, Fe = { label: "Haline", tags: ["sequential", "salinity"], colors: ["#2a186c", "#17568b", "#1a7e8f", "#22a785", "#55c666", "#aadc32", "#fde333"] }, Ue = { label: "Solar", tags: ["sequential", "irradiance"], colors: ["#330f0b", "#6b2313", "#a83c12", "#d6621a", "#f3951e", "#f7c741", "#f9f871"] }, Ne = { label: "Ice", tags: ["sequential"], colors: ["#040d1a", "#123365", "#1c5f9e", "#2b8ece", "#62bde3", "#aaddf2", "#f2faff"] }, Ce = { label: "Deep", tags: ["sequential", "depth"], colors: ["#fdfecc", "#c8e59b", "#74c8a3", "#3194b0", "#2a5b8e", "#281a5e", "#0c0820"] }, De = { label: "RdYlBu", tags: ["diverging"], colors: ["#3288bd", "#66c2a5", "#abdda4", "#e6f598", "#fee08b", "#fdae61", "#f46d43", "#d53e4f"] }, Ie = { label: "Dense", tags: ["sequential"], colors: ["#e6f1f1", "#92c4ca", "#44929a", "#20627a", "#1a3c6a", "#211a50", "#0d0621"] }, Pe = { label: "Algae", tags: ["sequential", "biology", "log"], colors: ["#d7f9d0", "#a2d595", "#64b463", "#129450", "#126e45", "#1a482f", "#122414"] }, Le = { label: "Oxygen", tags: ["sequential", "biology", "hypoxia"], colors: ["#09060f", "#5b1028", "#d43d2f", "#f39b3d", "#f3e7b3", "#79cbd1", "#176b9c"] }, Ge = { label: "Matter", tags: ["sequential", "biology"], colors: ["#fdfecc", "#f2c98a", "#e07c4e", "#bc3754", "#8d1a6d", "#51156b", "#1c0c3f"] }, Ve = { label: "Viridis", tags: ["sequential", "perceptual"], colors: ["#440154", "#443983", "#31688e", "#21918c", "#35b779", "#90d743", "#fde725"] }, Oe = { label: "Plasma", tags: ["sequential", "perceptual"], colors: ["#0d0887", "#5e01a6", "#9c179e", "#cc4778", "#ed7953", "#fdb42f", "#f0f921"] }, Be = { label: "Cyclic", tags: ["cyclic", "direction"], colors: ["#2e22ea", "#b541fb", "#fc93c0", "#f1ee35", "#77c80d", "#458776", "#2c24e9"] }, $e = { label: "Tempo", tags: ["sequential"], colors: ["#fff6f4", "#c2d1b9", "#7db390", "#2a937f", "#156d73", "#1c455b", "#151d44"] }, Xe = { label: "Turbid", tags: ["sequential", "biology", "log"], colors: ["#e9f5a0", "#c8c86e", "#a09845", "#786031", "#533324", "#341423", "#150d17"] }, ze = { label: "Speed", tags: ["sequential", "velocity"], colors: ["#fcfea4", "#d5e429", "#94c63e", "#52a657", "#2d8169", "#1d5b6d", "#0d3361"] }, qe = { label: "Amp", tags: ["sequential"], colors: ["#f2f2f2", "#c0b8db", "#9180b6", "#6c4e9e", "#4e2e83", "#32185d", "#110a35"] }, We = { label: "Heat", tags: ["sequential"], colors: ["#fde725", "#fde725", "#f8961e", "#e63946", "#9d0208", "#3a0007"] }, He = { label: "Balance", tags: ["diverging"], colors: ["#181c43", "#3066af", "#9bbcdd", "#f2f2f2", "#e07d53", "#b13626", "#2c0b0e"] }, Ye = { label: "Delta", tags: ["diverging"], colors: ["#0e3f31", "#20877b", "#99d4c1", "#f2f2f2", "#a1b0d4", "#3c5b9e", "#0d1938"] }, je = { label: "Curl", tags: ["diverging"], colors: ["#152237", "#2471b3", "#8dbac4", "#f2f2f2", "#c79f84", "#a63827", "#270b17"] }, Ke = { label: "Gray", tags: ["sequential"], colors: ["#000000", "#252525", "#4d4d4d", "#7a7a7a", "#a8a8a8", "#d4d4d4", "#ffffff"] }, ye = {
+  thermal: Se,
+  "thermal-alt": { label: "Thermal Alt", tags: ["sequential", "temperature"], colors: ["#176b9c", "#79cbd1", "#f3e7b3", "#f39b3d", "#d43d2f", "#5b1028", "#09060f"] },
+  haline: Fe,
+  solar: Ue,
+  ice: Ne,
+  deep: Ce,
+  rdylbu: De,
+  dense: Ie,
+  algae: Pe,
+  oxygen: Le,
+  matter: Ge,
+  viridis: Ve,
+  plasma: Oe,
+  cyclic: Be,
+  tempo: $e,
+  turbid: Xe,
+  speed: ze,
+  amp: qe,
+  heat: We,
+  "heat-alert": { label: "Heat Alert", tags: ["sequential", "alpha", "deprecated"], colors: ["#fde72500", "#fde725cc", "#f8961e", "#e63946", "#9d0208", "#3a0007"] },
+  balance: He,
+  delta: Ye,
+  curl: je,
+  "mono-black": { label: "Black", tags: ["monochrome", "particles"], colors: ["#000000", "#000000"] },
+  "mono-white": { label: "White", tags: ["monochrome", "particles"], colors: ["#ffffff", "#ffffff"] },
+  "mono-pink": { label: "Pink", tags: ["monochrome", "particles"], colors: ["#ff2aa1", "#ff2aa1"] },
+  gray: Ke
+}, oe = 64, Ze = {
+  linear: (i) => i,
+  // Rises fast: values just inside the zone already show.
+  log: (i) => Math.log10(1 + 9 * i),
+  // Stays faint longer: codec noise at the end of the range stays hidden.
+  exp: (i) => (10 ** i - 1) / 9
+};
+function Qe(i, e) {
+  const t = Ze[e.curve ?? "linear"], s = e.low ?? 0, r = e.high ?? 0;
+  let n = 1;
+  return s > 0 && i < s && (n = Math.min(n, t(Math.max(i, 0) / s))), r > 0 && i > 1 - r && (n = Math.min(n, t(Math.max(1 - i, 0) / r))), n;
+}
+function Je(i) {
+  let e = i.replace("#", "");
+  (e.length === 3 || e.length === 4) && (e = [...e].map((s) => s + s).join(""));
+  const t = (s) => parseInt(e.slice(s, s + 2), 16);
+  return [
+    t(0),
+    t(2),
+    t(4),
+    e.length === 8 ? t(6) : 255
+  ];
+}
+function et([i, e, t, s]) {
+  return `#${[i, e, t, s].map(
+    (r) => Math.round(Math.min(255, Math.max(0, r))).toString(16).padStart(2, "0")
+  ).join("")}`;
+}
+function tt(i, e) {
+  if (e <= i[0][0])
+    return i[0][1];
+  for (let t = 1; t < i.length; t++) {
+    const [s, r] = i[t];
+    if (e <= s) {
+      const [n, o] = i[t - 1], a = s === n ? 1 : (e - n) / (s - n);
+      return o.map((c, l) => c + (r[l] - c) * a);
+    }
+  }
+  return i[i.length - 1][1];
+}
+function it(i, e) {
+  const t = Object.entries(i).map(
+    ([r, n]) => [Number(r), Je(n)]
+  ).sort((r, n) => r[0] - n[0]), s = {};
+  for (let r = 0; r <= oe; r++) {
+    const n = r / oe, [o, a, c, l] = tt(t, n);
+    s[n] = et([o, a, c, l * Qe(n, e)]);
+  }
+  return s;
+}
+const st = (i) => !!i && ((i.low ?? 0) > 0 || (i.high ?? 0) > 0);
+function ce(i) {
+  const e = {}, t = i.length - 1;
+  return i.forEach((s, r) => {
+    e[t === 0 ? 0 : r / t] = s;
+  }), e;
+}
+function rt(i, e) {
+  const t = nt(i, e?.reverse ?? !1);
+  return st(e?.alphaFade) ? it(t, e.alphaFade) : t;
+}
+function nt(i, e) {
+  const t = ye;
+  if (typeof i == "string") {
+    const s = t[i];
+    if (!s)
+      throw new Error(
+        `Palette "${i}" not found. Available palettes: ${Object.keys(
+          t
+        ).join(", ")}`
+      );
+    const r = e ? [...s.colors].reverse() : s.colors;
+    return ce(r);
+  }
+  if (Array.isArray(i)) {
+    const s = e ? [...i].reverse() : i;
+    return ce(s);
+  }
+  return e ? Object.fromEntries(
+    Object.entries(i).map(([s, r]) => [1 - Number(s), r])
+  ) : i;
+}
+function fi(i = {}) {
+  return Object.entries(ye).map(([t, s]) => ({ id: t, ...s })).filter(
+    (t) => i.includeDeprecated || !t.tags.includes("deprecated")
+  );
+}
+function le(i, e, t) {
+  const s = i.createShader(e);
+  if (!s)
+    throw new Error("Failed to create shader");
+  if (i.shaderSource(s, t), i.compileShader(s), !i.getShaderParameter(s, i.COMPILE_STATUS)) {
+    const r = i.getShaderInfoLog(s);
+    throw i.deleteShader(s), new Error(`Shader compile error: ${r}`);
+  }
+  return s;
+}
+function mi(i, e, t) {
+  const s = i.createProgram();
+  if (!s)
+    throw new Error("Failed to create program");
+  const r = le(i, i.VERTEX_SHADER, e), n = le(i, i.FRAGMENT_SHADER, t);
+  if (i.attachShader(s, r), i.attachShader(s, n), i.linkProgram(s), !i.getProgramParameter(s, i.LINK_STATUS)) {
+    const o = i.getProgramInfoLog(s);
+    throw i.deleteProgram(s), new Error(`Program link error: ${o}`);
+  }
+  return i.deleteShader(r), i.deleteShader(n), s;
+}
+function pi(i, e, t, s, r) {
+  const n = i.createTexture();
+  if (!n)
+    throw new Error("Failed to create texture");
+  return i.bindTexture(i.TEXTURE_2D, n), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, e), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, e), i.texImage2D(
+    i.TEXTURE_2D,
+    0,
+    i.RGBA,
+    s,
+    r,
+    0,
+    i.RGBA,
+    i.UNSIGNED_BYTE,
+    t
+  ), i.bindTexture(i.TEXTURE_2D, null), n;
+}
+function at(i, e, t) {
+  const s = i.getParameter(
+    i.TEXTURE_BINDING_2D
+  ), r = i.getParameter(
+    i.FRAMEBUFFER_BINDING
+  ), n = i.createTexture(), o = i.createFramebuffer();
+  if (!n || !o)
+    return n && i.deleteTexture(n), o && i.deleteFramebuffer(o), i.bindTexture(i.TEXTURE_2D, s), i.bindFramebuffer(i.FRAMEBUFFER, r), !1;
+  let a = !1;
+  try {
+    i.bindTexture(i.TEXTURE_2D, n), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.NEAREST), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.NEAREST), i.texImage2D(
+      i.TEXTURE_2D,
+      0,
+      e,
+      1,
+      1,
+      0,
+      i.RGBA,
+      t,
+      null
+    ), i.bindFramebuffer(i.FRAMEBUFFER, o), i.framebufferTexture2D(
+      i.FRAMEBUFFER,
+      i.COLOR_ATTACHMENT0,
+      i.TEXTURE_2D,
+      n,
+      0
+    ), a = i.checkFramebufferStatus(i.FRAMEBUFFER) === i.FRAMEBUFFER_COMPLETE;
+  } finally {
+    i.bindFramebuffer(i.FRAMEBUFFER, r), i.bindTexture(i.TEXTURE_2D, s), i.deleteFramebuffer(o), i.deleteTexture(n);
+  }
+  return a;
+}
+function ot(i) {
+  return {
+    kind: "rgba8-packed",
+    internalFormat: i.RGBA,
+    type: i.UNSIGNED_BYTE
+  };
+}
+function gi(i) {
+  if (typeof WebGL2RenderingContext > "u" || !(i instanceof WebGL2RenderingContext))
+    throw new Error("zartigl requires WebGL2");
+  return i;
+}
+function Ei(i) {
+  const e = [];
+  i.getExtension("EXT_color_buffer_float") ? e.push(
+    { kind: "float32", internalFormat: i.RGBA32F, type: i.FLOAT },
+    { kind: "float16", internalFormat: i.RGBA16F, type: i.HALF_FLOAT }
+  ) : i.getExtension("EXT_color_buffer_half_float") && e.push({
+    kind: "float16",
+    internalFormat: i.RGBA16F,
+    type: i.HALF_FLOAT
+  });
+  for (const t of e)
+    if (at(
+      i,
+      t.internalFormat,
+      t.type
+    ))
+      return t;
+  return ot(i);
+}
+function Ti(i, e, t, s, r, n, o) {
+  const a = i.createTexture();
+  if (!a)
+    throw new Error("Failed to create texture");
+  return i.bindTexture(i.TEXTURE_2D, a), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, e), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, e), i.texImage2D(
+    i.TEXTURE_2D,
+    0,
+    n,
+    s,
+    r,
+    0,
+    i.RGBA,
+    o,
+    t
+  ), i.bindTexture(i.TEXTURE_2D, null), a;
+}
+function yi(i, e, t) {
+  i.activeTexture(i.TEXTURE0 + t), i.bindTexture(i.TEXTURE_2D, e);
+}
+function wi(i, e) {
+  const t = i.createFramebuffer();
+  if (!t)
+    throw new Error("Failed to create framebuffer");
+  return i.bindFramebuffer(i.FRAMEBUFFER, t), i.framebufferTexture2D(
+    i.FRAMEBUFFER,
+    i.COLOR_ATTACHMENT0,
+    i.TEXTURE_2D,
+    e,
+    0
+  ), i.bindFramebuffer(i.FRAMEBUFFER, null), t;
+}
+function bi(i) {
+  const e = i.createBuffer();
+  if (!e)
+    throw new Error("Failed to create buffer");
+  return i.bindBuffer(i.ARRAY_BUFFER, e), i.bufferData(
+    i.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+    i.STATIC_DRAW
+  ), e;
+}
+const ct = {
+  0: "#3288bd",
+  0.1: "#66c2a5",
+  0.2: "#abdda4",
+  0.3: "#e6f598",
+  0.4: "#fee08b",
+  0.5: "#fdae61",
+  0.6: "#f46d43",
+  1: "#d53e4f"
+};
+function xi(i, e, t) {
+  const s = rt(e ?? ct, t), r = document.createElement("canvas");
+  r.width = 256, r.height = 1;
+  const n = r.getContext("2d"), o = n.createLinearGradient(0, 0, 256, 0);
+  for (const [c, l] of Object.entries(s))
+    o.addColorStop(Number(c), l);
+  n.fillStyle = o, n.fillRect(0, 0, 256, 1);
+  const a = i.createTexture();
+  if (!a)
+    throw new Error("Failed to create color ramp texture");
+  return i.bindTexture(i.TEXTURE_2D, a), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.LINEAR), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, i.RGBA, i.UNSIGNED_BYTE, r), i.bindTexture(i.TEXTURE_2D, null), a;
+}
+function _i(i) {
+  const e = i.getExtension("WEBGL_debug_renderer_info");
+  return {
+    vendor: String(i.getParameter(i.VENDOR) ?? ""),
+    renderer: String(i.getParameter(i.RENDERER) ?? ""),
+    unmaskedVendor: e ? String(i.getParameter(e.UNMASKED_VENDOR_WEBGL) ?? "") : void 0,
+    unmaskedRenderer: e ? String(i.getParameter(e.UNMASKED_RENDERER_WEBGL) ?? "") : void 0,
+    version: String(i.getParameter(i.VERSION) ?? "")
+  };
+}
+function Ri(i) {
+  return {
+    program: i.getParameter(i.CURRENT_PROGRAM),
+    activeTexture: i.getParameter(i.ACTIVE_TEXTURE),
+    arrayBuffer: i.getParameter(i.ARRAY_BUFFER_BINDING),
+    elementBuffer: i.getParameter(i.ELEMENT_ARRAY_BUFFER_BINDING),
+    framebuffer: i.getParameter(i.FRAMEBUFFER_BINDING),
+    blend: i.isEnabled(i.BLEND),
+    depthTest: i.isEnabled(i.DEPTH_TEST),
+    stencilTest: i.isEnabled(i.STENCIL_TEST),
+    viewport: i.getParameter(i.VIEWPORT),
+    blendFunc: [
+      i.getParameter(i.BLEND_SRC_RGB),
+      i.getParameter(i.BLEND_DST_RGB)
+    ]
+  };
+}
+function vi(i, e) {
+  i.useProgram(e.program), i.activeTexture(e.activeTexture), i.bindBuffer(i.ARRAY_BUFFER, e.arrayBuffer), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, e.elementBuffer), i.bindFramebuffer(i.FRAMEBUFFER, e.framebuffer), e.blend ? i.enable(i.BLEND) : i.disable(i.BLEND), e.depthTest ? i.enable(i.DEPTH_TEST) : i.disable(i.DEPTH_TEST), e.stencilTest ? i.enable(i.STENCIL_TEST) : i.disable(i.STENCIL_TEST), i.viewport(e.viewport[0], e.viewport[1], e.viewport[2], e.viewport[3]), i.blendFunc(e.blendFunc[0], e.blendFunc[1]);
+}
+const we = new Float32Array([
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  1
+]), ki = {
+  projectionTransition: 1,
+  fallbackMatrix: we
+};
+function Ai(i, e, t) {
+  i.uniform1f(
+    e.u_projection_transition,
+    t.projectionTransition ?? 1
+  ), i.uniformMatrix4fv(
+    e.u_fallback_matrix,
+    !1,
+    t.fallbackMatrix ? t.fallbackMatrix instanceof Float32Array ? t.fallbackMatrix : new Float32Array(Array.from(t.fallbackMatrix)) : we
+  );
+}
+const lt = {
+  degrees_c: "°C",
+  degc: "°C",
+  degrees_celsius: "°C",
+  degree_celsius: "°C",
+  celsius: "°C",
+  // Degree heating weeks accumulate °C over weeks: a product, not a rate.
+  degree_celsius_weeks: "°C-weeks",
+  degree: "°",
+  degrees: "°",
+  kelvin: "K",
+  1: "",
+  "1e-3": "PSU",
+  "0.001": "PSU",
+  psu: "PSU",
+  stress_level: ""
+}, dt = {
+  meter: "m",
+  meters: "m",
+  metre: "m",
+  metres: "m",
+  second: "s",
+  seconds: "s",
+  day: "d",
+  days: "d",
+  hour: "h",
+  hours: "h",
+  gram: "g",
+  grams: "g",
+  milligram: "mg",
+  milligrams: "mg",
+  kilogram: "kg",
+  kilograms: "kg",
+  mole: "mol",
+  millimole: "mmol",
+  watt: "W",
+  newton: "N",
+  pascal: "Pa",
+  kelvin: "K"
+}, ht = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+function de(i) {
+  return i === 1 ? "" : [...String(i)].map((e) => ht[Number(e)]).join("");
+}
+function Mi(i) {
+  const e = i?.trim() ?? "", t = lt[e.toLowerCase()];
+  if (t != null)
+    return t;
+  if (e.includes("/"))
+    return e;
+  const s = [], r = [];
+  for (const n of e.split(/\s+/)) {
+    const o = /^([A-Za-z]+)\^?(-?\d+)?$/.exec(n);
+    if (!o)
+      return e.replace(/_/g, " ");
+    const a = dt[o[1]] ?? o[1], c = Number(o[2] ?? 1);
+    c < 0 ? r.push(a + de(-c)) : s.push(a + de(c));
+  }
+  return [s.join(" ") || "1", ...r].join("/");
+}
+const he = 20, ut = 600;
+function ft(i) {
+  const e = Math.max(0, Math.min(1, i));
+  return he * Math.pow(ut / he, e);
+}
+function Si(i) {
+  return Math.exp(-1 / ft(i));
+}
+const mt = 0.8, pt = 120, gt = 300;
+class Fi {
+  constructor(e) {
+    this.base = e, this.moving = !1, this.start = 0, this.duration = 0, this.from = e, this.to = e;
+  }
+  /** Configured opacity, applied at once unless the camera moves. */
+  setBase(e) {
+    this.base = e, this.moving || (this.from = e, this.to = e, this.duration = 0);
+  }
+  setMoving(e, t) {
+    e !== this.moving && (this.from = this.value(t), this.moving = e, this.to = e ? mt : this.base, this.start = t, this.duration = e ? pt : gt);
+  }
+  value(e) {
+    if (this.duration === 0)
+      return this.to;
+    const t = Math.min(1, Math.max(0, (e - this.start) / this.duration));
+    return t === 1 ? (this.duration = 0, this.from = this.to, this.to) : this.from + (this.to - this.from) * t * t * (3 - 2 * t);
+  }
+}
+var Et = `vec3 velocityValue(vec4 texel, vec2 minimum, vec2 maximum, float physical) {
+    if (physical > 0.5) return texel.xyz;
+    return vec3(mix(minimum, maximum, texel.rg), texel.a);
+}
+
+vec3 blendVelocity(vec3 a, vec3 b, float fraction) {
+    if (fraction <= 0.0) return a;
+    return mix(a, b, fraction);
+}`, Tt = `vec3 applyVibrance(vec3 c, float v) {
+    float mx = max(c.r, max(c.g, c.b));
+    float mn = min(c.r, min(c.g, c.b));
+    float boost = v * (1.0 - (mx - mn));
+    float luma = dot(c, vec3(0.299, 0.587, 0.114));
+    return mix(vec3(luma), c, 1.0 + boost);
+}
+
+vec3 gradeColor(vec3 c, vec4 g) {
+    float m = max(c.r, max(c.g, c.b));
+    if (m > 0.0) {
+        
+        
+        float e = g.x > 1e-3 ? (1.0 - exp(-g.x * m)) / (1.0 - exp(-g.x)) : m;
+        
+        e += g.w * smoothstep(0.5, 1.0, e) * (1.0 - e);
+        c *= e / m;
+    }
+    
+    c = mix(c, c * c * (3.0 - 2.0 * c), g.y);
+    return clamp(applyVibrance(c, g.z), 0.0, 1.0);
+}`, yt = `uniform vec2 u_code_range;       
+uniform vec2 u_value_range;      
+uniform float u_scalar_transfer; 
+
+float geoVideoScalarCode(float r) {
+    return clamp((r - u_code_range.x) / (u_code_range.y - u_code_range.x), 0.0, 1.0);
+}
+
+float geoVideoScalarValue(float r) {
+    float code = geoVideoScalarCode(r);
+    float t = mix(code, (pow(10.0, code) - 1.0) / 9.0, u_scalar_transfer);
+    return mix(u_value_range.x, u_value_range.y, t);
+}`, wt = `uint pcg(uint v) {
+    uint state = v * 747796405u + 2891336453u;
+    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+    return (word >> 22u) ^ word;
+}
+
+float random(uvec3 v) {
+    return float(pcg(v.x ^ pcg(v.y ^ pcg(v.z))) >> 8u) * (1.0 / 16777216.0);
+}`, bt = `vec3 applyVibrance(vec3 c, float v) {
+    float mx = max(c.r, max(c.g, c.b));
+    float mn = min(c.r, min(c.g, c.b));
+    float boost = v * (1.0 - (mx - mn));
+    float luma = dot(c, vec3(0.299, 0.587, 0.114));
+    return mix(vec3(luma), c, 1.0 + boost);
+}`, xt = `#define GLOW_SCALE 4
+
+vec4 glowGather(sampler2D trails, ivec2 texel) {
+    ivec2 last = textureSize(trails, 0) - 1;
+    ivec2 origin = texel * GLOW_SCALE;
+    vec4 sum = vec4(0.0);
+    for (int y = 0; y < GLOW_SCALE; y++) {
+        for (int x = 0; x < GLOW_SCALE; x++) {
+            vec4 c = texelFetch(trails, min(origin + ivec2(x, y), last), 0);
+            sum += vec4(c.rgb * c.a, c.a);
+        }
+    }
+    return sum / float(GLOW_SCALE * GLOW_SCALE);
+}
+
+vec4 addGlow(vec4 trail, sampler2D glowTex, vec2 uv, float gain) {
+    vec2 d = 1.0 / vec2(textureSize(glowTex, 0));
+    vec4 glow = 0.25 * (
+        texture(glowTex, uv + vec2(-d.x, -d.y)) +
+        texture(glowTex, uv + vec2(d.x, -d.y)) +
+        texture(glowTex, uv + vec2(-d.x, d.y)) +
+        texture(glowTex, uv + vec2(d.x, d.y)));
+    glow = min(glow * gain, vec4(1.0));
+    float under = 1.0 - trail.a;
+    float alpha = trail.a + glow.a * under;
+    vec3 rgb = (trail.rgb * trail.a + glow.rgb * under) / max(alpha, 1e-4);
+    return vec4(rgb, alpha);
+}`;
+const Ui = bt, Ni = Tt, Ci = wt, Di = yt, Ii = Et, Pi = xt, Li = 4, Gi = 1.2, ue = "x-zartigl-size", fe = "x-zartigl-stored-at", J = "x-zartigl-revision";
+function _t(i, e, t, s) {
+  const r = i.indexOf("time");
+  if (r < 0 || !e[r] || !t[r])
+    return "";
+  const n = Math.floor((e[r] - 1) / t[r]);
+  return s[r] === n ? `t=${e[r]}` : "";
+}
+function Vi(i = "zartigl-chunks-v1") {
+  const e = typeof caches > "u" ? void 0 : caches;
+  if (!e)
+    return {
+      get: async () => {
+      },
+      put: async () => {
+      },
+      entries: async () => [],
+      delete: async () => {
+      },
+      estimate: async () => {
+      }
+    };
+  let t = null;
+  const s = () => t ??= e.open(i);
+  let r = !1;
+  const n = () => {
+    !r && typeof navigator < "u" && (r = !0, navigator.storage?.persist?.().catch(() => !1));
+  };
+  return {
+    async get(o, a = "") {
+      try {
+        const c = await (await s()).match(o);
+        return !c || (c.headers.get(J) ?? "") !== a ? void 0 : new Uint8Array(await c.arrayBuffer());
+      } catch {
+        return;
+      }
+    },
+    async put(o, a, c = "") {
+      n();
+      try {
+        const l = new Uint8Array(a);
+        await (await s()).put(
+          o,
+          new Response(l, {
+            headers: {
+              "content-type": "application/octet-stream",
+              [ue]: String(l.byteLength),
+              [fe]: String(Date.now()),
+              [J]: c
+            }
+          })
+        );
+      } catch {
+      }
+    },
+    async entries(o = "") {
+      try {
+        const a = await s(), c = [];
+        for (const l of await a.keys()) {
+          if (!l.url.startsWith(o))
+            continue;
+          const d = await a.match(l);
+          d && c.push({
+            url: l.url,
+            size: Number(d.headers.get(ue) ?? 0),
+            storedAt: Number(d.headers.get(fe) ?? 0),
+            revision: d.headers.get(J) ?? ""
+          });
+        }
+        return c;
+      } catch {
+        return [];
+      }
+    },
+    async delete(o) {
+      try {
+        const a = await s();
+        await Promise.all(Array.from(o, (c) => a.delete(c)));
+      } catch {
+      }
+    },
+    async estimate() {
+      try {
+        const o = await navigator.storage?.estimate?.();
+        return o ? { usage: o.usage ?? 0, quota: o.quota ?? 0 } : void 0;
+      } catch {
+        return;
+      }
+    }
+  };
+}
+const ee = [
+  "depth",
+  "elevation",
+  "level",
+  "altitude",
+  "pressure_level"
+];
+class me extends Error {
+  constructor(e, t) {
+    super(`Chunk fetch failed: ${e} ${t}`), this.name = "ZarrChunkFetchError", this.status = e, this.url = t;
+  }
+}
+class Oi {
+  /**
+   * `options.chunkStore` keeps the compressed chunks across sessions (see
+   * chunkStore.ts); without it, chunks are only kept in memory.
+   */
+  constructor(e, t = 200, s = {}) {
+    this.meta = null, this.coords = null, this.initPromise = null, this.verticalName = "depth", this.timeUnits = "", this.timeCalendar = "standard", this.cache = /* @__PURE__ */ new Map(), this.abortControllers = /* @__PURE__ */ new Map(), this.bloscCodecCache = /* @__PURE__ */ new Map(), this.root = e.replace(/\/$/, ""), this.maxCacheSize = t, this.chunkStore = s.chunkStore;
+  }
+  /** The URL of a chunk, as fetched and as stored. */
+  chunkUrl(e, t) {
+    return `${this.root}/${e}/${t.join(this.getDimensionSeparator(e))}`;
+  }
+  /** The revision a stored chunk must carry to be current (see chunkRevision). */
+  chunkRevision(e, t) {
+    return _t(
+      this.getDimensions(e),
+      this.getShape(e),
+      this.getChunkShape(e),
+      t
+    );
+  }
+  async init() {
+    if (!this.coords) {
+      if (this.initPromise)
+        return this.initPromise;
+      this.initPromise = (async () => {
+        const e = await fetch(`${this.root}/.zmetadata`);
+        if (!e.ok)
+          throw new Error(`Failed to fetch .zmetadata: ${e.status}`);
+        this.meta = await e.json(), await this.loadCoordinates();
+      })();
+      try {
+        await this.initPromise;
+      } catch (e) {
+        throw this.meta = null, this.coords = null, e;
+      } finally {
+        this.initPromise = null;
+      }
+    }
+  }
+  getArrayMeta(e) {
+    const t = `${e}/.zarray`, s = this.meta.metadata[t];
+    if (!s || !("dtype" in s))
+      throw new Error(`No .zarray for ${e}`);
+    return s;
+  }
+  getAttrs(e) {
+    const t = `${e}/.zattrs`;
+    return this.meta.metadata[t] ?? {};
+  }
+  getDimensionSeparator(e) {
+    return this.getArrayMeta(e).dimension_separator ?? ".";
+  }
+  getShape(e) {
+    return this.getArrayMeta(e).shape;
+  }
+  getChunkShape(e) {
+    return this.getArrayMeta(e).chunks;
+  }
+  getCoords() {
+    if (!this.coords)
+      throw new Error("Call init() first");
+    return this.coords;
+  }
+  getTimeDimension() {
+    const e = this.getCoords().time, t = e.length, s = Array.from(e, (a) => this.zarrTimeToMs(a));
+    let r = t ? s[0] : NaN, n = r;
+    for (let a = 1; a < s.length; a++)
+      r = Math.min(r, s[a]), n = Math.max(n, s[a]);
+    const o = At(s);
+    return {
+      min: r,
+      max: n,
+      step: o,
+      size: t,
+      units: this.timeUnits,
+      values: s
+    };
+  }
+  getVerticalDimension(e) {
+    if (!this.verticalName || e && !this.getDimensions(e).includes(this.verticalName))
+      return;
+    const t = this.getAttrs(this.verticalName), s = typeof t.units == "string" ? t.units : void 0, r = typeof t.standard_name == "string" ? t.standard_name : "", n = s?.toLowerCase() ?? "", o = r.includes("pressure") || this.verticalName.includes("pressure") || /(^|\s)(pa|hpa|bar|dbar)($|\s)/i.test(n) ? "pressure" : r.includes("elevation") || this.verticalName === "elevation" || t.positive === "up" ? "elevation" : "depth";
+    return {
+      name: this.verticalName,
+      label: o,
+      units: s,
+      values: Array.from(this.getCoords().vertical)
+    };
+  }
+  hasVariable(e) {
+    const t = this.meta?.metadata[`${e}/.zarray`];
+    return !!(t && "dtype" in t);
+  }
+  getVariableAttrs(e) {
+    if (!this.meta)
+      throw new Error("Call init() first");
+    if (!this.hasVariable(e))
+      throw new Error(`No .zarray for ${e}`);
+    return { ...this.getAttrs(e) };
+  }
+  getDimensions(e) {
+    return this.getAttrs(e)._ARRAY_DIMENSIONS ?? ["time", "latitude", "longitude"];
+  }
+  findNearestIndex(e, t) {
+    let s = 0, r = Math.abs(e[0] - t);
+    for (let n = 1; n < e.length; n++) {
+      const o = Math.abs(e[n] - t);
+      o < r && (r = o, s = n);
+    }
+    return s;
+  }
+  findTimeIndex(e) {
+    const t = this.getCoords();
+    let s;
+    return typeof e == "string" ? s = new Date(e).getTime() : s = e, this.findNearestIndex(t.time, this.msToZarrTime(s));
+  }
+  /**
+   * Convert a Unix-ms timestamp to the native time units used by this zarr
+   * (read from the time variable's .zattrs "units" field).
+   * Unsupported units are rejected during initialization rather than guessed.
+   */
+  msToZarrTime(e) {
+    const { refMs: t, multiplier: s } = this.parseTimeEncoding();
+    return (e - t) / s;
+  }
+  zarrTimeToMs(e) {
+    const { refMs: t, multiplier: s } = this.parseTimeEncoding();
+    return t + e * s;
+  }
+  parseTimeEncoding() {
+    const e = this.timeCalendar.toLowerCase();
+    if (!["standard", "gregorian", "proleptic_gregorian"].includes(e))
+      throw new Error(`Unsupported Zarr time calendar: ${this.timeCalendar}`);
+    const t = this.timeUnits.match(
+      /^(milliseconds?|seconds?|minutes?|hours?|days?)\s+since\s+(.+)$/i
+    );
+    if (!t)
+      throw new Error(
+        `Unsupported Zarr time units: ${this.timeUnits || "<missing>"}`
+      );
+    const s = vt(t[2]);
+    if (!Number.isFinite(s))
+      throw new Error(`Invalid Zarr time epoch: ${t[2]}`);
+    const r = t[1].toLowerCase(), n = r.startsWith("ms") || r.startsWith("milli") ? 1 : r.startsWith("s") ? 1e3 : r.startsWith("min") ? 6e4 : r.startsWith("h") ? 36e5 : 864e5;
+    return { refMs: s, multiplier: n };
+  }
+  findNearestLongitudeIndex(e) {
+    const t = this.getCoords().longitude, s = t[0], r = t[t.length - 1];
+    let n = e;
+    return s >= 0 && r > 180 ? n = (e % 360 + 360) % 360 : n = ((e + 180) % 360 + 360) % 360 - 180, this.findNearestIndex(t, n);
+  }
+  async sampleVariableAt(e, t) {
+    const s = this.getDimensions(e), r = this.getChunkShape(e), n = this.getShape(e), o = new Array(s.length).fill(0), a = new Array(s.length).fill(0);
+    for (let d = 0; d < s.length; d++) {
+      const h = s[d];
+      let f = 0;
+      h === "time" ? f = t.timeIdx : h === "latitude" ? f = t.latIdx : h === "longitude" ? f = t.lonIdx : (h === this.verticalName || ee.includes(h)) && (f = t.depthIdx), f = Math.max(0, Math.min(n[d] - 1, f)), o[d] = Math.floor(f / r[d]), a[d] = f - o[d] * r[d];
+    }
+    let c;
+    try {
+      c = await this.fetchChunk(e, o);
+    } catch (d) {
+      if (d instanceof me && (d.status === 403 || d.status === 404))
+        return NaN;
+      throw d;
+    }
+    const l = this.getFlatOffset(e, a);
+    return l < c.length ? c[l] : NaN;
+  }
+  getFlatOffset(e, t) {
+    const s = this.getArrayMeta(e), r = s.chunks;
+    if (s.order === "F") {
+      let o = 0, a = 1;
+      for (let c = 0; c < t.length; c++)
+        o += t[c] * a, a *= r[c];
+      return o;
+    }
+    let n = 0;
+    for (let o = 0; o < t.length; o++)
+      n = n * r[o] + t[o];
+    return n;
+  }
+  findDepthIndex(e) {
+    return this.findNearestIndex(this.getCoords().vertical, e);
+  }
+  async sampleTimeSeries(e) {
+    await this.init();
+    const t = this.getCoords(), s = this.findNearestLongitudeIndex(e.longitude), r = this.findNearestIndex(t.latitude, e.latitude), n = this.findDepthIndex(e.depth ?? 0), o = Math.max(0, e.timeStartIndex ?? 0), a = Math.min(
+      t.time.length - 1,
+      e.timeEndIndex ?? t.time.length - 1
+    ), c = Math.max(1, Math.floor(e.stride ?? 1)), l = Math.max(
+      0,
+      Math.floor(e.stopAfterMissingSamples ?? 0)
+    );
+    let d = 0;
+    const h = [];
+    for (let f = o; f <= a; f += c) {
+      const u = {};
+      for (const p of e.variables)
+        u[p] = await this.sampleVariableAt(p, {
+          timeIdx: f,
+          depthIdx: n,
+          latIdx: r,
+          lonIdx: s
+        });
+      const m = this.zarrTimeToMs(t.time[f]);
+      if (h.push({
+        axisValue: m,
+        time: m,
+        depth: t.vertical[n],
+        values: u
+      }), d = e.variables.every(
+        (p) => !Number.isFinite(u[p])
+      ) ? d + 1 : 0, l > 0 && d >= l)
+        break;
+    }
+    return {
+      longitude: t.longitude[s],
+      latitude: t.latitude[r],
+      depth: t.vertical[n],
+      points: h
+    };
+  }
+  async sampleVerticalProfile(e) {
+    await this.init();
+    const t = this.getCoords(), s = this.findNearestLongitudeIndex(e.longitude), r = this.findNearestIndex(t.latitude, e.latitude), n = this.findTimeIndex(e.time), o = Math.max(
+      0,
+      Math.floor(e.stopAfterMissingSamples ?? 0)
+    );
+    let a = 0;
+    const c = [];
+    let l = Array.from(
+      { length: t.vertical.length },
+      (f, u) => u
+    ).sort(
+      (f, u) => Math.abs(t.vertical[f]) - Math.abs(t.vertical[u])
+    );
+    const d = Math.max(
+      1,
+      Math.floor(e.maxDepths ?? l.length)
+    ), h = Math.max(
+      1,
+      Math.floor(e.stride ?? Math.ceil(l.length / d))
+    );
+    l = l.filter((f, u) => u % h === 0).slice(0, d);
+    for (const f of l) {
+      const u = {};
+      for (const p of e.variables)
+        u[p] = await this.sampleVariableAt(p, {
+          timeIdx: n,
+          depthIdx: f,
+          latIdx: r,
+          lonIdx: s
+        });
+      const m = t.vertical[f];
+      if (c.push({
+        axisValue: m,
+        time: this.zarrTimeToMs(t.time[n]),
+        depth: m,
+        values: u
+      }), a = e.variables.every(
+        (p) => !Number.isFinite(u[p])
+      ) ? a + 1 : 0, o > 0 && a >= o)
+        break;
+    }
+    return {
+      longitude: t.longitude[s],
+      latitude: t.latitude[r],
+      time: this.zarrTimeToMs(t.time[n]),
+      points: c
+    };
+  }
+  /** Return the actual name of the vertical dimension ("depth" or "elevation"). */
+  getVerticalDimName() {
+    return this.verticalName;
+  }
+  /**
+   * Get chunk indices that intersect a geographic bounding box.
+   */
+  getChunksForBounds(e, t, s, r) {
+    const n = this.getCoords(), o = this.getChunkShape(e), a = this.getDimensions(e), c = a.indexOf("latitude"), l = a.indexOf("longitude"), d = o[c], h = o[l], f = n.latitude, u = n.longitude, m = this.findNearestIndex(f, r.north), T = this.findNearestIndex(f, r.south), p = this.findNearestIndex(u, r.west), y = this.findNearestIndex(u, r.east), k = Math.min(m, T), C = Math.max(m, T), U = Math.min(p, y), b = Math.max(p, y), x = Math.floor(k / d), A = Math.floor(C / d), M = Math.floor(U / h), v = Math.floor(b / h), N = this.getShape(e), O = N[c], Z = N[l], B = [];
+    for (let D = x; D <= A; D++)
+      for (let P = M; P <= v; P++) {
+        const E = D * d, g = P * h, I = Math.min(d, O - E), _ = Math.min(h, Z - g);
+        B.push({
+          timeIdx: t,
+          depthIdx: s,
+          latIdx: D,
+          lonIdx: P,
+          latRange: [f[E], f[E + I - 1]],
+          lonRange: [u[g], u[g + _ - 1]],
+          latSize: I,
+          lonSize: _
+        });
+      }
+    return B;
+  }
+  async fetchChunk(e, t) {
+    return (await this.fetchChunkResult(e, t)).data;
+  }
+  /**
+   * Fetch one latitude/longitude chunk and extract the requested time/vertical
+   * plane from it. Logical coordinate indices are converted to physical Zarr
+   * chunk indices before fetching.
+   */
+  async fetchSpatialChunkResult(e, t) {
+    const s = this.getDimensions(e), r = this.getChunkShape(e), n = s.indexOf("latitude"), o = s.indexOf("longitude");
+    if (n < 0 || o < 0)
+      throw new Error(
+        `Variable ${e} must have latitude and longitude dimensions`
+      );
+    const a = new Array(s.length).fill(0), c = new Array(s.length).fill(0);
+    for (let u = 0; u < s.length; u++) {
+      const m = s[u];
+      let T = 0;
+      if (m === "time")
+        T = t.timeIndex;
+      else if (m === this.verticalName || ee.includes(m))
+        T = t.verticalIndex;
+      else if (m === "latitude") {
+        a[u] = t.latitudeChunkIndex;
+        continue;
+      } else if (m === "longitude") {
+        a[u] = t.longitudeChunkIndex;
+        continue;
+      }
+      a[u] = Math.floor(T / r[u]), c[u] = T % r[u];
+    }
+    const l = await this.fetchChunkResult(e, a), d = r[n], h = r[o], f = new Float32Array(d * h);
+    f.fill(NaN);
+    for (let u = 0; u < d; u++) {
+      c[n] = u;
+      for (let m = 0; m < h; m++) {
+        c[o] = m;
+        const T = this.getFlatOffset(e, c);
+        T < l.data.length && (f[u * h + m] = l.data[T]);
+      }
+    }
+    return { ...l, data: f };
+  }
+  async fetchChunkResult(e, t) {
+    const s = this.getDimensionSeparator(e), r = t.join(s), n = `${e}/${r}`, o = `${this.root}/${e}/${r}`;
+    if (this.cache.has(n))
+      return { data: this.cache.get(n), missing: !1, url: o };
+    this.abortControllers.get(n)?.abort();
+    const a = new AbortController();
+    this.abortControllers.set(n, a);
+    const c = this.getArrayMeta(e), l = this.chunkStore ? this.chunkRevision(e, t) : "";
+    try {
+      const d = await this.chunkStore?.get(o, l);
+      if (d) {
+        const m = pe(
+          await this.decompress(d, c, e)
+        );
+        return this.cacheChunk(n, m), { data: m, missing: !1, url: o };
+      }
+      const h = await fetch(o, { signal: a.signal });
+      if (!h.ok) {
+        if (h.status === 403 || h.status === 404)
+          return {
+            data: Rt(c),
+            missing: !0,
+            status: h.status,
+            url: o
+          };
+        throw new me(h.status, o);
+      }
+      const f = new Uint8Array(await h.arrayBuffer());
+      this.chunkStore?.put(o, f, l);
+      const u = pe(
+        await this.decompress(f, c, e)
+      );
+      return this.cacheChunk(n, u), { data: u, missing: !1, url: o };
+    } finally {
+      this.abortControllers.get(n) === a && this.abortControllers.delete(n);
+    }
+  }
+  cancelAll() {
+    for (const e of this.abortControllers.values())
+      e.abort();
+    this.abortControllers.clear();
+  }
+  cacheChunk(e, t) {
+    if (this.cache.size >= this.maxCacheSize) {
+      const s = this.cache.keys().next().value;
+      s !== void 0 && this.cache.delete(s);
+    }
+    this.cache.set(e, t);
+  }
+  getBloscCodec(e) {
+    const t = e.compressor, s = `${t.cname ?? "lz4"}-${t.clevel ?? 5}-${t.shuffle ?? 1}-${t.blocksize ?? 0}`;
+    let r = this.bloscCodecCache.get(s);
+    return r || (r = Me.fromConfig({
+      id: "blosc",
+      cname: t.cname ?? "lz4",
+      clevel: t.clevel ?? 5,
+      shuffle: t.shuffle ?? 1,
+      blocksize: t.blocksize ?? 0
+    }), this.bloscCodecCache.set(s, r)), r;
+  }
+  async decompress(e, t, s) {
+    let r;
+    if (t.compressor)
+      switch (t.compressor.id) {
+        case "zlib":
+        case "gzip":
+          r = Ae(e);
+          break;
+        case "blosc": {
+          r = await this.getBloscCodec(t).decode(e);
+          break;
+        }
+        default:
+          throw new Error(`Unsupported compressor: ${t.compressor.id}`);
+      }
+    else
+      r = e;
+    let n;
+    const o = t.dtype;
+    if (o === "<f4" || o === "|f4")
+      n = new Float32Array(
+        r.buffer,
+        r.byteOffset,
+        r.byteLength / 4
+      );
+    else if (o === "<f8" || o === "|f8")
+      n = new Float64Array(
+        r.buffer,
+        r.byteOffset,
+        r.byteLength / 8
+      );
+    else if (o === "<i2" || o === "|i2") {
+      const c = new Int16Array(
+        r.buffer,
+        r.byteOffset,
+        r.byteLength / 2
+      );
+      n = Float32Array.from(c);
+    } else if (o === "<i4" || o === "|i4") {
+      const c = new Int32Array(
+        r.buffer,
+        r.byteOffset,
+        r.byteLength / 4
+      );
+      n = Float32Array.from(c);
+    } else if (o === "<i8" || o === "|i8") {
+      const c = new DataView(
+        r.buffer,
+        r.byteOffset,
+        r.byteLength
+      ), l = r.byteLength / 8;
+      n = new Float64Array(l);
+      for (let d = 0; d < l; d++)
+        n[d] = Number(c.getBigInt64(d * 8, !0));
+    } else
+      throw new Error(`Unsupported dtype: ${o}`);
+    const a = t.fill_value;
+    if (a != null && typeof a == "number" && !isNaN(a))
+      for (let c = 0; c < n.length; c++)
+        n[c] === a && (n[c] = NaN);
+    if (s) {
+      const c = this.getAttrs(s), l = c.scale_factor, d = c.add_offset;
+      if (l != null || d != null) {
+        const h = l ?? 1, f = d ?? 0;
+        for (let u = 0; u < n.length; u++)
+          isNaN(n[u]) || (n[u] = n[u] * h + f);
+      }
+    }
+    return n;
+  }
+  async loadCoordinates() {
+    const e = async (c) => {
+      const l = this.getArrayMeta(c), d = l.shape[0], h = Math.ceil(d / l.chunks[0]), f = [];
+      for (let p = 0; p < h; p++) {
+        const y = `${this.root}/${c}/${p}`, k = await fetch(y);
+        if (!k.ok)
+          throw new Error(`Failed to fetch coord ${c}/${p}`);
+        const C = new Uint8Array(await k.arrayBuffer());
+        f.push(await this.decompress(C, l));
+      }
+      if (f.length === 1)
+        return f[0].length > d ? f[0].subarray(0, d) : f[0];
+      const u = f.some((p) => p instanceof Float64Array) ? Float64Array : Float32Array, m = new u(d);
+      let T = 0;
+      for (const p of f) {
+        const y = Math.min(p.length, d - T);
+        if (m.set(p.subarray(0, y), T), T += y, T >= d)
+          break;
+      }
+      return m;
+    };
+    let t = null;
+    for (const c of ee) {
+      const l = `${c}/.zarray`;
+      if (this.meta.metadata[l] && "dtype" in this.meta.metadata[l]) {
+        t = c;
+        break;
+      }
+    }
+    this.verticalName = t ?? "";
+    const s = this.getAttrs("time");
+    this.timeUnits = s.units ?? "", this.timeCalendar = s.calendar ?? "standard", this.parseTimeEncoding();
+    const [r, n, o] = await Promise.all([
+      e("time"),
+      e("latitude"),
+      e("longitude")
+    ]);
+    let a;
+    t ? a = await e(t) : a = new Float32Array([0]), this.coords = {
+      time: r,
+      vertical: a,
+      latitude: n,
+      longitude: o
+    };
+  }
+}
+function pe(i) {
+  return i instanceof Float32Array ? i : Float32Array.from(i);
+}
+function Rt(i) {
+  const e = i.chunks.reduce((s, r) => s * r, 1), t = new Float32Array(e);
+  return t.fill(NaN), t;
+}
+function vt(i) {
+  const t = i.trim().replace(/\s+\([^)]*\)\s*$/, "").match(
+    /^(\d{4})-(\d{2})-(\d{2})(?:(?:T|\s+)(\d{2})(?::(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?)?)?(?:\s*(Z|[+-]\d{2}:?\d{2}))?$/i
+  );
+  if (!t)
+    return NaN;
+  const s = Number(t[1]), r = Number(t[2]), n = Number(t[3]), o = Number(t[4] ?? 0), a = Number(t[5] ?? 0), c = Number(t[6] ?? 0), l = Number((t[7] ?? "").padEnd(3, "0").slice(0, 3)), d = t[8] ?? "Z";
+  if (r < 1 || r > 12 || o > 23 || a > 59 || c > 59)
+    return NaN;
+  const h = /* @__PURE__ */ new Date(0);
+  h.setUTCFullYear(s, r - 1, n), h.setUTCHours(o, a, c, l);
+  const f = h.getTime();
+  if (h.getUTCFullYear() !== s || h.getUTCMonth() !== r - 1 || h.getUTCDate() !== n || h.getUTCHours() !== o || h.getUTCMinutes() !== a || h.getUTCSeconds() !== c || h.getUTCMilliseconds() !== l)
+    return NaN;
+  if (/^z$/i.test(d))
+    return f;
+  const u = d.match(/^([+-])(\d{2}):?(\d{2})$/);
+  if (!u)
+    return NaN;
+  const m = Number(u[2]), T = Number(u[3]);
+  if (m > 23 || T > 59)
+    return NaN;
+  const p = (m * 60 + T) * 6e4;
+  return f - (u[1] === "+" ? p : -p);
+}
+function kt(i) {
+  if (typeof i != "number" || !Number.isFinite(i) || i <= 0)
+    return i;
+  const e = [
+    60 * 1e3,
+    180 * 1e3,
+    300 * 1e3,
+    600 * 1e3,
+    900 * 1e3,
+    1800 * 1e3,
+    3600 * 1e3,
+    10800 * 1e3,
+    360 * 60 * 1e3,
+    720 * 60 * 1e3,
+    1440 * 60 * 1e3,
+    10080 * 60 * 1e3
+  ];
+  for (const t of e)
+    if (Math.abs(i - t) <= Math.max(1e3, t * 0.02))
+      return t;
+  return Math.round(i);
+}
+function At(i) {
+  if (i.length < 2)
+    return;
+  const e = i[1] - i[0];
+  if (!Number.isFinite(e) || e <= 0)
+    return;
+  const t = Math.max(1, Math.abs(e) * 1e-9);
+  for (let s = 2; s < i.length; s++)
+    if (Math.abs(i[s] - i[s - 1] - e) > t)
+      return;
+  return kt(e);
+}
+function Bi(i) {
+  if (i == null)
+    return null;
+  if (!Number.isFinite(i[0]) || !Number.isFinite(i[1]) || i[0] >= i[1])
+    throw new RangeError(
+      "colorDomain must contain two finite, increasing values"
+    );
+  return [i[0], i[1]];
+}
+function S(i, e) {
+  if (typeof i != "number" || !Number.isFinite(i))
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  return i;
+}
+function q(i, e) {
+  if (typeof i != "string")
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  const t = new Date(i).getTime();
+  if (!Number.isFinite(t))
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  return t;
+}
+function te(i) {
+  return typeof i == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(
+    i
+  );
+}
+function ge(i) {
+  if (!i || typeof i != "object")
+    throw new Error("Invalid GeoVideo manifest");
+  const e = i;
+  if (e.schemaVersion !== 3 || e.type !== "geovideo")
+    throw new Error("Unsupported GeoVideo manifest version or type");
+  if (e.projection !== "equirectangular")
+    throw new Error(
+      `Unsupported GeoVideo projection: ${String(e.projection)}`
+    );
+  if (!Array.isArray(e.bounds) || e.bounds.length !== 4)
+    throw new Error("Invalid GeoVideo manifest bounds");
+  const [t, s, r, n] = e.bounds.map(
+    (u, m) => S(u, `bounds[${m}]`)
+  );
+  if (s < -90 || n > 90 || s >= n || t === r)
+    throw new Error("Invalid GeoVideo geographic bounds");
+  const o = e.media;
+  if (!o || typeof o.url != "string" || !o.url)
+    throw new Error("Invalid GeoVideo media");
+  for (const u of ["width", "height", "fps", "durationSeconds"])
+    if (S(o[u], `media.${u}`) <= 0)
+      throw new Error(`Invalid GeoVideo media.${u}`);
+  const a = e.encoding;
+  if (!a || a.bits !== 8 || a.colorSpace !== "bt709" || a.colorRange !== "limited" && a.colorRange !== "full")
+    throw new Error("Invalid GeoVideo encoding");
+  const c = S(a.codeMin, "encoding.codeMin"), l = S(a.codeMax, "encoding.codeMax");
+  if (c < 0 || l > 255 || c >= l)
+    throw new Error("Invalid GeoVideo code range");
+  let d = o.height;
+  if (a.kind === "scalar-luma") {
+    if (a.transfer !== "linear" && a.transfer !== "log10-1p9" || S(a.valueMin, "encoding.valueMin") >= S(a.valueMax, "encoding.valueMax"))
+      throw new Error("Invalid GeoVideo scalar-luma encoding");
+  } else if (a.kind === "vector-luma") {
+    if (a.transfer !== "linear" && a.transfer !== "sqrt" || a.layout !== "stacked-uv" || S(a.valueDomain, "encoding.valueDomain") <= 0 || o.height % 2 !== 0)
+      throw new Error("Invalid GeoVideo vector-luma encoding");
+    d = o.height / 2;
+  } else
+    throw new Error("Unsupported GeoVideo encoding");
+  const h = e.mask;
+  if (!h || h.kind !== "static-validity" || typeof h.url != "string" || !h.url || S(h.width, "mask.width") !== o.width || S(h.height, "mask.height") !== d || S(h.threshold, "mask.threshold") < 0 || h.threshold > 1)
+    throw new Error("Invalid GeoVideo static mask");
+  if (e.timeline?.kind === "range") {
+    const u = q(e.timeline.dateStart, "timeline.dateStart");
+    if (q(e.timeline.dateEnd, "timeline.dateEnd") <= u)
+      throw new Error("GeoVideo timeline end must follow start");
+    if (e.timeline.interpolation !== "linear" && e.timeline.interpolation !== "nearest")
+      throw new Error("Invalid GeoVideo interpolation");
+  } else if (e.timeline?.kind === "snapshot-loop")
+    q(e.timeline.date, "timeline.date");
+  else if (e.timeline?.kind === "sample-sequence") {
+    if (!Array.isArray(e.timeline.values) || e.timeline.values.length === 0)
+      throw new Error("GeoVideo sample sequence must contain values");
+    const u = e.timeline.values.map(
+      (m, T) => q(m, `timeline.values[${T}]`)
+    );
+    if (u.some((m, T) => T > 0 && m <= u[T - 1]))
+      throw new Error(
+        "GeoVideo sample sequence values must be strictly increasing"
+      );
+  } else
+    throw new Error("Invalid GeoVideo timeline");
+  const f = e.style?.colorDomain;
+  if (!Array.isArray(f) || f.length !== 2 || !f.every(Number.isFinite) || f[0] >= f[1])
+    throw new Error("Invalid GeoVideo color domain");
+  if (!te(e.id) || !e.provenance || !te(e.provenance.catalogEntryId) || !te(e.provenance.inputSourceId) || !Array.isArray(e.provenance.variables) || e.provenance.variables.length === 0)
+    throw new Error("Invalid GeoVideo provenance");
+  return { ...e, bounds: [t, s, r, n] };
+}
+async function Mt(i, e) {
+  if (typeof i != "string")
+    return ge(i);
+  const t = await fetch(i, { signal: e });
+  if (!t.ok)
+    throw new Error(
+      `GeoVideo manifest request failed (${t.status}): ${i}`
+    );
+  const s = await t.json(), r = ge(s), n = typeof document < "u" ? new URL(i, document.baseURI).href : i;
+  return {
+    ...r,
+    media: { ...r.media, url: new URL(r.media.url, n).href },
+    mask: { ...r.mask, url: new URL(r.mask.url, n).href }
+  };
+}
+function L(i) {
+  if (i.timeline.kind === "snapshot-loop")
+    return [new Date(i.timeline.date).getTime()];
+  if (i.timeline.kind === "sample-sequence")
+    return i.timeline.values.map((r) => new Date(r).getTime());
+  const e = new Date(i.timeline.dateStart).getTime(), t = new Date(i.timeline.dateEnd).getTime(), s = Math.max(
+    2,
+    Math.round(i.media.durationSeconds * i.media.fps)
+  );
+  return Array.from(
+    { length: s },
+    (r, n) => e + (t - e) * n / (s - 1)
+  );
+}
+function be(i) {
+  return i.timeline.kind === "sample-sequence" ? i.timeline.values.length / i.media.durationSeconds : i.media.fps;
+}
+function $i(i, e) {
+  return e / be(i);
+}
+function St(i, e) {
+  if (i.timeline.kind === "snapshot-loop")
+    return 0;
+  if (i.timeline.kind === "sample-sequence") {
+    const n = L(i);
+    let o = 0;
+    for (let c = 1; c < n.length; c += 1)
+      Math.abs(n[c] - e) < Math.abs(n[o] - e) && (o = c);
+    const a = i.media.durationSeconds / n.length;
+    return o * a + Math.min(a / 2, 0.5 / i.media.fps);
+  }
+  const t = new Date(i.timeline.dateStart).getTime(), s = new Date(i.timeline.dateEnd).getTime();
+  return Math.max(0, Math.min(1, (e - t) / (s - t))) * xe(i);
+}
+function Xi(i, e) {
+  if (i.timeline.kind === "snapshot-loop")
+    return new Date(i.timeline.date).getTime();
+  if (i.timeline.kind === "sample-sequence") {
+    const o = L(i), a = i.media.durationSeconds / o.length, c = Math.floor((e + 0.25 / i.media.fps) / a);
+    return o[Math.max(0, Math.min(o.length - 1, c))];
+  }
+  const t = new Date(i.timeline.dateStart).getTime(), s = new Date(i.timeline.dateEnd).getTime(), r = xe(i), n = r > 0 ? Math.max(0, Math.min(1, e / r)) : 0;
+  return t + (s - t) * n;
+}
+function xe(i) {
+  return Math.max(0, i.media.durationSeconds - 1 / i.media.fps);
+}
+function Ft(i, e) {
+  const t = new Uint8Array(i.length / 4);
+  for (let s = 0; s < t.length; s++) {
+    const r = i[s * 4];
+    t[s] = e === "limited" ? Math.round(r * 219 / 255 + 16) : r;
+  }
+  return t;
+}
+class Ut {
+  constructor() {
+    this.gl = null, this.texture = null, this.framebuffer = null;
+  }
+  read(e, t, s) {
+    const r = this.context();
+    r.bindTexture(r.TEXTURE_2D, this.texture), r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL, !1), r.pixelStorei(r.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), r.pixelStorei(r.UNPACK_COLORSPACE_CONVERSION_WEBGL, r.NONE), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_MIN_FILTER, r.NEAREST), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_MAG_FILTER, r.NEAREST), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_S, r.CLAMP_TO_EDGE), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_T, r.CLAMP_TO_EDGE), r.texImage2D(r.TEXTURE_2D, 0, r.RGBA, r.RGBA, r.UNSIGNED_BYTE, e), r.bindFramebuffer(r.FRAMEBUFFER, this.framebuffer), r.framebufferTexture2D(
+      r.FRAMEBUFFER,
+      r.COLOR_ATTACHMENT0,
+      r.TEXTURE_2D,
+      this.texture,
+      0
+    );
+    const n = new Uint8Array(t * s * 4);
+    return r.readPixels(0, 0, t, s, r.RGBA, r.UNSIGNED_BYTE, n), r.bindFramebuffer(r.FRAMEBUFFER, null), n;
+  }
+  release() {
+    this.gl?.getExtension("WEBGL_lose_context")?.loseContext(), this.gl = null, this.texture = null, this.framebuffer = null;
+  }
+  context() {
+    if (this.gl)
+      return this.gl;
+    const e = document.createElement("canvas"), t = {
+      premultipliedAlpha: !1,
+      antialias: !1
+    }, s = e.getContext("webgl2", t);
+    if (!s)
+      throw new Error("WebGL2 is required to decode GeoVideo frames");
+    return this.gl = s, this.texture = s.createTexture(), this.framebuffer = s.createFramebuffer(), s;
+  }
+}
+function Ee(i) {
+  const e = Math.max(4, Math.floor(i.length / 4 / 997) * 4);
+  for (let t = 3; t < i.length; t += e)
+    if (i[t] !== 0)
+      return !1;
+  return !0;
+}
+function w() {
+  return new DOMException("GeoVideo frame request was cancelled", "AbortError");
+}
+function V(i, e, t) {
+  return e ? e.aborted ? (i.catch(() => {
+  }), t?.(), Promise.reject(w())) : new Promise((s, r) => {
+    const n = () => {
+      t?.(), r(w());
+    };
+    e.addEventListener("abort", n, { once: !0 }), i.then(s, r).finally(() => {
+      e.removeEventListener("abort", n);
+    });
+  }) : i;
+}
+function ie(i, e) {
+  return new Promise(
+    (t) => i.addEventListener(e, () => t(), { once: !0 })
+  );
+}
+const Nt = 250;
+function Ct(i) {
+  return "requestVideoFrameCallback" in i ? Promise.race([
+    new Promise(
+      (e) => i.requestVideoFrameCallback(() => e())
+    ),
+    new Promise((e) => setTimeout(e, Nt))
+  ]) : Promise.resolve();
+}
+class _e {
+  constructor(e, t, s = {}) {
+    this.reader = new Ut(), this.video = null, this.maskCodes = null, this.initPromise = null, this.presented = !1, this.primed = !1, this.queue = Promise.resolve(), this.frames = /* @__PURE__ */ new Map(), this.pending = /* @__PURE__ */ new Set(), this.manifest = e, this.planes = t, this.cacheSize = Math.max(1, s.cacheSize ?? 3), this.width = e.media.width, this.height = e.media.height / t, this.times = Float64Array.from(L(e));
+  }
+  /** Static validity, one 8-bit value per grid cell; null before init(). */
+  get mask() {
+    return this.maskCodes;
+  }
+  /** Luma codes of the presented frame, or null when it is blank. */
+  readCodes(e, t) {
+    const s = this.reader.read(e, this.width, t);
+    return Ee(s) ? null : Ft(s, this.manifest.encoding.colorRange);
+  }
+  /** True when the decoder exposed no pixels; reads back one row only. */
+  isBlank(e) {
+    return Ee(this.reader.read(e, this.width, 1));
+  }
+  init() {
+    return this.initPromise ??= this.load().catch((e) => {
+      throw this.initPromise = null, e;
+    }), this.initPromise;
+  }
+  /** Abort every pending frame decode; frames already decoded stay cached. */
+  cancelAll() {
+    for (const e of [...this.pending])
+      this.drop(e);
+  }
+  /** Release the video element and GL context; a later init() reloads them. */
+  release() {
+    this.cancelAll(), this.frames.clear(), this.video && (this.video.removeAttribute("src"), this.video.load()), this.video = null, this.maskCodes = null, this.presented = !1, this.primed = !1, this.initPromise = null, this.reader.release();
+  }
+  /**
+   * One decode per time step, cached and shared by concurrent requests.
+   * Aborting `request.signal` rejects this request with an AbortError; the
+   * decode goes on while another request waits for it.
+   */
+  frame(e, t = {}) {
+    const { signal: s } = t;
+    if (s?.aborted)
+      return Promise.reject(w());
+    let r = this.frames.get(e);
+    if (r ? (this.frames.delete(e), this.frames.set(e, r)) : r = this.enqueue(e), r.settled)
+      return r.promise;
+    const n = r;
+    return n.waiters++, V(n.promise, s, () => this.leave(n));
+  }
+  enqueue(e) {
+    const t = new AbortController(), s = this.queue.then(
+      () => t.signal.aborted ? Promise.reject(w()) : this.decode(e, t.signal)
+    );
+    this.queue = s.catch(() => {
+    });
+    const r = {
+      index: e,
+      controller: t,
+      promise: V(s, t.signal),
+      waiters: 0,
+      settled: !1
+    };
+    for (this.pending.add(r), r.promise.then(
+      () => {
+        r.settled = !0, this.pending.delete(r);
+      },
+      () => {
+        r.settled = !0, this.pending.delete(r), this.frames.get(e) === r && this.frames.delete(e);
+      }
+    ), this.frames.set(e, r); this.frames.size > this.cacheSize; )
+      this.frames.delete(this.frames.keys().next().value);
+    return r;
+  }
+  /** A request left; drop the decode when it was the last one waiting. */
+  leave(e) {
+    e.waiters--, e.waiters <= 0 && !e.settled && this.drop(e);
+  }
+  drop(e) {
+    e.controller.abort(), this.pending.delete(e), this.frames.get(e.index) === e && this.frames.delete(e.index);
+  }
+  async load() {
+    const [e] = await Promise.all([this.loadMask(), this.loadMedia()]);
+    this.maskCodes = e;
+  }
+  async loadMask() {
+    const { url: e, width: t, height: s } = this.manifest.mask, r = new Image();
+    r.crossOrigin = "anonymous", r.src = e;
+    try {
+      await r.decode();
+    } catch {
+      throw new Error(`Failed to load GeoVideo mask: ${e}`);
+    }
+    if (r.naturalWidth !== t || r.naturalHeight !== s)
+      throw new Error(
+        `GeoVideo mask dimensions ${r.naturalWidth}x${r.naturalHeight} do not match manifest ${t}x${s}`
+      );
+    const n = this.reader.read(r, t, s), o = new Uint8Array(t * s);
+    for (let a = 0; a < o.length; a++)
+      o[a] = n[a * 4];
+    return o;
+  }
+  /** Open the media; the default reads frames by seeking a video element. */
+  async loadMedia() {
+    const e = document.createElement("video");
+    if (e.crossOrigin = "anonymous", e.muted = !0, e.playsInline = !0, e.preload = "metadata", e.src = this.manifest.media.url, this.video = e, await new Promise((t, s) => {
+      e.addEventListener("loadedmetadata", () => t(), {
+        once: !0
+      }), e.addEventListener(
+        "error",
+        () => s(
+          new Error(
+            `Failed to load GeoVideo media: ${this.manifest.media.url}`
+          )
+        ),
+        { once: !0 }
+      );
+    }), e.videoWidth !== this.manifest.media.width || e.videoHeight !== this.manifest.media.height)
+      throw new Error(
+        `GeoVideo media dimensions ${e.videoWidth}x${e.videoHeight} do not match manifest ${this.manifest.media.width}x${this.manifest.media.height}`
+      );
+  }
+  /** Seek to a frame and wait until it is presented. */
+  async presentFrame(e, t) {
+    if (this.presented && Math.abs(e.currentTime - t) <= 1e-3 && !e.seeking)
+      return;
+    const s = Ct(e), r = ie(e, "seeked");
+    e.currentTime = t, await r, e.readyState < HTMLMediaElement.HAVE_CURRENT_DATA && await Promise.race([ie(e, "loadeddata"), ie(e, "canplay")]), await s, this.presented = !0;
+  }
+  /**
+   * Some mobile browsers expose no decoded pixels to WebGL until playback
+   * started once. A muted play/pause primes the decoder, only when needed:
+   * playback would otherwise buffer far beyond the requested frame.
+   */
+  async primeDecoder(e) {
+    this.primed = !0;
+    try {
+      await e.play();
+    } catch {
+    }
+    e.pause(), this.presented = !1;
+  }
+  /** Media time inside the video frame showing step `index`. */
+  stepSeconds(e) {
+    return this.manifest.timeline.kind === "snapshot-loop" ? e / this.manifest.media.fps : St(this.manifest, this.times[e]);
+  }
+  /**
+   * Seek and capture one step. `signal` aborts it between steps; a seek
+   * already started completes first, keeping the queue serial.
+   */
+  async decode(e, t) {
+    if (t.aborted)
+      throw w();
+    await this.init();
+    const s = this.video, r = this.maskCodes;
+    if (t.aborted || !s || !r)
+      throw w();
+    const n = this.stepSeconds(e);
+    if (await this.presentFrame(s, n), t.aborted || s !== this.video)
+      throw w();
+    const o = this.height * this.planes;
+    let a = await this.capture(s, o, r);
+    if (a === null && !this.primed) {
+      if (await this.primeDecoder(s), await this.presentFrame(s, n), t.aborted || s !== this.video)
+        throw w();
+      a = await this.capture(s, o, r);
+    }
+    if (a === null)
+      throw new Error("GeoVideo frame could not be read back from the decoder");
+    return a;
+  }
+}
+function Dt(i) {
+  return {
+    codeRange: [i.codeMin / 255, i.codeMax / 255],
+    valueRange: [i.valueMin, i.valueMax],
+    transfer: i.transfer === "log10-1p9" ? 1 : 0
+  };
+}
+class It extends _e {
+  constructor(e, t = {}) {
+    if (e.encoding.kind !== "scalar-luma")
+      throw new Error("GeoVideoScalarSource requires a scalar-luma manifest");
+    super(e, 1, t);
+  }
+  async capture(e) {
+    return this.isBlank(e) ? null : createImageBitmap(e, {
+      premultiplyAlpha: "none",
+      colorSpaceConversion: "none"
+    });
+  }
+}
+function F(i, e) {
+  if (e <= i[0])
+    return { index: 0, fraction: 0 };
+  const t = i.length - 1;
+  if (e >= i[t])
+    return { index: t, fraction: 0 };
+  let s = 0, r = t;
+  for (; r - s > 1; ) {
+    const n = s + r >> 1;
+    i[n] <= e ? s = n : r = n;
+  }
+  return { index: s, fraction: (e - i[s]) / (i[r] - i[s]) };
+}
+function se(i, e) {
+  const { index: t, fraction: s } = F(i, e);
+  return t + s;
+}
+function Pt(i, e) {
+  const t = Math.max(0, Math.min(i.length - 1, Math.floor(e))), s = Math.min(t + 1, i.length - 1);
+  return i[t] + (i[s] - i[t]) * Math.max(0, e - t);
+}
+function j(i, e, t) {
+  const s = [];
+  let r = e;
+  for (; r + 8 <= t; ) {
+    let n = i.getUint32(r);
+    const o = String.fromCharCode(
+      i.getUint8(r + 4),
+      i.getUint8(r + 5),
+      i.getUint8(r + 6),
+      i.getUint8(r + 7)
+    );
+    let a = 8;
+    if (n === 1 ? (n = Number(i.getBigUint64(r + 8)), a = 16) : n === 0 && (n = t - r), n < a || r + n > t)
+      throw new Error(`Malformed MP4 box ${o}`);
+    s.push({ type: o, start: r + a, end: r + n }), r += n;
+  }
+  return s;
+}
+function R(i, e, t) {
+  const s = j(i, e.start, e.end).find(
+    (r) => r.type === t
+  );
+  if (!s)
+    throw new Error(`MP4 box ${t} not found in ${e.type}`);
+  return s;
+}
+function z(i, e, t) {
+  return j(i, e.start, e.end).find((s) => s.type === t) ?? null;
+}
+function G(i, e) {
+  return { at: e.start + 8, count: i.getUint32(e.start + 4) };
+}
+function Lt(i, e, t) {
+  const s = z(i, e, "edts"), r = s && z(i, s, "elst");
+  if (!r)
+    return;
+  const { at: n, count: o } = G(i, r), a = i.getUint8(r.start) === 1 ? Number(i.getBigInt64(n + 8)) : i.getInt32(n + 4);
+  if (o !== 1 || a !== t)
+    throw new Error("Unsupported MP4 edit list");
+}
+function Gt(i) {
+  const e = new DataView(i), t = { type: "file", start: 0, end: i.byteLength }, s = R(e, t, "moov"), r = j(e, s.start, s.end).find((E) => {
+    if (E.type !== "trak")
+      return !1;
+    const g = R(e, R(e, E, "mdia"), "hdlr");
+    return String.fromCharCode(...new Uint8Array(i, g.start + 8, 4)) === "vide";
+  });
+  if (!r)
+    throw new Error("MP4 has no video track");
+  const n = R(
+    e,
+    R(e, R(e, r, "mdia"), "minf"),
+    "stbl"
+  ), o = R(e, n, "stsd"), [a] = j(e, o.start + 8, o.end);
+  if (!a || a.type !== "avc1" && a.type !== "avc3")
+    throw new Error(`Unsupported MP4 sample entry ${a?.type}`);
+  const c = e.getUint16(a.start + 24), l = e.getUint16(a.start + 26), d = R(e, { ...a, start: a.start + 78 }, "avcC"), h = new Uint8Array(i.slice(d.start, d.end)), f = (E) => h[E].toString(16).padStart(2, "0"), u = `avc1.${f(1)}${f(2)}${f(3)}`, m = R(e, n, "stsz"), T = e.getUint32(m.start + 4), p = e.getUint32(m.start + 8), y = Array.from(
+    { length: p },
+    (E, g) => T || e.getUint32(m.start + 12 + g * 4)
+  ), k = z(e, n, "co64"), C = k ?? R(e, n, "stco"), U = G(e, C), b = Array.from(
+    { length: U.count },
+    (E, g) => k ? Number(e.getBigUint64(U.at + g * 8)) : e.getUint32(U.at + g * 4)
+  ), x = G(e, R(e, n, "stsc")), A = [];
+  for (let E = 0; E < x.count; E++) {
+    const g = x.at + E * 12, I = e.getUint32(g) - 1, _ = e.getUint32(g + 4), Q = E + 1 < x.count ? e.getUint32(g + 12) - 1 : b.length;
+    for (let $ = I; $ < Q; $++) {
+      let X = b[$];
+      for (let ae = 0; ae < _ && A.length < p; ae++)
+        A.push(X), X += y[A.length - 1];
+    }
+  }
+  const M = G(e, R(e, n, "stts")), v = [];
+  let N = 0;
+  for (let E = 0; E < M.count; E++) {
+    const g = e.getUint32(M.at + E * 8), I = e.getUint32(M.at + E * 8 + 4);
+    for (let _ = 0; _ < g; _++)
+      v.push(N), N += I;
+  }
+  const O = z(e, n, "ctts");
+  if (O) {
+    const E = e.getUint8(O.start) === 1, g = G(e, O);
+    let I = 0;
+    for (let _ = 0; _ < g.count; _++) {
+      const Q = e.getUint32(g.at + _ * 8), $ = E ? e.getInt32(g.at + _ * 8 + 4) : e.getUint32(g.at + _ * 8 + 4);
+      for (let X = 0; X < Q; X++)
+        v[I++] += $;
+    }
+  }
+  Lt(e, r, Math.min(...v.slice(0, p)));
+  const Z = v.slice(0, p).map((E, g) => [E, g]).sort((E, g) => E[0] - g[0]), B = new Array(p);
+  Z.forEach(([, E], g) => B[E] = g);
+  const D = z(e, n, "stss"), P = /* @__PURE__ */ new Set();
+  if (D) {
+    const E = G(e, D);
+    for (let g = 0; g < E.count; g++)
+      P.add(e.getUint32(E.at + g * 4) - 1);
+  }
+  if (A.length !== p || v.length < p)
+    throw new Error("Inconsistent MP4 sample tables");
+  return {
+    codec: u,
+    description: h,
+    width: c,
+    height: l,
+    samples: y.map((E, g) => ({
+      offset: A[g],
+      size: E,
+      frame: B[g],
+      key: D ? P.has(g) : !0
+    }))
+  };
+}
+const Vt = 50;
+class Ot extends It {
+  constructor() {
+    super(...arguments), this.track = null, this.data = null, this.sampleOfFrame = [], this.decoder = null, this.fed = -1, this.taken = -1, this.outputs = /* @__PURE__ */ new Map(), this.progress = null, this.failure = null, this.loading = null;
+  }
+  /** True once the media decodes through WebCodecs. */
+  get usesWebCodecs() {
+    return this.track !== null;
+  }
+  async loadMedia() {
+    if (typeof VideoDecoder > "u" || typeof fetch > "u")
+      return super.loadMedia();
+    const e = new AbortController();
+    this.loading = e;
+    const t = await fetch(this.manifest.media.url, {
+      signal: e.signal
+    });
+    if (!t.ok)
+      throw new Error(
+        `Failed to load GeoVideo media: ${this.manifest.media.url}`
+      );
+    const s = await t.arrayBuffer();
+    let r;
+    try {
+      r = Gt(s);
+    } catch {
+      return this.loading === e ? super.loadMedia() : void 0;
+    }
+    if (r.width !== this.manifest.media.width || r.height !== this.manifest.media.height)
+      throw new Error(
+        `GeoVideo media dimensions ${r.width}x${r.height} do not match manifest ${this.manifest.media.width}x${this.manifest.media.height}`
+      );
+    const { supported: n } = await VideoDecoder.isConfigSupported(
+      this.config(r)
+    ).catch(() => ({ supported: !1 }));
+    if (this.loading !== e)
+      throw w();
+    if (this.loading = null, !n)
+      return super.loadMedia();
+    this.sampleOfFrame = [], r.samples.forEach(
+      (o, a) => this.sampleOfFrame[o.frame] = a
+    ), this.data = s, this.track = r;
+  }
+  release() {
+    this.loading?.abort(), this.loading = null, this.closeDecoder(), this.track = null, this.data = null, super.release();
+  }
+  async decode(e, t) {
+    if (await this.init(), !this.track)
+      return super.decode(e, t);
+    if (t.aborted)
+      throw w();
+    const s = Math.min(
+      this.track.samples.length - 1,
+      Math.floor(this.stepSeconds(e) * this.manifest.media.fps + 1e-6)
+    ), r = await this.decodeFrame(s, t);
+    try {
+      return await createImageBitmap(r, {
+        premultiplyAlpha: "none",
+        colorSpaceConversion: "none"
+      });
+    } finally {
+      r.close();
+    }
+  }
+  config(e) {
+    return {
+      codec: e.codec,
+      description: e.description,
+      codedWidth: e.width,
+      codedHeight: e.height,
+      optimizeForLatency: !0
+    };
+  }
+  /** Video frame `frame`, owned by the caller. */
+  async decodeFrame(e, t) {
+    const s = this.track, r = this.sampleOfFrame[e], n = this.keySample(r);
+    for ((this.fed < 0 || e <= this.taken || n > this.fed) && this.restart(n), this.taken = e - 1, this.dropOutputsBefore(e); !this.outputs.has(e); ) {
+      if (this.failure)
+        throw this.failure;
+      if (t.aborted)
+        throw w();
+      const a = this.decoder;
+      this.fed < s.samples.length && a.decodeQueueSize < 2 && (this.feed(this.fed++), this.fed === s.samples.length && a.flush().catch(() => {
+      })), await this.waitProgress();
+    }
+    const o = this.outputs.get(e);
+    return this.outputs.delete(e), this.taken = e, o;
+  }
+  dropOutputsBefore(e) {
+    for (const [t, s] of this.outputs)
+      t < e && (s.close(), this.outputs.delete(t));
+  }
+  keySample(e) {
+    const { samples: t } = this.track;
+    let s = e;
+    for (; s > 0 && !t[s].key; )
+      s--;
+    return s;
+  }
+  restart(e) {
+    this.closeDecoder(), this.failure = null;
+    const t = new VideoDecoder({
+      output: (s) => {
+        this.decoder !== t || s.timestamp <= this.taken ? s.close() : this.outputs.set(s.timestamp, s), this.notify();
+      },
+      error: (s) => {
+        this.decoder === t && (this.failure = s, this.fed = -1), this.notify();
+      }
+    });
+    t.addEventListener("dequeue", () => this.notify()), t.configure(this.config(this.track)), this.decoder = t, this.fed = e, this.taken = this.track.samples[e].frame - 1;
+  }
+  feed(e) {
+    const t = this.track.samples[e];
+    this.decoder.decode(
+      new EncodedVideoChunk({
+        type: t.key ? "key" : "delta",
+        // Video frame numbers: outputs carry them back in display order.
+        timestamp: t.frame,
+        data: new Uint8Array(this.data, t.offset, t.size)
+      })
+    );
+  }
+  /** Next output, dequeue or error; a timer for decoders without events. */
+  waitProgress() {
+    return new Promise((e) => {
+      const t = setTimeout(s, Vt);
+      function s() {
+        clearTimeout(t), e();
+      }
+      this.progress = s;
+    });
+  }
+  notify() {
+    const e = this.progress;
+    this.progress = null, e?.();
+  }
+  closeDecoder() {
+    this.decoder && this.decoder.state !== "closed" && this.decoder.close(), this.decoder = null, this.fed = -1;
+    for (const e of this.outputs.values())
+      e.close();
+    this.outputs.clear();
+  }
+}
+function Bt(i, e) {
+  let t = (i - e.codeMin) / (e.codeMax - e.codeMin) * 2 - 1;
+  return t = Math.max(-1, Math.min(1, t)), e.transfer === "sqrt" && (t = Math.sign(t) * t * t), t * e.valueDomain;
+}
+function $t(i, e, t, s) {
+  const r = e.length;
+  if (i.length !== 2 * r)
+    throw new Error(
+      `GeoVideo vector frame has ${i.length} codes, expected ${2 * r}`
+    );
+  const n = new Float32Array(256);
+  for (let l = 0; l < 256; l++)
+    n[l] = Bt(l, s);
+  const o = t * 255, a = new Float32Array(r), c = new Float32Array(r);
+  for (let l = 0; l < r; l++) {
+    const d = e[l] >= o;
+    a[l] = d ? n[i[l]] : NaN, c[l] = d ? n[i[r + l]] : NaN;
+  }
+  return { u: a, v: c };
+}
+class Xt extends _e {
+  constructor(e, t = {}) {
+    if (e.encoding.kind !== "vector-luma")
+      throw new Error("GeoVideoVectorSource requires a vector-luma manifest");
+    super(e, 2, t), this.encoding = e.encoding;
+    const [s, r, n, o] = e.bounds, a = (n - s) / this.width, c = (o - r) / this.height;
+    this.coords = {
+      time: this.times,
+      vertical: new Float32Array([0]),
+      latitude: Float32Array.from(
+        { length: this.height },
+        (l, d) => o - (d + 0.5) * c
+      ),
+      longitude: Float32Array.from(
+        { length: this.width },
+        (l, d) => s + (d + 0.5) * a
+      )
+    };
+  }
+  getValueDomain() {
+    return this.encoding.valueDomain;
+  }
+  getCoords() {
+    return this.coords;
+  }
+  getDimensions() {
+    return ["time", "latitude", "longitude"];
+  }
+  getChunkShape() {
+    return [1, this.height, this.width];
+  }
+  findDepthIndex() {
+    return 0;
+  }
+  findTimeIndex(e) {
+    const t = typeof e == "number" ? e : new Date(e).getTime(), s = this.coords.time;
+    let r = 0;
+    for (let n = 1; n < s.length; n++)
+      Math.abs(s[n] - t) < Math.abs(s[r] - t) && (r = n);
+    return r;
+  }
+  getChunksForBounds(e, t, s) {
+    const { latitude: r, longitude: n } = this.coords;
+    return [
+      {
+        timeIdx: t,
+        depthIdx: s,
+        latIdx: 0,
+        lonIdx: 0,
+        latRange: [r[0], r[this.height - 1]],
+        lonRange: [n[0], n[this.width - 1]],
+        latSize: this.height,
+        lonSize: this.width
+      }
+    ];
+  }
+  async fetchSpatialChunkResult(e, t) {
+    const s = await this.frame(t.timeIndex);
+    return {
+      data: e === "v" ? s.v : s.u,
+      missing: !1,
+      url: this.manifest.media.url
+    };
+  }
+  /** u/v codes are written into luma: read back, then decoded on the CPU. */
+  async capture(e, t, s) {
+    const r = this.readCodes(e, t);
+    return r ? $t(
+      r,
+      s,
+      this.manifest.mask.threshold,
+      this.encoding
+    ) : null;
+  }
+}
+function zt(i, e, t = {}) {
+  const [s, r] = t.range ?? [-1 / 0, 1 / 0], n = [...i].sort((a, c) => a.start - c.start), o = n.find(
+    (a) => a.start > e && a.start <= r
+  ) ?? (t.loop ? n.find(
+    (a) => a.end >= s && a.start <= r
+  ) : void 0);
+  return o ? { chunk: o, time: Math.max(o.start, s) } : null;
+}
+function qt(i, e) {
+  let t = null, s = -1 / 0;
+  for (const r of e) {
+    const n = Math.min(i.end, r.end) - Math.max(i.start, r.start);
+    Number.isFinite(n) && n >= 0 && n > s && (t = r, s = n);
+  }
+  return t;
+}
+function Wt(i) {
+  return {
+    width: i.mask.width,
+    height: i.mask.height,
+    bounds: i.bounds,
+    rowOrder: "north-to-south"
+  };
+}
+function Re(i, e = {}) {
+  return i.encoding.kind === "vector-luma" ? new Xt(i, e) : new Ot(i, e);
+}
+const Ht = 3, Yt = 3, jt = 0.6, Kt = 1.5;
+function Zt(i) {
+  const e = new AbortController();
+  if (!i)
+    return { controller: e, unlink: () => {
+    } };
+  const t = () => e.abort();
+  return i.aborted && t(), i.addEventListener("abort", t, { once: !0 }), {
+    controller: e,
+    unlink: () => i.removeEventListener("abort", t)
+  };
+}
+class zi {
+  constructor(e) {
+    this.manifests = /* @__PURE__ */ new Map(), this.open = /* @__PURE__ */ new Map(), this.id = e.id, this.chunks = e.chunks.filter(
+      (t) => Number.isFinite(t.start) && Number.isFinite(t.end) && t.end >= t.start
+    ).sort((t, s) => t.start - s.start), this.maxOpenChunks = Math.max(2, e.maxOpenChunks ?? Ht), this.frameCacheSize = Math.max(
+      1,
+      e.frameCacheSize ?? Yt
+    ), this.prefetchAt = e.prefetchAt ?? jt, this.maxGap = e.maxGap, this.loadManifest = e.loadManifest ?? Mt, this.createFrameSource = e.createFrameSource ?? ((t, s) => Re(
+      t,
+      s
+    ));
+  }
+  /** First and last sample of the archive, or null without chunks. */
+  get range() {
+    const { chunks: e } = this;
+    return e.length ? [e[0].start, Math.max(...e.map((t) => t.end))] : null;
+  }
+  /** The chunk whose sample range holds `time`, or null. */
+  chunkAt(e) {
+    const t = this.chunkIndexAt(e), s = t >= 0 ? this.chunks[t] : null;
+    return s && e <= s.end ? s : null;
+  }
+  /** Every step time of the archive; loads all chunk manifests. */
+  async steps(e = {}) {
+    if (e.signal?.aborted)
+      throw w();
+    const t = await V(
+      Promise.all(this.chunks.map((s) => this.manifest(s))),
+      e.signal
+    );
+    return Float64Array.from(t.flatMap(L));
+  }
+  /**
+   * The frames bracketing `time`, decoded; null out of coverage (before the
+   * first step, after the last, or in a gap wider than `maxGap`).
+   */
+  async sample(e, t = {}) {
+    const { signal: s } = t, r = t.mode ?? "interpolate";
+    if (s?.aborted)
+      throw w();
+    const n = this.chunkIndexAt(e);
+    if (n < 0)
+      return null;
+    const o = [], { controller: a, unlink: c } = Zt(s);
+    try {
+      const l = this.acquire(this.chunks[n], o), d = await V(l.ready, a.signal), { times: h } = d;
+      let f;
+      if (e <= h[h.length - 1]) {
+        const { index: b, fraction: x } = F(h, e);
+        f = r === "discrete" || x === 0 ? [l, b, l, b, 0] : [l, b, l, b + 1, x];
+      } else {
+        const b = this.chunks[n + 1];
+        if (!b)
+          return null;
+        const x = this.acquire(b, o), A = await V(x.ready, a.signal), M = h.length - 1, v = h[M], N = A.times[0];
+        if (N - v > this.gapLimit(h, A.times))
+          return null;
+        f = r === "discrete" ? [l, M, l, M, 0] : e >= N ? [x, 0, x, 0, 0] : [l, M, x, 0, (e - v) / (N - v)];
+      }
+      const [u, m, T, p, y] = f, k = u === T && m === p, C = [this.frame(u, m, a.signal)];
+      k || C.push(this.frame(T, p, a.signal));
+      let U;
+      try {
+        U = await Promise.all(C);
+      } catch (b) {
+        throw a.abort(), b;
+      }
+      return this.prefetchAfter(n, e), {
+        time: e,
+        a: U[0],
+        b: U[k ? 0 : 1],
+        mix: y
+      };
+    } finally {
+      c();
+      for (const l of o)
+        l.users--;
+      this.trim();
+    }
+  }
+  /** Open `chunk` and decode its first frame ahead of a request. */
+  prefetch(e) {
+    if (this.open.has(e.key))
+      return;
+    const t = this.touch(e), s = new AbortController();
+    t.prefetch = s, t.ready.then(({ source: r }) => r.frame(0, { signal: s.signal })).catch(() => {
+    }).finally(() => {
+      t.prefetch === s && (t.prefetch = null);
+    }), this.trim();
+  }
+  /** Release every open chunk source; later requests reopen them. */
+  release() {
+    for (const e of [...this.open.values()])
+      this.close(e);
+  }
+  chunkIndexAt(e) {
+    let t = 0, s = this.chunks.length - 1, r = -1;
+    for (; t <= s; ) {
+      const n = t + s >> 1;
+      this.chunks[n].start <= e ? (r = n, t = n + 1) : s = n - 1;
+    }
+    return r;
+  }
+  gapLimit(e, t) {
+    if (this.maxGap !== void 0)
+      return this.maxGap;
+    const s = [
+      e.length > 1 ? e[e.length - 1] - e[e.length - 2] : 0,
+      t.length > 1 ? t[1] - t[0] : 0
+    ], r = Math.max(...s);
+    return r > 0 ? r * Kt : -1 / 0;
+  }
+  prefetchAfter(e, t) {
+    const s = this.chunks[e], r = this.chunks[e + 1], n = s.end - s.start, o = n > 0 ? (t - s.start) / n : 1;
+    r && o > this.prefetchAt && this.prefetch(r);
+  }
+  manifest(e) {
+    let t = this.manifests.get(e.manifestUrl);
+    return t || (t = this.loadManifest(e.manifestUrl), this.manifests.set(e.manifestUrl, t), t.catch(() => {
+      this.manifests.get(e.manifestUrl) === t && this.manifests.delete(e.manifestUrl);
+    })), t;
+  }
+  /** The open chunk, pinned for a running sample listed in `used`. */
+  acquire(e, t) {
+    const s = this.touch(e);
+    return s.users++, t.push(s), s;
+  }
+  /** The open chunk, opened when needed, most recently used; not pinned. */
+  touch(e) {
+    let t = this.open.get(e.key);
+    if (t)
+      this.open.delete(e.key);
+    else {
+      const s = {
+        chunk: e,
+        ready: null,
+        opened: null,
+        users: 0,
+        prefetch: null,
+        released: !1
+      };
+      s.ready = this.manifest(e).then((r) => {
+        if (s.released)
+          throw w();
+        return s.opened = {
+          manifest: r,
+          times: Float64Array.from(L(r)),
+          grid: Wt(r),
+          source: this.createFrameSource(r, {
+            cacheSize: this.frameCacheSize
+          })
+        }, s.opened;
+      }), s.ready.catch(() => {
+        this.open.get(e.key) === s && this.open.delete(e.key);
+      }), t = s;
+    }
+    return this.open.set(e.key, t), t;
+  }
+  async frame(e, t, s) {
+    const { manifest: r, times: n, grid: o, source: a } = await V(
+      e.ready,
+      s
+    );
+    if (e.released)
+      throw w();
+    const c = await a.frame(t, { signal: s });
+    return {
+      key: `${this.id}/${e.chunk.key}/${t}`,
+      chunk: e.chunk,
+      step: t,
+      time: n[t],
+      data: c,
+      grid: o,
+      manifest: r
+    };
+  }
+  /** Release least recently used chunks beyond the bound, unless in use. */
+  trim() {
+    let e = this.open.size - this.maxOpenChunks;
+    for (const t of [...this.open.values()]) {
+      if (e <= 0)
+        return;
+      t.users === 0 && (this.close(t), e--);
+    }
+  }
+  close(e) {
+    e.released = !0, e.prefetch?.abort(), e.prefetch = null, e.opened?.source.release(), e.opened = null, this.open.get(e.chunk.key) === e && this.open.delete(e.chunk.key);
+  }
+}
+const Qt = {
+  a: "u_vel0",
+  b: "u_vel1",
+  mix: "u_vel_mix",
+  bounds: "u_bounds"
+}, Jt = {
+  a: "u_tint0",
+  b: "u_tint1",
+  mix: "u_tint_mix",
+  bounds: "u_tint_bounds"
+};
+function ei(i) {
+  const e = new Float32Array(i.u.length * 4);
+  for (let t = 0; t < i.u.length; t++) {
+    const s = i.u[t], r = i.v[t];
+    Number.isNaN(s) || Number.isNaN(r) || (e[t * 4] = s, e[t * 4 + 1] = r, e[t * 4 + 2] = 1);
+  }
+  return e;
+}
+class ti {
+  constructor(e, t, s = {}) {
+    this.gl = e, this.manifest = t, this.options = s, this.textures = /* @__PURE__ */ new Map(), this.pending = /* @__PURE__ */ new Map(), this.mask = null, this.pair = null, this.destroyed = !1, this.linearFilter = !0, this.uploadedFrames = 0, this.lastUploadDurationMs = 0, this.vector = t.encoding.kind === "vector-luma", this.source = Re(t, { cacheSize: 2 }), this.uniforms = this.vector ? Qt : Jt;
+    const r = L(t);
+    this.times = s.animateSnapshot && t.timeline.kind === "snapshot-loop" ? Array.from(
+      {
+        length: Math.max(
+          1,
+          Math.round(t.media.durationSeconds * t.media.fps)
+        )
+      },
+      (n, o) => r[0] + o * 1e3 / t.media.fps
+    ) : r, this.bounds = t.bounds;
+  }
+  get currentPair() {
+    return this.pair;
+  }
+  /** Fixed catalog color domain of a scalar field. */
+  get domain() {
+    return this.manifest.style.colorDomain;
+  }
+  /** Top of the color ramp and of the particle speed normalization. */
+  get maxSpeed() {
+    const { encoding: e, style: t } = this.manifest;
+    return e.kind === "vector-luma" ? e.valueDomain : t.colorDomain[1];
+  }
+  /** Resolves once the step at `ms` is uploaded. */
+  async prime(e) {
+    const { index: t } = F(this.times, e);
+    await this.request(t);
+  }
+  /** The uploaded texture of the step at `ms`, or null. */
+  texture(e) {
+    return this.textures.get(F(this.times, e).index) ?? null;
+  }
+  /** True once the frames interpolated at `ms` are uploaded. */
+  ready(e) {
+    const { index: t, fraction: s } = F(this.times, e);
+    return this.textures.has(t) && (s === 0 || this.textures.has(t + 1));
+  }
+  /**
+   * Latest wins while scrubbing: drop queued decodes outside the frames at
+   * `ms`, then request those first.
+   */
+  focus(e) {
+    const { index: t } = F(this.times, e), s = Math.min(t + 1, this.times.length - 1);
+    [...this.pending.keys()].some(
+      (n) => n !== t && n !== s
+    ) && (this.source.cancelAll(), this.pending.clear());
+    for (const n of [t, s])
+      this.request(n).catch(() => {
+      });
+  }
+  /**
+   * Bracketing textures and their mix, retaining the last complete pair
+   * while a requested frame decodes.
+   */
+  sample(e, t = !0) {
+    const { index: s, fraction: r } = F(this.times, e), n = Math.min(s + 1, this.times.length - 1);
+    [...this.pending.keys()].some((l) => l < s || l > n + 1) && (this.source.cancelAll(), this.pending.clear());
+    for (const l of [s, n, n + 1])
+      l < this.times.length && this.request(l).catch(() => {
+      });
+    const o = this.textures.get(s), a = this.textures.get(n), c = t ? r : 0;
+    return o && (c === 0 || a) && (this.pair = [o, c === 0 ? o : a, c]), this.evict(s), this.pair;
+  }
+  /** Switch spatial filtering without changing the decoded-step cache. */
+  setFilter(e) {
+    if (this.linearFilter === e)
+      return;
+    this.linearFilter = e;
+    const t = this.gl, s = t.getParameter(
+      t.TEXTURE_BINDING_2D
+    );
+    for (const r of this.textures.values())
+      t.bindTexture(t.TEXTURE_2D, r), t.texParameteri(
+        t.TEXTURE_2D,
+        t.TEXTURE_MIN_FILTER,
+        e ? t.LINEAR : t.NEAREST
+      ), t.texParameteri(
+        t.TEXTURE_2D,
+        t.TEXTURE_MAG_FILTER,
+        e ? t.LINEAR : t.NEAREST
+      );
+    t.bindTexture(t.TEXTURE_2D, s);
+  }
+  get maskTexture() {
+    return this.mask;
+  }
+  get cachedFrames() {
+    return this.textures.size;
+  }
+  bind(e, t, s = 0) {
+    if (!this.sample(t) || !this.pair)
+      return !1;
+    const r = this.uniforms;
+    if (e.texture(r.a, s, this.pair[0]), e.texture(r.b, s + 1, this.pair[1]), e.float(r.mix, this.pair[2]), e.vec4(r.bounds, this.bounds), this.mask && this.manifest.encoding.kind === "scalar-luma") {
+      const { codeRange: n, valueRange: o, transfer: a } = Dt(
+        this.manifest.encoding
+      );
+      e.texture("u_tint_mask", s + 2, this.mask), e.vec2("u_code_range", ...n), e.vec2("u_value_range", ...o), e.float("u_scalar_transfer", a);
+    }
+    return !0;
+  }
+  destroy() {
+    this.destroyed = !0, this.source.cancelAll(), this.source.release();
+    for (const e of this.textures.values())
+      this.gl.deleteTexture(e);
+    this.textures.clear(), this.gl.deleteTexture(this.mask), this.mask = null, this.pair = null;
+  }
+  request(e) {
+    if (this.textures.has(e))
+      return Promise.resolve();
+    const t = this.pending.get(e);
+    if (t)
+      return t;
+    const s = this.source.frame(e).then((r) => {
+      if (!this.destroyed && this.pending.get(e) === s && !this.textures.has(e)) {
+        const n = performance.now();
+        this.textures.set(e, this.uploadPreservingState(r)), this.uploadedFrames++, this.lastUploadDurationMs = performance.now() - n, this.options.onReady?.();
+      }
+    }).catch((r) => {
+      throw !this.destroyed && this.pending.get(e) === s && !(r instanceof Error && r.name === "AbortError") && this.options.onError?.(r), r;
+    }).finally(() => {
+      this.pending.get(e) === s && this.pending.delete(e);
+    });
+    return this.pending.set(e, s), s;
+  }
+  uploadPreservingState(e) {
+    const t = this.gl, s = t.getParameter(
+      t.TEXTURE_BINDING_2D
+    ), r = [
+      t.UNPACK_FLIP_Y_WEBGL,
+      t.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
+      t.UNPACK_COLORSPACE_CONVERSION_WEBGL,
+      t.UNPACK_ALIGNMENT
+    ], n = r.map((o) => t.getParameter(o));
+    try {
+      return this.upload(e);
+    } finally {
+      t.bindTexture(t.TEXTURE_2D, s), r.forEach((o, a) => t.pixelStorei(o, n[a]));
+    }
+  }
+  upload(e) {
+    const t = this.gl, { width: s, height: r } = this.source, n = this.gridTexture();
+    return this.vector ? t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.RGBA16F,
+      s,
+      r,
+      0,
+      t.RGBA,
+      t.FLOAT,
+      ei(e)
+    ) : (t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, !1), t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), t.pixelStorei(t.UNPACK_COLORSPACE_CONVERSION_WEBGL, t.NONE), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.RGBA8,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
+      e
+    ), this.mask ??= this.uploadMask()), t.bindTexture(t.TEXTURE_2D, null), n;
+  }
+  /** The source's mask, loaded with its first frame, as an R8 texture. */
+  uploadMask() {
+    const e = this.source.mask;
+    if (!e)
+      return null;
+    const t = this.gl, s = this.gridTexture();
+    return this.options.nearestMask && (t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST)), t.pixelStorei(t.UNPACK_ALIGNMENT, 1), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.R8,
+      this.source.width,
+      this.source.height,
+      0,
+      t.RED,
+      t.UNSIGNED_BYTE,
+      e
+    ), t.pixelStorei(t.UNPACK_ALIGNMENT, 4), s;
+  }
+  /** A bound, linearly filtered texture over the field grid. */
+  gridTexture() {
+    const e = this.gl, t = e.createTexture();
+    return e.bindTexture(e.TEXTURE_2D, t), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_WRAP_S,
+      this.options.repeatLongitude !== !1 && this.bounds[2] - this.bounds[0] >= 359 ? e.REPEAT : e.CLAMP_TO_EDGE
+    ), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_MIN_FILTER,
+      this.linearFilter ? e.LINEAR : e.NEAREST
+    ), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_MAG_FILTER,
+      this.linearFilter ? e.LINEAR : e.NEAREST
+    ), t;
+  }
+  /** Keep a small window around the playhead. */
+  evict(e) {
+    for (const [t, s] of this.textures) {
+      const r = this.pair && (this.pair[0] === s || this.pair[1] === s);
+      (t < e - 1 || t > e + 3) && !r && (this.gl.deleteTexture(s), this.textures.delete(t));
+    }
+  }
+}
+class ii {
+  constructor(e, t) {
+    this.onPlaying = t, this.time = 0, this.endFraction = 0, this.held = !1, this.playingValue = e;
+  }
+  /** Playhead, epoch ms. Assigning it also resets a terminal step's hold. */
+  get ms() {
+    return this.time;
+  }
+  set ms(e) {
+    this.time = e, this.endFraction = 0;
+  }
+  /** Progress through the final sample's held step, 0 elsewhere. */
+  get holdFraction() {
+    return this.endFraction;
+  }
+  get playing() {
+    return this.playingValue;
+  }
+  setPlaying(e) {
+    this.playingValue !== e && (this.playingValue = e, this.onPlaying(e));
+  }
+  /** Playing and not held. */
+  get advancing() {
+    return this.playingValue && !this.held;
+  }
+  /**
+   * Advance in step units, including irregular timelines. Returns true at a
+   * non-looping end. holdLastStep gives the final sample a full step's duration.
+   */
+  advance(e, t, s, r = [t[0], t[t.length - 1]], n = !1, o = !1) {
+    if (!this.advancing || !t.length)
+      return !1;
+    const a = se(t, r[0]), c = se(t, r[1]), l = c + (o ? 1 : 0);
+    let d = Math.max(a, se(t, this.ms) + this.endFraction) + Math.max(0, e) * s;
+    const h = o ? d >= l : d > l;
+    return h && n && l > a ? d = a + (d - a) % (l - a) : d = Math.min(l, d), this.time = Pt(t, Math.min(c, d)), this.endFraction = Math.max(0, d - c), h && !n;
+  }
+}
+function W(i) {
+  const e = L(i);
+  return [e[0], e[e.length - 1]];
+}
+function re(i, e) {
+  return e ? [Math.max(i[0], e[0]), Math.min(i[1], e[1])] : i;
+}
+function H([i, e], t) {
+  return Math.max(i, Math.min(e, t));
+}
+class qi {
+  constructor(e, t, s) {
+    this.repaint = t, this.emit = s, this.field = null, this.manifest = null, this.gl = null, this.pendingField = null, this.standby = null, this.awaitingNext = !1, this.timeRange = null, this.lastTick = null, this.lastStepTime = null, this.seekId = 0, this.seeking = !1, this.failed = !1, this.exactTime = 0, this.endEmitted = !1, this.destroyed = !1, this.resumePlayback = !1, this.playOnReady = e.autoplay ?? !0, this.loop = e.loop ?? !0, this.playbackRate = e.playbackRate ?? 1, this.stepsPerSecond = e.stepsPerSecond;
+    const r = typeof e.time == "string" ? Date.parse(e.time) : e.time;
+    this.requestedTime = r != null && Number.isFinite(r) ? r : null, this.requestedTimeRange = e.timeRange, this.clock = new ii(
+      !1,
+      (n) => this.emit("playbackChange", n)
+    );
+  }
+  async load(e, t) {
+    if (this.gl = e, this.manifest = t, this.timeRange = re(
+      W(t),
+      this.requestedTimeRange
+    ), this.timeRange[0] > this.timeRange[1])
+      throw new Error(
+        "GeoVideo time range does not overlap the manifest timeline"
+      );
+    this.pendingField = this.createField(t), await this.prepare(this.pendingField);
+  }
+  sample(e) {
+    if (this.tick(e), !this.field)
+      return null;
+    const t = this.pendingField || this.seeking ? this.field.currentPair : this.field.sample(
+      this.clock.advancing ? this.clock.ms : this.exactTime,
+      this.clock.advancing && !this.awaitingNext
+    );
+    return this.handoff(t) ?? t;
+  }
+  /**
+   * Through the final step of a chunk followed by a decoded one, the last
+   * frame blends into the next chunk's first, as steps do within a chunk:
+   * the chunk swap then lands on the frame already shown.
+   */
+  handoff(e) {
+    const t = this.clock.holdFraction, s = this.pendingField ?? this.standby?.field, r = this.pendingField ? this.requestedTime : this.standby?.time;
+    if (!e || t <= 0 || !s || r == null)
+      return null;
+    const n = s.texture(r);
+    return n ? [e[0], n, Math.min(1, t)] : null;
+  }
+  get time() {
+    return this.clock.ms;
+  }
+  get preloadedMediaUrl() {
+    return this.standby?.field.manifest.media.url;
+  }
+  setStepsPerSecond(e) {
+    if (!Number.isFinite(e) || e <= 0)
+      throw new Error("GeoVideo steps per second must be positive");
+    this.stepsPerSecond = e;
+  }
+  suspend() {
+    this.resumePlayback = this.isPlaying(), this.pause();
+  }
+  resume() {
+    this.resumePlayback && this.play(), this.resumePlayback = !1;
+  }
+  destroy() {
+    this.destroyed = !0, this.seekId++, this.pendingField?.destroy(), this.pendingField = null, this.discardStandby(), this.field?.destroy(), this.field = null, this.gl = null;
+  }
+  tick(e) {
+    if (!this.field || this.pendingField || this.seeking || this.awaitingNext || !this.clock.advancing) {
+      this.lastTick = null;
+      return;
+    }
+    const t = this.lastTick === null ? 0 : (e - this.lastTick) / 1e3;
+    this.lastTick = e;
+    const s = this.clock.advance(
+      t,
+      this.field.times,
+      this.stepsPerSecond ?? this.playbackRate * be(this.field.manifest),
+      this.playbackRange(this.field),
+      this.loop,
+      !0
+    ), { index: r } = F(this.field.times, this.clock.ms), n = this.field.manifest.timeline.kind === "snapshot-loop" ? this.field.times[0] : H(this.timeRange, this.field.times[r]);
+    n !== this.lastStepTime && (this.lastStepTime = n, this.emit("timeChange", n)), s ? this.reachEnd() : this.repaint();
+  }
+  setTime(e) {
+    const t = typeof e == "number" ? e : Date.parse(e);
+    if (!Number.isFinite(t))
+      return;
+    this.requestedTime = t, this.awaitingNext = !1;
+    const s = this.pendingField ?? this.field;
+    s && this.prepare(s).catch((r) => this.reportError(r));
+  }
+  /** Load the requested step first; stale seeks and swaps cannot replace it. */
+  async prepare(e, t) {
+    this.failed = !1;
+    const s = ++this.seekId, r = this.timeRange ?? W(e.manifest), n = t ?? H(r, this.requestedTime ?? r[0]), o = F(e.times, n), a = Math.min(
+      e.times.length - 1,
+      o.index + (o.fraction > 0.5 ? 1 : 0)
+    ), c = e.times[a];
+    this.seeking = !0, this.lastTick = null, e.focus(c);
+    try {
+      await e.prime(c);
+    } catch (d) {
+      if (s !== this.seekId)
+        return;
+      throw d;
+    }
+    if (s !== this.seekId || this.destroyed)
+      return;
+    const l = this.pendingField === e;
+    if (l && (this.field?.destroy(), this.field = e, this.pendingField = null, this.lastStepTime = null), this.exactTime = c, this.clock.ms = H(this.playbackRange(e), c), e.sample(c, !1), this.seeking = !1, this.endEmitted = !1, this.repaint(), l) {
+      const d = e.manifest;
+      if (this.emit("loaded", {
+        min: d.style.colorDomain[0],
+        max: d.style.colorDomain[1],
+        unit: d.style.unit ?? "",
+        time: new Date(this.clock.ms).toISOString()
+      }), this.emit("status", { phase: "ready", time: this.clock.ms }), this.playOnReady) {
+        this.playOnReady = !1;
+        const h = this.clock.playing;
+        await this.play(), h && this.emit("playbackChange", !0);
+      }
+    }
+  }
+  /** Keep the outgoing pair until the incoming chunk's requested step is ready. */
+  replaceManifest(e, t = {}) {
+    const s = this.replacementTimeRange(e, t);
+    if (!s || !this.gl)
+      return !1;
+    this.playOnReady ||= this.isPlaying(), this.pendingField?.destroy();
+    const r = this.standby;
+    return this.standby = null, r && r.field.manifest.media.url !== e.media.url && r.field.destroy(), this.pendingField = r?.field.manifest.media.url === e.media.url ? r.field : this.createField(e), this.awaitingNext = !1, this.manifest = e, this.requestedTimeRange = t.timeRange, this.timeRange = s, this.requestedTime = t.time ?? s[0], this.loop = t.loop ?? this.loop, this.playbackRate = t.playbackRate ?? this.playbackRate, this.stepsPerSecond = t.stepsPerSecond ?? this.stepsPerSecond, this.lastTick = null, this.prepare(this.pendingField).catch(
+      (n) => this.reportError(n)
+    ), !0;
+  }
+  /** Decode the next chunk ahead of its swap, including its static mask. */
+  preloadManifest(e, t = {}) {
+    const s = this.replacementTimeRange(e, t);
+    if (!s || !this.gl || e.media.url === this.manifest?.media.url)
+      return !1;
+    const r = H(s, t.time ?? s[0]);
+    this.standby?.field.manifest.media.url !== e.media.url && (this.discardStandby(), this.standby = { field: this.createField(e), time: r });
+    const n = this.standby;
+    return n.time = r, n.field.focus(r), n.field.prime(r).catch(() => {
+      this.standby === n && this.discardStandby();
+    }), !0;
+  }
+  discardStandby() {
+    this.standby?.field.destroy(), this.standby = null;
+  }
+  /** Clamped time range of a compatible replacement, else null. */
+  replacementTimeRange(e, t) {
+    const s = this.manifest;
+    if (!s || e.encoding.kind !== s.encoding.kind || e.media.width !== s.media.width || e.media.height !== s.media.height || e.mask.width !== s.mask.width || e.mask.height !== s.mask.height)
+      return null;
+    const r = re(
+      W(e),
+      t.timeRange
+    );
+    return r[0] <= r[1] ? r : null;
+  }
+  async play() {
+    if (!this.field || this.pendingField || this.awaitingNext) {
+      this.playOnReady = !0, this.clock.setPlaying(!0);
+      return;
+    }
+    this.failed && this.prepare(this.field, this.clock.ms).catch(
+      (s) => this.reportError(s)
+    );
+    const e = this.endEmitted;
+    this.endEmitted = !1;
+    const t = this.playbackRange(this.field);
+    e && this.setTime(t[0]), this.lastTick = null, this.clock.setPlaying(!0), this.repaint();
+  }
+  pause() {
+    const e = this.playOnReady && !this.clock.playing;
+    if (this.playOnReady = !1, this.awaitingNext = !1, this.clock.setPlaying(!1), this.field && !this.pendingField && !this.seeking && !this.endEmitted) {
+      const { index: t } = F(this.field.times, this.clock.ms);
+      this.prepare(this.field, this.field.times[t]).catch(
+        (s) => this.reportError(s)
+      );
+    }
+    e && this.emit("playbackChange", !1), this.lastTick = null, this.repaint();
+  }
+  isPlaying() {
+    return this.clock.playing || this.playOnReady;
+  }
+  reachEnd() {
+    this.endEmitted || (this.endEmitted = !0, this.exactTime = this.clock.ms, this.lastTick = null, this.standby ? (this.awaitingNext = !0, this.playOnReady = !0) : this.clock.setPlaying(!1), this.emit("playbackEnd"));
+  }
+  setLoop(e) {
+    this.loop = e;
+  }
+  setPlaybackRate(e) {
+    if (!Number.isFinite(e) || e <= 0)
+      throw new Error("GeoVideo playback rate must be positive");
+    this.playbackRate = e, this.stepsPerSecond = void 0;
+  }
+  setTimeRange(e) {
+    if (!Number.isFinite(e[0]) || !Number.isFinite(e[1]) || e[0] > e[1])
+      throw new Error("Invalid GeoVideo time range");
+    const t = re(
+      this.manifest ? W(this.manifest) : e,
+      e
+    );
+    if (t[0] > t[1])
+      throw new Error(
+        "GeoVideo time range does not overlap the manifest timeline"
+      );
+    this.requestedTimeRange = e, this.timeRange = t, this.setTime(
+      this.pendingField ? this.requestedTime ?? t[0] : this.clock.ms
+    );
+  }
+  playbackRange(e) {
+    return e.manifest.timeline.kind === "snapshot-loop" ? [e.times[0], e.times[e.times.length - 1]] : this.timeRange ?? [
+      e.times[0],
+      e.times[e.times.length - 1]
+    ];
+  }
+  createField(e) {
+    const t = new ti(this.gl, e, {
+      nearestMask: !0,
+      animateSnapshot: !0,
+      onError: (s) => {
+        this.field === t && !this.seeking && this.reportError(s);
+      },
+      onReady: () => this.repaint()
+    });
+    return t;
+  }
+  reportError(e) {
+    const t = e instanceof Error ? e : new Error(String(e));
+    t.name === "AbortError" || this.destroyed || (this.playOnReady = !1, this.awaitingNext = !1, this.failed = !0, this.seeking = !0, this.clock.setPlaying(!1), this.emit("status", { phase: "error", error: t }), this.emit("error", t));
+  }
+}
+function K(i) {
+  const { start: e, end: t } = i.temporal ?? {};
+  return {
+    source: i,
+    start: Date.parse(e ?? ""),
+    end: Date.parse(t ?? e ?? "")
+  };
+}
+function Wi(i, e, t = {}) {
+  const s = i.filter((n) => n.id === e.id && n.temporal?.start != null).map(K), r = zt(
+    s,
+    Date.parse(e.temporal?.end ?? ""),
+    t
+  );
+  return r ? { source: r.chunk.source, time: r.time } : null;
+}
+function Hi(i, e) {
+  return qt(K(i), e.map(K))?.source ?? null;
+}
+function Yi(i, e = {}) {
+  const t = e.start ?? -1 / 0, s = e.end ?? 1 / 0, r = i.map(K).filter((a) => a.end >= t && a.start <= s).sort((a, c) => a.start - c.start);
+  if (r.length === 0)
+    return;
+  if (e.time == null)
+    return r[r.length - 1].source;
+  const n = Math.min(s, Math.max(t, e.time)), o = (a) => n < a.start ? a.start - n : Math.max(0, n - a.end);
+  return r.reduce(
+    (a, c) => o(c) <= o(a) ? c : a
+  ).source;
+}
+const si = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+function ri(i) {
+  return i instanceof Date ? i.getTime() : typeof i == "number" ? i : new Date(i).getTime();
+}
+function Te(i, e) {
+  const t = ri(i);
+  if (!Number.isFinite(t))
+    throw new Error(`Invalid ${e}`);
+  return t;
+}
+function ve(i, e) {
+  const t = e.match(si);
+  if (!t)
+    throw new Error(`Invalid trailing time duration: ${e}`);
+  const s = t.slice(1).map((y) => Number(y ?? 0));
+  if (!s.some((y) => y > 0))
+    throw new Error("Trailing time duration must be positive");
+  const [r, n, o, a, c, l, d] = s, h = new Date(i), f = h.getUTCFullYear() * 12 + h.getUTCMonth() - r * 12 - n, u = Math.floor(f / 12), m = (f % 12 + 12) % 12, T = new Date(Date.UTC(u, m + 1, 0)).getUTCDate();
+  return Date.UTC(
+    u,
+    m,
+    Math.min(h.getUTCDate(), T),
+    h.getUTCHours(),
+    h.getUTCMinutes(),
+    h.getUTCSeconds(),
+    h.getUTCMilliseconds()
+  ) - (((o * 7 + a) * 24 + c) * 60 + l) * 6e4 - d * 1e3;
+}
+function ji(i, [e, t]) {
+  let s = e, r = t;
+  if (typeof i.trailing == "string" ? s = ve(t, i.trailing) : (i.start != null && (s = Te(i.start, "time range start")), i.end != null && (r = Te(i.end, "time range end"))), s > r)
+    throw new Error("Time range start must not follow its end");
+  return [Math.max(e, s), Math.min(t, r)];
+}
+const ni = (i) => typeof i == "object" && i !== null && !Array.isArray(i);
+function Ki(i, e) {
+  if (!ni(i))
+    throw new Error(`${e} must be an object`);
+  for (const n of Object.keys(i))
+    if (n !== "start" && n !== "end" && n !== "trailing")
+      throw new Error(`${e}.${n} is not a time range key`);
+  if (i.trailing !== void 0) {
+    if (i.start !== void 0 || i.end !== void 0)
+      throw new Error(`${e}.trailing excludes start and end`);
+    if (typeof i.trailing != "string")
+      throw new Error(`${e}.trailing must be an ISO 8601 duration`);
+    return ve(0, i.trailing), { trailing: i.trailing };
+  }
+  const t = (n) => {
+    const o = i[n];
+    if (o !== void 0) {
+      if (typeof o != "string" || !Number.isFinite(Date.parse(o)))
+        throw new Error(`${e}.${n} is not a date`);
+      return o;
+    }
+  }, s = t("start"), r = t("end");
+  if (s !== void 0 && r !== void 0 && Date.parse(s) > Date.parse(r))
+    throw new Error(`${e}.start must not follow its end`);
+  return {
+    ...s !== void 0 && { start: s },
+    ...r !== void 0 && { end: r }
+  };
+}
+function Zi(i, e) {
+  return !!i && !!e && i.name === e.name && i.units === e.units && i.positive === e.positive && i.value === e.value;
+}
+function Y(i) {
+  const e = i;
+  return !!e && typeof e.name == "string" && typeof e.units == "string" && typeof e.positive == "string" && Number.isFinite(e.value);
+}
+function ai(i) {
+  const e = i.depths;
+  if (e === void 0)
+    return i.surface === void 0 || Y(i.surface);
+  const t = i.surface ?? e?.[0];
+  if (!Array.isArray(e) || !Y(t))
+    return e?.length === 0;
+  const s = new Set(i.surface ? [t.value] : []);
+  return e.every((r) => {
+    const n = Y(r) && typeof r.indexUrl == "string" && r.name === t.name && r.units === t.units && r.positive === t.positive && !s.has(r.value);
+    return s.add(r.value), n;
+  });
+}
+function Qi(i) {
+  return i.type === "geovideo" && typeof i.indexUrl == "string";
+}
+function Ji(i, e) {
+  return i.id === e.id && (i.type !== "geovideo" || e.type !== "geovideo" || i.manifestUrl === e.manifestUrl);
+}
+function ne(i) {
+  return typeof i == "string" && Number.isFinite(Date.parse(i));
+}
+function oi(i) {
+  const e = i.times;
+  if (!Array.isArray(e) || e.length !== i.samples || e[0] !== i.start || e[e.length - 1] !== i.end)
+    return !1;
+  let t = -1 / 0;
+  for (const s of e) {
+    const r = ne(s) ? Date.parse(s) : NaN;
+    if (!(r > t))
+      return !1;
+    t = r;
+  }
+  return !0;
+}
+function ci(i) {
+  const e = i;
+  if (!e || e.schemaVersion !== 1 || e.type !== "geovideo-index" || !Array.isArray(e.chunks))
+    throw new Error("Unsupported GeoVideo index");
+  if (!ai(e) || e.vertical !== void 0 && !Y(e.vertical))
+    throw new Error("Invalid GeoVideo index levels");
+  for (const t of e.chunks)
+    if (!ne(t?.start) || !ne(t.end) || Date.parse(t.end) < Date.parse(t.start) || typeof t.manifestUrl != "string" || t.times !== void 0 && !oi(t))
+      throw new Error("Invalid GeoVideo index chunk");
+  return e;
+}
+async function es(i, e) {
+  const t = await fetch(i, { signal: e });
+  if (!t.ok)
+    throw new Error(
+      `GeoVideo index request failed (${t.status}): ${i}`
+    );
+  return ci(await t.json());
+}
+function ke(i) {
+  return typeof document < "u" ? new URL(i, document.baseURI).href : i;
+}
+function li(i, e) {
+  const t = ke(e);
+  return i.chunks.map((s) => ({
+    key: s.key,
+    manifestUrl: new URL(s.manifestUrl, t).href,
+    start: Date.parse(s.start),
+    end: Date.parse(s.end),
+    samples: s.samples,
+    ...s.times ? { times: s.times.map(Date.parse) } : {},
+    ...s.provisional ? { provisional: !0 } : {}
+  }));
+}
+function di(i, e, t) {
+  if (e.sourceId !== i.id || e.catalogEntryId !== t.id)
+    throw new Error(
+      `GeoVideo index identity does not match catalog entry/source: ${i.id}`
+    );
+}
+function ts(i, e, t) {
+  di(i, e, t);
+  const s = li(e, i.indexUrl);
+  return e.chunks.map(
+    (r, n) => ({
+      id: i.id,
+      type: "geovideo",
+      title: i.title,
+      provenance: i.provenance,
+      temporal: {
+        mode: "fixed",
+        cadence: i.temporal?.cadence,
+        start: r.start,
+        end: r.end
+      },
+      manifestUrl: s[n].manifestUrl
+    })
+  );
+}
+function is(i, e) {
+  return new URL(i.indexUrl, ke(e)).href;
+}
+export {
+  _i as $,
+  Dt as A,
+  L as B,
+  Ni as C,
+  fi as D,
+  Qi as E,
+  es as F,
+  Di as G,
+  Mt as H,
+  Wi as I,
+  zt as J,
+  Hi as K,
+  qt as L,
+  Ki as M,
+  rt as N,
+  Pt as O,
+  ve as P,
+  F as Q,
+  Ci as R,
+  ji as S,
+  Fi as T,
+  se as U,
+  Ii as V,
+  ci as W,
+  ge as X,
+  Bi as Y,
+  Oi as Z,
+  ei as _,
+  Gi as a,
+  ot as a0,
+  Ei as a1,
+  bi as a2,
+  Ti as a3,
+  wi as a4,
+  pi as a5,
+  yi as a6,
+  ki as a7,
+  Ai as a8,
+  gi as a9,
+  Ri as aa,
+  vi as ab,
+  St as ac,
+  Te as ad,
+  Zi as ae,
+  Ji as af,
+  $i as ag,
+  be as ah,
+  Yi as ai,
+  is as aj,
+  Xi as ak,
+  Pi as b,
+  Li as c,
+  zi as d,
+  ii as e,
+  Ot as f,
+  ti as g,
+  _e as h,
+  qi as i,
+  It as j,
+  Xt as k,
+  Ui as l,
+  Qe as m,
+  di as n,
+  Vi as o,
+  _t as p,
+  xi as q,
+  Re as r,
+  mi as s,
+  le as t,
+  ft as u,
+  Si as v,
+  Mi as w,
+  ts as x,
+  Wt as y,
+  li as z
+};