@fxi/zartigl 0.10.1 → 0.10.2

package/dist/geovideo-index-BqOLqzgA.js

@@ -0,0 +1,1839 @@
+const te = { label: "Thermal", tags: ["sequential", "temperature"], colors: ["#042333", "#2c3395", "#744796", "#b15f82", "#eb7958", "#fbb43d", "#e8fa5b"] }, ie = { label: "Haline", tags: ["sequential", "salinity"], colors: ["#2a186c", "#17568b", "#1a7e8f", "#22a785", "#55c666", "#aadc32", "#fde333"] }, re = { 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"] }, se = { label: "Deep", tags: ["sequential", "depth"], colors: ["#fdfecc", "#c8e59b", "#74c8a3", "#3194b0", "#2a5b8e", "#281a5e", "#0c0820"] }, ae = { label: "RdYlBu", tags: ["diverging"], colors: ["#3288bd", "#66c2a5", "#abdda4", "#e6f598", "#fee08b", "#fdae61", "#f46d43", "#d53e4f"] }, oe = { label: "Dense", tags: ["sequential"], colors: ["#e6f1f1", "#92c4ca", "#44929a", "#20627a", "#1a3c6a", "#211a50", "#0d0621"] }, ce = { label: "Algae", tags: ["sequential", "biology", "log"], colors: ["#d7f9d0", "#a2d595", "#64b463", "#129450", "#126e45", "#1a482f", "#122414"] }, de = { label: "Oxygen", tags: ["sequential", "biology", "hypoxia"], colors: ["#09060f", "#5b1028", "#d43d2f", "#f39b3d", "#f3e7b3", "#79cbd1", "#176b9c"] }, le = { label: "Matter", tags: ["sequential", "biology"], colors: ["#fdfecc", "#f2c98a", "#e07c4e", "#bc3754", "#8d1a6d", "#51156b", "#1c0c3f"] }, he = { label: "Viridis", tags: ["sequential", "perceptual"], colors: ["#440154", "#443983", "#31688e", "#21918c", "#35b779", "#90d743", "#fde725"] }, ue = { label: "Plasma", tags: ["sequential", "perceptual"], colors: ["#0d0887", "#5e01a6", "#9c179e", "#cc4778", "#ed7953", "#fdb42f", "#f0f921"] }, fe = { label: "Cyclic", tags: ["cyclic", "direction"], colors: ["#2e22ea", "#b541fb", "#fc93c0", "#f1ee35", "#77c80d", "#458776", "#2c24e9"] }, me = { label: "Tempo", tags: ["sequential"], colors: ["#fff6f4", "#c2d1b9", "#7db390", "#2a937f", "#156d73", "#1c455b", "#151d44"] }, Ee = { label: "Turbid", tags: ["sequential", "biology", "log"], colors: ["#e9f5a0", "#c8c86e", "#a09845", "#786031", "#533324", "#341423", "#150d17"] }, pe = { label: "Speed", tags: ["sequential", "velocity"], colors: ["#fcfea4", "#d5e429", "#94c63e", "#52a657", "#2d8169", "#1d5b6d", "#0d3361"] }, Te = { label: "Amp", tags: ["sequential"], colors: ["#f2f2f2", "#c0b8db", "#9180b6", "#6c4e9e", "#4e2e83", "#32185d", "#110a35"] }, be = { label: "Heat", tags: ["sequential"], colors: ["#fde725", "#fde725", "#f8961e", "#e63946", "#9d0208", "#3a0007"] }, Re = { label: "Balance", tags: ["diverging"], colors: ["#181c43", "#3066af", "#9bbcdd", "#f2f2f2", "#e07d53", "#b13626", "#2c0b0e"] }, ge = { label: "Delta", tags: ["diverging"], colors: ["#0e3f31", "#20877b", "#99d4c1", "#f2f2f2", "#a1b0d4", "#3c5b9e", "#0d1938"] }, we = { label: "Curl", tags: ["diverging"], colors: ["#152237", "#2471b3", "#8dbac4", "#f2f2f2", "#c79f84", "#a63827", "#270b17"] }, _e = { label: "Gray", tags: ["sequential"], colors: ["#000000", "#252525", "#4d4d4d", "#7a7a7a", "#a8a8a8", "#d4d4d4", "#ffffff"] }, K = {
+  thermal: te,
+  "thermal-alt": { label: "Thermal Alt", tags: ["sequential", "temperature"], colors: ["#176b9c", "#79cbd1", "#f3e7b3", "#f39b3d", "#d43d2f", "#5b1028", "#09060f"] },
+  haline: ie,
+  solar: re,
+  ice: ne,
+  deep: se,
+  rdylbu: ae,
+  dense: oe,
+  algae: ce,
+  oxygen: de,
+  matter: le,
+  viridis: he,
+  plasma: ue,
+  cyclic: fe,
+  tempo: me,
+  turbid: Ee,
+  speed: pe,
+  amp: Te,
+  heat: be,
+  "heat-alert": { label: "Heat Alert", tags: ["sequential", "alpha", "deprecated"], colors: ["#fde72500", "#fde725cc", "#f8961e", "#e63946", "#9d0208", "#3a0007"] },
+  balance: Re,
+  delta: ge,
+  curl: we,
+  "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: _e
+}, B = 64, ye = {
+  linear: (t) => t,
+  // Rises fast: values just inside the zone already show.
+  log: (t) => Math.log10(1 + 9 * t),
+  // Stays faint longer: codec noise at the end of the range stays hidden.
+  exp: (t) => (10 ** t - 1) / 9
+};
+function xe(t, e) {
+  const i = ye[e.curve ?? "linear"], r = e.low ?? 0, n = e.high ?? 0;
+  let s = 1;
+  return r > 0 && t < r && (s = Math.min(s, i(Math.max(t, 0) / r))), n > 0 && t > 1 - n && (s = Math.min(s, i(Math.max(1 - t, 0) / n))), s;
+}
+function Ae(t) {
+  let e = t.replace("#", "");
+  (e.length === 3 || e.length === 4) && (e = [...e].map((r) => r + r).join(""));
+  const i = (r) => parseInt(e.slice(r, r + 2), 16);
+  return [
+    i(0),
+    i(2),
+    i(4),
+    e.length === 8 ? i(6) : 255
+  ];
+}
+function ke([t, e, i, r]) {
+  return `#${[t, e, i, r].map(
+    (n) => Math.round(Math.min(255, Math.max(0, n))).toString(16).padStart(2, "0")
+  ).join("")}`;
+}
+function Fe(t, e) {
+  if (e <= t[0][0])
+    return t[0][1];
+  for (let i = 1; i < t.length; i++) {
+    const [r, n] = t[i];
+    if (e <= r) {
+      const [s, o] = t[i - 1], a = r === s ? 1 : (e - s) / (r - s);
+      return o.map((d, c) => d + (n[c] - d) * a);
+    }
+  }
+  return t[t.length - 1][1];
+}
+function ve(t, e) {
+  const i = Object.entries(t).map(
+    ([n, s]) => [Number(n), Ae(s)]
+  ).sort((n, s) => n[0] - s[0]), r = {};
+  for (let n = 0; n <= B; n++) {
+    const s = n / B, [o, a, d, c] = Fe(i, s);
+    r[s] = ke([o, a, d, c * xe(s, e)]);
+  }
+  return r;
+}
+const Se = (t) => !!t && ((t.low ?? 0) > 0 || (t.high ?? 0) > 0);
+function X(t) {
+  const e = {}, i = t.length - 1;
+  return t.forEach((r, n) => {
+    e[i === 0 ? 0 : n / i] = r;
+  }), e;
+}
+function Ue(t, e) {
+  const i = Pe(t, e?.reverse ?? !1);
+  return Se(e?.alphaFade) ? ve(i, e.alphaFade) : i;
+}
+function Pe(t, e) {
+  const i = K;
+  if (typeof t == "string") {
+    const r = i[t];
+    if (!r)
+      throw new Error(
+        `Palette "${t}" not found. Available palettes: ${Object.keys(
+          i
+        ).join(", ")}`
+      );
+    const n = e ? [...r.colors].reverse() : r.colors;
+    return X(n);
+  }
+  if (Array.isArray(t)) {
+    const r = e ? [...t].reverse() : t;
+    return X(r);
+  }
+  return e ? Object.fromEntries(
+    Object.entries(t).map(([r, n]) => [1 - Number(r), n])
+  ) : t;
+}
+function wt(t = {}) {
+  return Object.entries(K).map(([i, r]) => ({ id: i, ...r })).filter(
+    (i) => t.includeDeprecated || !i.tags.includes("deprecated")
+  );
+}
+function O(t, e, i) {
+  const r = t.createShader(e);
+  if (!r)
+    throw new Error("Failed to create shader");
+  if (t.shaderSource(r, i), t.compileShader(r), !t.getShaderParameter(r, t.COMPILE_STATUS)) {
+    const n = t.getShaderInfoLog(r);
+    throw t.deleteShader(r), new Error(`Shader compile error: ${n}`);
+  }
+  return r;
+}
+function _t(t, e, i) {
+  const r = t.createProgram();
+  if (!r)
+    throw new Error("Failed to create program");
+  const n = O(t, t.VERTEX_SHADER, e), s = O(t, t.FRAGMENT_SHADER, i);
+  if (t.attachShader(r, n), t.attachShader(r, s), t.linkProgram(r), !t.getProgramParameter(r, t.LINK_STATUS)) {
+    const o = t.getProgramInfoLog(r);
+    throw t.deleteProgram(r), new Error(`Program link error: ${o}`);
+  }
+  return t.deleteShader(n), t.deleteShader(s), r;
+}
+function yt(t, e, i, r, n) {
+  const s = t.createTexture();
+  if (!s)
+    throw new Error("Failed to create texture");
+  return t.bindTexture(t.TEXTURE_2D, s), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, e), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, e), t.texImage2D(
+    t.TEXTURE_2D,
+    0,
+    t.RGBA,
+    r,
+    n,
+    0,
+    t.RGBA,
+    t.UNSIGNED_BYTE,
+    i
+  ), t.bindTexture(t.TEXTURE_2D, null), s;
+}
+function De(t, e, i) {
+  const r = t.getParameter(
+    t.TEXTURE_BINDING_2D
+  ), n = t.getParameter(
+    t.FRAMEBUFFER_BINDING
+  ), s = t.createTexture(), o = t.createFramebuffer();
+  if (!s || !o)
+    return s && t.deleteTexture(s), o && t.deleteFramebuffer(o), t.bindTexture(t.TEXTURE_2D, r), t.bindFramebuffer(t.FRAMEBUFFER, n), !1;
+  let a = !1;
+  try {
+    t.bindTexture(t.TEXTURE_2D, s), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      e,
+      1,
+      1,
+      0,
+      t.RGBA,
+      i,
+      null
+    ), t.bindFramebuffer(t.FRAMEBUFFER, o), t.framebufferTexture2D(
+      t.FRAMEBUFFER,
+      t.COLOR_ATTACHMENT0,
+      t.TEXTURE_2D,
+      s,
+      0
+    ), a = t.checkFramebufferStatus(t.FRAMEBUFFER) === t.FRAMEBUFFER_COMPLETE;
+  } finally {
+    t.bindFramebuffer(t.FRAMEBUFFER, n), t.bindTexture(t.TEXTURE_2D, r), t.deleteFramebuffer(o), t.deleteTexture(s);
+  }
+  return a;
+}
+function Me(t) {
+  return {
+    kind: "rgba8-packed",
+    internalFormat: t.RGBA,
+    type: t.UNSIGNED_BYTE
+  };
+}
+function xt(t) {
+  if (typeof WebGL2RenderingContext > "u" || !(t instanceof WebGL2RenderingContext))
+    throw new Error("zartigl requires WebGL2");
+  return t;
+}
+function At(t) {
+  const e = [];
+  t.getExtension("EXT_color_buffer_float") ? e.push(
+    { kind: "float32", internalFormat: t.RGBA32F, type: t.FLOAT },
+    { kind: "float16", internalFormat: t.RGBA16F, type: t.HALF_FLOAT }
+  ) : t.getExtension("EXT_color_buffer_half_float") && e.push({
+    kind: "float16",
+    internalFormat: t.RGBA16F,
+    type: t.HALF_FLOAT
+  });
+  for (const i of e)
+    if (De(
+      t,
+      i.internalFormat,
+      i.type
+    ))
+      return i;
+  return Me(t);
+}
+function kt(t, e, i, r, n, s, o) {
+  const a = t.createTexture();
+  if (!a)
+    throw new Error("Failed to create texture");
+  return t.bindTexture(t.TEXTURE_2D, a), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, e), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, e), t.texImage2D(
+    t.TEXTURE_2D,
+    0,
+    s,
+    r,
+    n,
+    0,
+    t.RGBA,
+    o,
+    i
+  ), t.bindTexture(t.TEXTURE_2D, null), a;
+}
+function Ft(t, e, i) {
+  t.activeTexture(t.TEXTURE0 + i), t.bindTexture(t.TEXTURE_2D, e);
+}
+function vt(t, e) {
+  const i = t.createFramebuffer();
+  if (!i)
+    throw new Error("Failed to create framebuffer");
+  return t.bindFramebuffer(t.FRAMEBUFFER, i), t.framebufferTexture2D(
+    t.FRAMEBUFFER,
+    t.COLOR_ATTACHMENT0,
+    t.TEXTURE_2D,
+    e,
+    0
+  ), t.bindFramebuffer(t.FRAMEBUFFER, null), i;
+}
+function St(t) {
+  const e = t.createBuffer();
+  if (!e)
+    throw new Error("Failed to create buffer");
+  return t.bindBuffer(t.ARRAY_BUFFER, e), t.bufferData(
+    t.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+    t.STATIC_DRAW
+  ), e;
+}
+const Ne = {
+  0: "#3288bd",
+  0.1: "#66c2a5",
+  0.2: "#abdda4",
+  0.3: "#e6f598",
+  0.4: "#fee08b",
+  0.5: "#fdae61",
+  0.6: "#f46d43",
+  1: "#d53e4f"
+};
+function Ut(t, e, i) {
+  const r = Ue(e ?? Ne, i), n = document.createElement("canvas");
+  n.width = 256, n.height = 1;
+  const s = n.getContext("2d"), o = s.createLinearGradient(0, 0, 256, 0);
+  for (const [d, c] of Object.entries(r))
+    o.addColorStop(Number(d), c);
+  s.fillStyle = o, s.fillRect(0, 0, 256, 1);
+  const a = t.createTexture();
+  if (!a)
+    throw new Error("Failed to create color ramp texture");
+  return t.bindTexture(t.TEXTURE_2D, a), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.LINEAR), t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, n), t.bindTexture(t.TEXTURE_2D, null), a;
+}
+function Pt(t) {
+  const e = t.getExtension("WEBGL_debug_renderer_info");
+  return {
+    vendor: String(t.getParameter(t.VENDOR) ?? ""),
+    renderer: String(t.getParameter(t.RENDERER) ?? ""),
+    unmaskedVendor: e ? String(t.getParameter(e.UNMASKED_VENDOR_WEBGL) ?? "") : void 0,
+    unmaskedRenderer: e ? String(t.getParameter(e.UNMASKED_RENDERER_WEBGL) ?? "") : void 0,
+    version: String(t.getParameter(t.VERSION) ?? "")
+  };
+}
+function Dt(t) {
+  return {
+    program: t.getParameter(t.CURRENT_PROGRAM),
+    activeTexture: t.getParameter(t.ACTIVE_TEXTURE),
+    arrayBuffer: t.getParameter(t.ARRAY_BUFFER_BINDING),
+    elementBuffer: t.getParameter(t.ELEMENT_ARRAY_BUFFER_BINDING),
+    framebuffer: t.getParameter(t.FRAMEBUFFER_BINDING),
+    blend: t.isEnabled(t.BLEND),
+    depthTest: t.isEnabled(t.DEPTH_TEST),
+    stencilTest: t.isEnabled(t.STENCIL_TEST),
+    viewport: t.getParameter(t.VIEWPORT),
+    blendFunc: [
+      t.getParameter(t.BLEND_SRC_RGB),
+      t.getParameter(t.BLEND_DST_RGB)
+    ]
+  };
+}
+function Mt(t, e) {
+  t.useProgram(e.program), t.activeTexture(e.activeTexture), t.bindBuffer(t.ARRAY_BUFFER, e.arrayBuffer), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, e.elementBuffer), t.bindFramebuffer(t.FRAMEBUFFER, e.framebuffer), e.blend ? t.enable(t.BLEND) : t.disable(t.BLEND), e.depthTest ? t.enable(t.DEPTH_TEST) : t.disable(t.DEPTH_TEST), e.stencilTest ? t.enable(t.STENCIL_TEST) : t.disable(t.STENCIL_TEST), t.viewport(e.viewport[0], e.viewport[1], e.viewport[2], e.viewport[3]), t.blendFunc(e.blendFunc[0], e.blendFunc[1]);
+}
+const Ie = {
+  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: ""
+}, Ge = {
+  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"
+}, Le = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+function q(t) {
+  return t === 1 ? "" : [...String(t)].map((e) => Le[Number(e)]).join("");
+}
+function Nt(t) {
+  const e = t?.trim() ?? "", i = Ie[e.toLowerCase()];
+  if (i != null)
+    return i;
+  if (e.includes("/"))
+    return e;
+  const r = [], n = [];
+  for (const s of e.split(/\s+/)) {
+    const o = /^([A-Za-z]+)\^?(-?\d+)?$/.exec(s);
+    if (!o)
+      return e.replace(/_/g, " ");
+    const a = Ge[o[1]] ?? o[1], d = Number(o[2] ?? 1);
+    d < 0 ? n.push(a + q(-d)) : r.push(a + q(d));
+  }
+  return [r.join(" ") || "1", ...n].join("/");
+}
+const $ = 20, Ce = 600;
+function Ve(t) {
+  const e = Math.max(0, Math.min(1, t));
+  return $ * Math.pow(Ce / $, e);
+}
+function It(t) {
+  return Math.exp(-1 / Ve(t));
+}
+const Be = 0.8, Xe = 120, Oe = 300;
+class Gt {
+  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, i) {
+    e !== this.moving && (this.from = this.value(i), this.moving = e, this.to = e ? Be : this.base, this.start = i, this.duration = e ? Xe : Oe);
+  }
+  value(e) {
+    if (this.duration === 0)
+      return this.to;
+    const i = Math.min(1, Math.max(0, (e - this.start) / this.duration));
+    return i === 1 ? (this.duration = 0, this.from = this.to, this.to) : this.from + (this.to - this.from) * i * i * (3 - 2 * i);
+  }
+}
+function Lt(t) {
+  if (t == null)
+    return null;
+  if (!Number.isFinite(t[0]) || !Number.isFinite(t[1]) || t[0] >= t[1])
+    throw new RangeError(
+      "colorDomain must contain two finite, increasing values"
+    );
+  return [t[0], t[1]];
+}
+function p(t, e) {
+  if (typeof t != "number" || !Number.isFinite(t))
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  return t;
+}
+function A(t, e) {
+  if (typeof t != "string")
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  const i = new Date(t).getTime();
+  if (!Number.isFinite(i))
+    throw new Error(`Invalid GeoVideo manifest ${e}`);
+  return i;
+}
+function D(t) {
+  return typeof t == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(
+    t
+  );
+}
+function W(t) {
+  if (!t || typeof t != "object")
+    throw new Error("Invalid GeoVideo manifest");
+  const e = t;
+  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 [i, r, n, s] = e.bounds.map(
+    (u, m) => p(u, `bounds[${m}]`)
+  );
+  if (r < -90 || s > 90 || r >= s || i === n)
+    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 (p(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 d = p(a.codeMin, "encoding.codeMin"), c = p(a.codeMax, "encoding.codeMax");
+  if (d < 0 || c > 255 || d >= c)
+    throw new Error("Invalid GeoVideo code range");
+  let l = o.height;
+  if (a.kind === "scalar-luma") {
+    if (a.transfer !== "linear" && a.transfer !== "log10-1p9" || p(a.valueMin, "encoding.valueMin") >= p(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" || p(a.valueDomain, "encoding.valueDomain") <= 0 || o.height % 2 !== 0)
+      throw new Error("Invalid GeoVideo vector-luma encoding");
+    l = 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 || p(h.width, "mask.width") !== o.width || p(h.height, "mask.height") !== l || p(h.threshold, "mask.threshold") < 0 || h.threshold > 1)
+    throw new Error("Invalid GeoVideo static mask");
+  if (e.timeline?.kind === "range") {
+    const u = A(e.timeline.dateStart, "timeline.dateStart");
+    if (A(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")
+    A(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) => A(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 (!D(e.id) || !e.provenance || !D(e.provenance.catalogEntryId) || !D(e.provenance.inputSourceId) || !Array.isArray(e.provenance.variables) || e.provenance.variables.length === 0)
+    throw new Error("Invalid GeoVideo provenance");
+  return { ...e, bounds: [i, r, n, s] };
+}
+async function qe(t, e) {
+  if (typeof t != "string")
+    return W(t);
+  const i = await fetch(t, { signal: e });
+  if (!i.ok)
+    throw new Error(
+      `GeoVideo manifest request failed (${i.status}): ${t}`
+    );
+  const r = await i.json(), n = W(r), s = typeof document < "u" ? new URL(t, document.baseURI).href : t;
+  return {
+    ...n,
+    media: { ...n.media, url: new URL(n.media.url, s).href },
+    mask: { ...n.mask, url: new URL(n.mask.url, s).href }
+  };
+}
+function w(t) {
+  if (t.timeline.kind === "snapshot-loop")
+    return [new Date(t.timeline.date).getTime()];
+  if (t.timeline.kind === "sample-sequence")
+    return t.timeline.values.map((n) => new Date(n).getTime());
+  const e = new Date(t.timeline.dateStart).getTime(), i = new Date(t.timeline.dateEnd).getTime(), r = Math.max(
+    2,
+    Math.round(t.media.durationSeconds * t.media.fps)
+  );
+  return Array.from(
+    { length: r },
+    (n, s) => e + (i - e) * s / (r - 1)
+  );
+}
+function z(t) {
+  return t.timeline.kind === "sample-sequence" ? t.timeline.values.length / t.media.durationSeconds : t.media.fps;
+}
+function Ct(t, e) {
+  return e / z(t);
+}
+function $e(t, e) {
+  if (t.timeline.kind === "snapshot-loop")
+    return 0;
+  if (t.timeline.kind === "sample-sequence") {
+    const s = w(t);
+    let o = 0;
+    for (let d = 1; d < s.length; d += 1)
+      Math.abs(s[d] - e) < Math.abs(s[o] - e) && (o = d);
+    const a = t.media.durationSeconds / s.length;
+    return o * a + Math.min(a / 2, 0.5 / t.media.fps);
+  }
+  const i = new Date(t.timeline.dateStart).getTime(), r = new Date(t.timeline.dateEnd).getTime();
+  return Math.max(0, Math.min(1, (e - i) / (r - i))) * Z(t);
+}
+function Vt(t, e) {
+  if (t.timeline.kind === "snapshot-loop")
+    return new Date(t.timeline.date).getTime();
+  if (t.timeline.kind === "sample-sequence") {
+    const o = w(t), a = t.media.durationSeconds / o.length, d = Math.floor((e + 0.25 / t.media.fps) / a);
+    return o[Math.max(0, Math.min(o.length - 1, d))];
+  }
+  const i = new Date(t.timeline.dateStart).getTime(), r = new Date(t.timeline.dateEnd).getTime(), n = Z(t), s = n > 0 ? Math.max(0, Math.min(1, e / n)) : 0;
+  return i + (r - i) * s;
+}
+function Z(t) {
+  return Math.max(0, t.media.durationSeconds - 1 / t.media.fps);
+}
+function We(t, e) {
+  const i = new Uint8Array(t.length / 4);
+  for (let r = 0; r < i.length; r++) {
+    const n = t[r * 4];
+    i[r] = e === "limited" ? Math.round(n * 219 / 255 + 16) : n;
+  }
+  return i;
+}
+class He {
+  constructor() {
+    this.gl = null, this.texture = null, this.framebuffer = null;
+  }
+  read(e, i, r) {
+    const n = this.context();
+    n.bindTexture(n.TEXTURE_2D, this.texture), n.pixelStorei(n.UNPACK_FLIP_Y_WEBGL, !1), n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), n.pixelStorei(n.UNPACK_COLORSPACE_CONVERSION_WEBGL, n.NONE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, n.NEAREST), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, n.NEAREST), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), n.texImage2D(n.TEXTURE_2D, 0, n.RGBA, n.RGBA, n.UNSIGNED_BYTE, e), n.bindFramebuffer(n.FRAMEBUFFER, this.framebuffer), n.framebufferTexture2D(
+      n.FRAMEBUFFER,
+      n.COLOR_ATTACHMENT0,
+      n.TEXTURE_2D,
+      this.texture,
+      0
+    );
+    const s = new Uint8Array(i * r * 4);
+    return n.readPixels(0, 0, i, r, n.RGBA, n.UNSIGNED_BYTE, s), n.bindFramebuffer(n.FRAMEBUFFER, null), s;
+  }
+  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"), i = {
+      premultipliedAlpha: !1,
+      antialias: !1
+    }, r = e.getContext("webgl2", i);
+    if (!r)
+      throw new Error("WebGL2 is required to decode GeoVideo frames");
+    return this.gl = r, this.texture = r.createTexture(), this.framebuffer = r.createFramebuffer(), r;
+  }
+}
+function H(t) {
+  const e = Math.max(4, Math.floor(t.length / 4 / 997) * 4);
+  for (let i = 3; i < t.length; i += e)
+    if (t[i] !== 0)
+      return !1;
+  return !0;
+}
+function E() {
+  return new DOMException("GeoVideo frame request was cancelled", "AbortError");
+}
+function _(t, e, i) {
+  return e ? e.aborted ? (t.catch(() => {
+  }), i?.(), Promise.reject(E())) : new Promise((r, n) => {
+    const s = () => {
+      i?.(), n(E());
+    };
+    e.addEventListener("abort", s, { once: !0 }), t.then(r, n).finally(() => {
+      e.removeEventListener("abort", s);
+    });
+  }) : t;
+}
+function M(t, e) {
+  return new Promise(
+    (i) => t.addEventListener(e, () => i(), { once: !0 })
+  );
+}
+const Ye = 250;
+function je(t) {
+  return "requestVideoFrameCallback" in t ? Promise.race([
+    new Promise(
+      (e) => t.requestVideoFrameCallback(() => e())
+    ),
+    new Promise((e) => setTimeout(e, Ye))
+  ]) : Promise.resolve();
+}
+class J {
+  constructor(e, i, r = {}) {
+    this.reader = new He(), 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 = i, this.cacheSize = Math.max(1, r.cacheSize ?? 3), this.width = e.media.width, this.height = e.media.height / i, this.times = Float64Array.from(w(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, i) {
+    const r = this.reader.read(e, this.width, i);
+    return H(r) ? null : We(r, this.manifest.encoding.colorRange);
+  }
+  /** True when the decoder exposed no pixels; reads back one row only. */
+  isBlank(e) {
+    return H(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, i = {}) {
+    const { signal: r } = i;
+    if (r?.aborted)
+      return Promise.reject(E());
+    let n = this.frames.get(e);
+    if (n ? (this.frames.delete(e), this.frames.set(e, n)) : n = this.enqueue(e), n.settled)
+      return n.promise;
+    const s = n;
+    return s.waiters++, _(s.promise, r, () => this.leave(s));
+  }
+  enqueue(e) {
+    const i = new AbortController(), r = this.queue.then(
+      () => i.signal.aborted ? Promise.reject(E()) : this.decode(e, i.signal)
+    );
+    this.queue = r.catch(() => {
+    });
+    const n = {
+      index: e,
+      controller: i,
+      promise: _(r, i.signal),
+      waiters: 0,
+      settled: !1
+    };
+    for (this.pending.add(n), n.promise.then(
+      () => {
+        n.settled = !0, this.pending.delete(n);
+      },
+      () => {
+        n.settled = !0, this.pending.delete(n), this.frames.get(e) === n && this.frames.delete(e);
+      }
+    ), this.frames.set(e, n); this.frames.size > this.cacheSize; )
+      this.frames.delete(this.frames.keys().next().value);
+    return n;
+  }
+  /** 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.loadVideo()]);
+    this.maskCodes = e;
+  }
+  async loadMask() {
+    const { url: e, width: i, height: r } = this.manifest.mask, n = new Image();
+    n.crossOrigin = "anonymous", n.src = e;
+    try {
+      await n.decode();
+    } catch {
+      throw new Error(`Failed to load GeoVideo mask: ${e}`);
+    }
+    if (n.naturalWidth !== i || n.naturalHeight !== r)
+      throw new Error(
+        `GeoVideo mask dimensions ${n.naturalWidth}x${n.naturalHeight} do not match manifest ${i}x${r}`
+      );
+    const s = this.reader.read(n, i, r), o = new Uint8Array(i * r);
+    for (let a = 0; a < o.length; a++)
+      o[a] = s[a * 4];
+    return o;
+  }
+  async loadVideo() {
+    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((i, r) => {
+      e.addEventListener("loadedmetadata", () => i(), {
+        once: !0
+      }), e.addEventListener(
+        "error",
+        () => r(
+          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, i) {
+    if (this.presented && Math.abs(e.currentTime - i) <= 1e-3 && !e.seeking)
+      return;
+    const r = je(e), n = M(e, "seeked");
+    e.currentTime = i, await n, e.readyState < HTMLMediaElement.HAVE_CURRENT_DATA && await Promise.race([M(e, "loadeddata"), M(e, "canplay")]), await r, 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;
+  }
+  /**
+   * Seek and capture one step. `signal` aborts it between steps; a seek
+   * already started completes first, keeping the queue serial.
+   */
+  async decode(e, i) {
+    if (i.aborted)
+      throw E();
+    await this.init();
+    const r = this.video, n = this.maskCodes;
+    if (i.aborted || !r || !n)
+      throw E();
+    const s = this.manifest.timeline.kind === "snapshot-loop" ? e / this.manifest.media.fps : $e(this.manifest, this.times[e]);
+    if (await this.presentFrame(r, s), i.aborted || r !== this.video)
+      throw E();
+    const o = this.height * this.planes;
+    let a = await this.capture(r, o, n);
+    if (a === null && !this.primed) {
+      if (await this.primeDecoder(r), await this.presentFrame(r, s), i.aborted || r !== this.video)
+        throw E();
+      a = await this.capture(r, o, n);
+    }
+    if (a === null)
+      throw new Error("GeoVideo frame could not be read back from the decoder");
+    return a;
+  }
+}
+function Ke(t) {
+  return {
+    codeRange: [t.codeMin / 255, t.codeMax / 255],
+    valueRange: [t.valueMin, t.valueMax],
+    transfer: t.transfer === "log10-1p9" ? 1 : 0
+  };
+}
+class ze extends J {
+  constructor(e, i = {}) {
+    if (e.encoding.kind !== "scalar-luma")
+      throw new Error("GeoVideoScalarSource requires a scalar-luma manifest");
+    super(e, 1, i);
+  }
+  async capture(e) {
+    return this.isBlank(e) ? null : createImageBitmap(e, {
+      premultiplyAlpha: "none",
+      colorSpaceConversion: "none"
+    });
+  }
+}
+function R(t, e) {
+  if (e <= t[0])
+    return { index: 0, fraction: 0 };
+  const i = t.length - 1;
+  if (e >= t[i])
+    return { index: i, fraction: 0 };
+  let r = 0, n = i;
+  for (; n - r > 1; ) {
+    const s = r + n >> 1;
+    t[s] <= e ? r = s : n = s;
+  }
+  return { index: r, fraction: (e - t[r]) / (t[n] - t[r]) };
+}
+function N(t, e) {
+  const { index: i, fraction: r } = R(t, e);
+  return i + r;
+}
+function Ze(t, e) {
+  const i = Math.max(0, Math.min(t.length - 1, Math.floor(e))), r = Math.min(i + 1, t.length - 1);
+  return t[i] + (t[r] - t[i]) * Math.max(0, e - i);
+}
+function Je(t, e) {
+  let i = (t - e.codeMin) / (e.codeMax - e.codeMin) * 2 - 1;
+  return i = Math.max(-1, Math.min(1, i)), e.transfer === "sqrt" && (i = Math.sign(i) * i * i), i * e.valueDomain;
+}
+function Qe(t, e, i, r) {
+  const n = e.length;
+  if (t.length !== 2 * n)
+    throw new Error(
+      `GeoVideo vector frame has ${t.length} codes, expected ${2 * n}`
+    );
+  const s = new Float32Array(256);
+  for (let c = 0; c < 256; c++)
+    s[c] = Je(c, r);
+  const o = i * 255, a = new Float32Array(n), d = new Float32Array(n);
+  for (let c = 0; c < n; c++) {
+    const l = e[c] >= o;
+    a[c] = l ? s[t[c]] : NaN, d[c] = l ? s[t[n + c]] : NaN;
+  }
+  return { u: a, v: d };
+}
+class et extends J {
+  constructor(e, i = {}) {
+    if (e.encoding.kind !== "vector-luma")
+      throw new Error("GeoVideoVectorSource requires a vector-luma manifest");
+    super(e, 2, i), this.encoding = e.encoding;
+    const [r, n, s, o] = e.bounds, a = (s - r) / this.width, d = (o - n) / this.height;
+    this.coords = {
+      time: this.times,
+      vertical: new Float32Array([0]),
+      latitude: Float32Array.from(
+        { length: this.height },
+        (c, l) => o - (l + 0.5) * d
+      ),
+      longitude: Float32Array.from(
+        { length: this.width },
+        (c, l) => r + (l + 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 i = typeof e == "number" ? e : new Date(e).getTime(), r = this.coords.time;
+    let n = 0;
+    for (let s = 1; s < r.length; s++)
+      Math.abs(r[s] - i) < Math.abs(r[n] - i) && (n = s);
+    return n;
+  }
+  getChunksForBounds(e, i, r) {
+    const { latitude: n, longitude: s } = this.coords;
+    return [
+      {
+        timeIdx: i,
+        depthIdx: r,
+        latIdx: 0,
+        lonIdx: 0,
+        latRange: [n[0], n[this.height - 1]],
+        lonRange: [s[0], s[this.width - 1]],
+        latSize: this.height,
+        lonSize: this.width
+      }
+    ];
+  }
+  async fetchSpatialChunkResult(e, i) {
+    const r = await this.frame(i.timeIndex);
+    return {
+      data: e === "v" ? r.v : r.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, i, r) {
+    const n = this.readCodes(e, i);
+    return n ? Qe(
+      n,
+      r,
+      this.manifest.mask.threshold,
+      this.encoding
+    ) : null;
+  }
+}
+function tt(t, e, i = {}) {
+  const [r, n] = i.range ?? [-1 / 0, 1 / 0], s = [...t].sort((a, d) => a.start - d.start), o = s.find(
+    (a) => a.start > e && a.start <= n
+  ) ?? (i.loop ? s.find(
+    (a) => a.end >= r && a.start <= n
+  ) : void 0);
+  return o ? { chunk: o, time: Math.max(o.start, r) } : null;
+}
+function it(t, e) {
+  let i = null, r = -1 / 0;
+  for (const n of e) {
+    const s = Math.min(t.end, n.end) - Math.max(t.start, n.start);
+    Number.isFinite(s) && s >= 0 && s > r && (i = n, r = s);
+  }
+  return i;
+}
+function rt(t) {
+  return {
+    width: t.mask.width,
+    height: t.mask.height,
+    bounds: t.bounds,
+    rowOrder: "north-to-south"
+  };
+}
+function Q(t, e = {}) {
+  return t.encoding.kind === "vector-luma" ? new et(t, e) : new ze(t, e);
+}
+const nt = 3, st = 3, at = 0.6, ot = 1.5;
+function ct(t) {
+  const e = new AbortController();
+  if (!t)
+    return { controller: e, unlink: () => {
+    } };
+  const i = () => e.abort();
+  return t.aborted && i(), t.addEventListener("abort", i, { once: !0 }), {
+    controller: e,
+    unlink: () => t.removeEventListener("abort", i)
+  };
+}
+class Bt {
+  constructor(e) {
+    this.manifests = /* @__PURE__ */ new Map(), this.open = /* @__PURE__ */ new Map(), this.id = e.id, this.chunks = e.chunks.filter(
+      (i) => Number.isFinite(i.start) && Number.isFinite(i.end) && i.end >= i.start
+    ).sort((i, r) => i.start - r.start), this.maxOpenChunks = Math.max(2, e.maxOpenChunks ?? nt), this.frameCacheSize = Math.max(
+      1,
+      e.frameCacheSize ?? st
+    ), this.prefetchAt = e.prefetchAt ?? at, this.maxGap = e.maxGap, this.loadManifest = e.loadManifest ?? qe, this.createFrameSource = e.createFrameSource ?? ((i, r) => Q(
+      i,
+      r
+    ));
+  }
+  /** 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((i) => i.end))] : null;
+  }
+  /** The chunk whose sample range holds `time`, or null. */
+  chunkAt(e) {
+    const i = this.chunkIndexAt(e), r = i >= 0 ? this.chunks[i] : null;
+    return r && e <= r.end ? r : null;
+  }
+  /** Every step time of the archive; loads all chunk manifests. */
+  async steps(e = {}) {
+    if (e.signal?.aborted)
+      throw E();
+    const i = await _(
+      Promise.all(this.chunks.map((r) => this.manifest(r))),
+      e.signal
+    );
+    return Float64Array.from(i.flatMap(w));
+  }
+  /**
+   * 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, i = {}) {
+    const { signal: r } = i, n = i.mode ?? "interpolate";
+    if (r?.aborted)
+      throw E();
+    const s = this.chunkIndexAt(e);
+    if (s < 0)
+      return null;
+    const o = [], { controller: a, unlink: d } = ct(r);
+    try {
+      const c = this.acquire(this.chunks[s], o), l = await _(c.ready, a.signal), { times: h } = l;
+      let f;
+      if (e <= h[h.length - 1]) {
+        const { index: b, fraction: g } = R(h, e);
+        f = n === "discrete" || g === 0 ? [c, b, c, b, 0] : [c, b, c, b + 1, g];
+      } else {
+        const b = this.chunks[s + 1];
+        if (!b)
+          return null;
+        const g = this.acquire(b, o), V = await _(g.ready, a.signal), x = h.length - 1, U = h[x], P = V.times[0];
+        if (P - U > this.gapLimit(h, V.times))
+          return null;
+        f = n === "discrete" ? [c, x, c, x, 0] : e >= P ? [g, 0, g, 0, 0] : [c, x, g, 0, (e - U) / (P - U)];
+      }
+      const [u, m, T, v, y] = f, L = u === T && m === v, C = [this.frame(u, m, a.signal)];
+      L || C.push(this.frame(T, v, a.signal));
+      let S;
+      try {
+        S = await Promise.all(C);
+      } catch (b) {
+        throw a.abort(), b;
+      }
+      return this.prefetchAfter(s, e), {
+        time: e,
+        a: S[0],
+        b: S[L ? 0 : 1],
+        mix: y
+      };
+    } finally {
+      d();
+      for (const c of o)
+        c.users--;
+      this.trim();
+    }
+  }
+  /** Open `chunk` and decode its first frame ahead of a request. */
+  prefetch(e) {
+    if (this.open.has(e.key))
+      return;
+    const i = this.touch(e), r = new AbortController();
+    i.prefetch = r, i.ready.then(({ source: n }) => n.frame(0, { signal: r.signal })).catch(() => {
+    }).finally(() => {
+      i.prefetch === r && (i.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 i = 0, r = this.chunks.length - 1, n = -1;
+    for (; i <= r; ) {
+      const s = i + r >> 1;
+      this.chunks[s].start <= e ? (n = s, i = s + 1) : r = s - 1;
+    }
+    return n;
+  }
+  gapLimit(e, i) {
+    if (this.maxGap !== void 0)
+      return this.maxGap;
+    const r = [
+      e.length > 1 ? e[e.length - 1] - e[e.length - 2] : 0,
+      i.length > 1 ? i[1] - i[0] : 0
+    ], n = Math.max(...r);
+    return n > 0 ? n * ot : -1 / 0;
+  }
+  prefetchAfter(e, i) {
+    const r = this.chunks[e], n = this.chunks[e + 1], s = r.end - r.start, o = s > 0 ? (i - r.start) / s : 1;
+    n && o > this.prefetchAt && this.prefetch(n);
+  }
+  manifest(e) {
+    let i = this.manifests.get(e.manifestUrl);
+    return i || (i = this.loadManifest(e.manifestUrl), this.manifests.set(e.manifestUrl, i), i.catch(() => {
+      this.manifests.get(e.manifestUrl) === i && this.manifests.delete(e.manifestUrl);
+    })), i;
+  }
+  /** The open chunk, pinned for a running sample listed in `used`. */
+  acquire(e, i) {
+    const r = this.touch(e);
+    return r.users++, i.push(r), r;
+  }
+  /** The open chunk, opened when needed, most recently used; not pinned. */
+  touch(e) {
+    let i = this.open.get(e.key);
+    if (i)
+      this.open.delete(e.key);
+    else {
+      const r = {
+        chunk: e,
+        ready: null,
+        opened: null,
+        users: 0,
+        prefetch: null,
+        released: !1
+      };
+      r.ready = this.manifest(e).then((n) => {
+        if (r.released)
+          throw E();
+        return r.opened = {
+          manifest: n,
+          times: Float64Array.from(w(n)),
+          grid: rt(n),
+          source: this.createFrameSource(n, {
+            cacheSize: this.frameCacheSize
+          })
+        }, r.opened;
+      }), r.ready.catch(() => {
+        this.open.get(e.key) === r && this.open.delete(e.key);
+      }), i = r;
+    }
+    return this.open.set(e.key, i), i;
+  }
+  async frame(e, i, r) {
+    const { manifest: n, times: s, grid: o, source: a } = await _(
+      e.ready,
+      r
+    );
+    if (e.released)
+      throw E();
+    const d = await a.frame(i, { signal: r });
+    return {
+      key: `${this.id}/${e.chunk.key}/${i}`,
+      chunk: e.chunk,
+      step: i,
+      time: s[i],
+      data: d,
+      grid: o,
+      manifest: n
+    };
+  }
+  /** Release least recently used chunks beyond the bound, unless in use. */
+  trim() {
+    let e = this.open.size - this.maxOpenChunks;
+    for (const i of [...this.open.values()]) {
+      if (e <= 0)
+        return;
+      i.users === 0 && (this.close(i), 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 dt = {
+  a: "u_vel0",
+  b: "u_vel1",
+  mix: "u_vel_mix",
+  bounds: "u_bounds"
+}, lt = {
+  a: "u_tint0",
+  b: "u_tint1",
+  mix: "u_tint_mix",
+  bounds: "u_tint_bounds"
+};
+function ht(t) {
+  const e = new Float32Array(t.u.length * 4);
+  for (let i = 0; i < t.u.length; i++) {
+    const r = t.u[i], n = t.v[i];
+    Number.isNaN(r) || Number.isNaN(n) || (e[i * 4] = r, e[i * 4 + 1] = n, e[i * 4 + 2] = 1);
+  }
+  return e;
+}
+class ut {
+  constructor(e, i, r = {}) {
+    this.gl = e, this.manifest = i, this.options = r, 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 = i.encoding.kind === "vector-luma", this.source = Q(i, { cacheSize: 2 }), this.uniforms = this.vector ? dt : lt;
+    const n = w(i);
+    this.times = r.animateSnapshot && i.timeline.kind === "snapshot-loop" ? Array.from(
+      {
+        length: Math.max(
+          1,
+          Math.round(i.media.durationSeconds * i.media.fps)
+        )
+      },
+      (s, o) => n[0] + o * 1e3 / i.media.fps
+    ) : n, this.bounds = i.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: i } = this.manifest;
+    return e.kind === "vector-luma" ? e.valueDomain : i.colorDomain[1];
+  }
+  /** Resolves once the step at `ms` is uploaded. */
+  async prime(e) {
+    const { index: i } = R(this.times, e);
+    await this.request(i);
+  }
+  /** True once the frames interpolated at `ms` are uploaded. */
+  ready(e) {
+    const { index: i, fraction: r } = R(this.times, e);
+    return this.textures.has(i) && (r === 0 || this.textures.has(i + 1));
+  }
+  /**
+   * Latest wins while scrubbing: drop queued decodes outside the frames at
+   * `ms`, then request those first.
+   */
+  focus(e) {
+    const { index: i } = R(this.times, e), r = Math.min(i + 1, this.times.length - 1);
+    [...this.pending.keys()].some(
+      (s) => s !== i && s !== r
+    ) && (this.source.cancelAll(), this.pending.clear());
+    for (const s of [i, r])
+      this.request(s).catch(() => {
+      });
+  }
+  /**
+   * Bracketing textures and their mix, retaining the last complete pair
+   * while a requested frame decodes.
+   */
+  sample(e, i = !0) {
+    const { index: r, fraction: n } = R(this.times, e), s = Math.min(r + 1, this.times.length - 1);
+    [...this.pending.keys()].some((c) => c < r || c > s + 1) && (this.source.cancelAll(), this.pending.clear());
+    for (const c of [r, s, s + 1])
+      c < this.times.length && this.request(c).catch(() => {
+      });
+    const o = this.textures.get(r), a = this.textures.get(s), d = i ? n : 0;
+    return o && (d === 0 || a) && (this.pair = [o, d === 0 ? o : a, d]), this.evict(r), this.pair;
+  }
+  /** Switch spatial filtering without changing the decoded-step cache. */
+  setFilter(e) {
+    if (this.linearFilter === e)
+      return;
+    this.linearFilter = e;
+    const i = this.gl, r = i.getParameter(
+      i.TEXTURE_BINDING_2D
+    );
+    for (const n of this.textures.values())
+      i.bindTexture(i.TEXTURE_2D, n), i.texParameteri(
+        i.TEXTURE_2D,
+        i.TEXTURE_MIN_FILTER,
+        e ? i.LINEAR : i.NEAREST
+      ), i.texParameteri(
+        i.TEXTURE_2D,
+        i.TEXTURE_MAG_FILTER,
+        e ? i.LINEAR : i.NEAREST
+      );
+    i.bindTexture(i.TEXTURE_2D, r);
+  }
+  get maskTexture() {
+    return this.mask;
+  }
+  get cachedFrames() {
+    return this.textures.size;
+  }
+  bind(e, i, r = 0) {
+    if (!this.sample(i) || !this.pair)
+      return !1;
+    const n = this.uniforms;
+    if (e.texture(n.a, r, this.pair[0]), e.texture(n.b, r + 1, this.pair[1]), e.float(n.mix, this.pair[2]), e.vec4(n.bounds, this.bounds), this.mask && this.manifest.encoding.kind === "scalar-luma") {
+      const { codeRange: s, valueRange: o, transfer: a } = Ke(
+        this.manifest.encoding
+      );
+      e.texture("u_tint_mask", r + 2, this.mask), e.vec2("u_code_range", ...s), 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 i = this.pending.get(e);
+    if (i)
+      return i;
+    const r = this.source.frame(e).then((n) => {
+      if (!this.destroyed && this.pending.get(e) === r && !this.textures.has(e)) {
+        const s = performance.now();
+        this.textures.set(e, this.uploadPreservingState(n)), this.uploadedFrames++, this.lastUploadDurationMs = performance.now() - s, this.options.onReady?.();
+      }
+    }).catch((n) => {
+      throw !this.destroyed && this.pending.get(e) === r && !(n instanceof Error && n.name === "AbortError") && this.options.onError?.(n), n;
+    }).finally(() => {
+      this.pending.get(e) === r && this.pending.delete(e);
+    });
+    return this.pending.set(e, r), r;
+  }
+  uploadPreservingState(e) {
+    const i = this.gl, r = i.getParameter(
+      i.TEXTURE_BINDING_2D
+    ), n = [
+      i.UNPACK_FLIP_Y_WEBGL,
+      i.UNPACK_PREMULTIPLY_ALPHA_WEBGL,
+      i.UNPACK_COLORSPACE_CONVERSION_WEBGL,
+      i.UNPACK_ALIGNMENT
+    ], s = n.map((o) => i.getParameter(o));
+    try {
+      return this.upload(e);
+    } finally {
+      i.bindTexture(i.TEXTURE_2D, r), n.forEach((o, a) => i.pixelStorei(o, s[a]));
+    }
+  }
+  upload(e) {
+    const i = this.gl, { width: r, height: n } = this.source, s = this.gridTexture();
+    return this.vector ? i.texImage2D(
+      i.TEXTURE_2D,
+      0,
+      i.RGBA16F,
+      r,
+      n,
+      0,
+      i.RGBA,
+      i.FLOAT,
+      ht(e)
+    ) : (i.pixelStorei(i.UNPACK_FLIP_Y_WEBGL, !1), i.pixelStorei(i.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), i.pixelStorei(i.UNPACK_COLORSPACE_CONVERSION_WEBGL, i.NONE), i.texImage2D(
+      i.TEXTURE_2D,
+      0,
+      i.RGBA8,
+      i.RGBA,
+      i.UNSIGNED_BYTE,
+      e
+    ), this.mask ??= this.uploadMask()), i.bindTexture(i.TEXTURE_2D, null), s;
+  }
+  /** The source's mask, loaded with its first frame, as an R8 texture. */
+  uploadMask() {
+    const e = this.source.mask;
+    if (!e)
+      return null;
+    const i = this.gl, r = this.gridTexture();
+    return this.options.repeatLongitude === !1 && (i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.NEAREST), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.NEAREST)), i.pixelStorei(i.UNPACK_ALIGNMENT, 1), i.texImage2D(
+      i.TEXTURE_2D,
+      0,
+      i.R8,
+      this.source.width,
+      this.source.height,
+      0,
+      i.RED,
+      i.UNSIGNED_BYTE,
+      e
+    ), i.pixelStorei(i.UNPACK_ALIGNMENT, 4), r;
+  }
+  /** A bound, linearly filtered texture over the field grid. */
+  gridTexture() {
+    const e = this.gl, i = e.createTexture();
+    return e.bindTexture(e.TEXTURE_2D, i), 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
+    ), i;
+  }
+  /** Keep a small window around the playhead. */
+  evict(e) {
+    for (const [i, r] of this.textures) {
+      const n = this.pair && (this.pair[0] === r || this.pair[1] === r);
+      (i < e - 1 || i > e + 3) && !n && (this.gl.deleteTexture(r), this.textures.delete(i));
+    }
+  }
+}
+class ft {
+  constructor(e, i) {
+    this.onPlaying = i, 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;
+  }
+  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, i, r, n = [i[0], i[i.length - 1]], s = !1, o = !1) {
+    if (!this.advancing || !i.length)
+      return !1;
+    const a = N(i, n[0]), d = N(i, n[1]), c = d + (o ? 1 : 0);
+    let l = Math.max(a, N(i, this.ms) + this.endFraction) + Math.max(0, e) * r;
+    const h = o ? l >= c : l > c;
+    return h && s && c > a ? l = a + (l - a) % (c - a) : l = Math.min(c, l), this.time = Ze(i, Math.min(d, l)), this.endFraction = Math.max(0, l - d), h && !s;
+  }
+}
+function k(t) {
+  const e = w(t);
+  return [e[0], e[e.length - 1]];
+}
+function I(t, e) {
+  return e ? [Math.max(t[0], e[0]), Math.min(t[1], e[1])] : t;
+}
+function F([t, e], i) {
+  return Math.max(t, Math.min(e, i));
+}
+class Xt {
+  constructor(e, i, r) {
+    this.repaint = i, this.emit = r, 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 n = typeof e.time == "string" ? Date.parse(e.time) : e.time;
+    this.requestedTime = n != null && Number.isFinite(n) ? n : null, this.requestedTimeRange = e.timeRange, this.clock = new ft(
+      !1,
+      (s) => this.emit("playbackChange", s)
+    );
+  }
+  async load(e, i) {
+    if (this.gl = e, this.manifest = i, this.timeRange = I(
+      k(i),
+      this.requestedTimeRange
+    ), this.timeRange[0] > this.timeRange[1])
+      throw new Error(
+        "GeoVideo time range does not overlap the manifest timeline"
+      );
+    this.pendingField = this.createField(i), await this.prepare(this.pendingField);
+  }
+  sample(e) {
+    return this.tick(e), this.field ? this.pendingField || this.seeking ? this.field.currentPair : this.field.sample(
+      this.clock.advancing ? this.clock.ms : this.exactTime,
+      this.clock.advancing && !this.awaitingNext
+    ) : 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 i = this.lastTick === null ? 0 : (e - this.lastTick) / 1e3;
+    this.lastTick = e;
+    const r = this.clock.advance(
+      i,
+      this.field.times,
+      this.stepsPerSecond ?? this.playbackRate * z(this.field.manifest),
+      this.playbackRange(this.field),
+      this.loop,
+      !0
+    ), { index: n } = R(this.field.times, this.clock.ms), s = this.field.manifest.timeline.kind === "snapshot-loop" ? this.field.times[0] : F(this.timeRange, this.field.times[n]);
+    s !== this.lastStepTime && (this.lastStepTime = s, this.emit("timeChange", s)), r ? this.reachEnd() : this.repaint();
+  }
+  setTime(e) {
+    const i = typeof e == "number" ? e : Date.parse(e);
+    if (!Number.isFinite(i))
+      return;
+    this.requestedTime = i, this.awaitingNext = !1;
+    const r = this.pendingField ?? this.field;
+    r && this.prepare(r).catch((n) => this.reportError(n));
+  }
+  /** Load the requested step first; stale seeks and swaps cannot replace it. */
+  async prepare(e, i) {
+    this.failed = !1;
+    const r = ++this.seekId, n = this.timeRange ?? k(e.manifest), s = i ?? F(n, this.requestedTime ?? n[0]), o = R(e.times, s), a = Math.min(
+      e.times.length - 1,
+      o.index + (o.fraction > 0.5 ? 1 : 0)
+    ), d = e.times[a];
+    this.seeking = !0, this.lastTick = null, e.focus(d);
+    try {
+      await e.prime(d);
+    } catch (l) {
+      if (r !== this.seekId)
+        return;
+      throw l;
+    }
+    if (r !== this.seekId || this.destroyed)
+      return;
+    const c = this.pendingField === e;
+    if (c && (this.field?.destroy(), this.field = e, this.pendingField = null, this.lastStepTime = null), this.exactTime = d, this.clock.ms = F(this.playbackRange(e), d), e.sample(d, !1), this.seeking = !1, this.endEmitted = !1, this.repaint(), c) {
+      const l = e.manifest;
+      if (this.emit("loaded", {
+        min: l.style.colorDomain[0],
+        max: l.style.colorDomain[1],
+        unit: l.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, i = {}) {
+    const r = this.replacementTimeRange(e, i);
+    if (!r || !this.gl)
+      return !1;
+    this.playOnReady ||= this.isPlaying(), this.pendingField?.destroy();
+    const n = this.standby;
+    return this.standby = null, n && n.field.manifest.media.url !== e.media.url && n.field.destroy(), this.pendingField = n?.field.manifest.media.url === e.media.url ? n.field : this.createField(e), this.awaitingNext = !1, this.manifest = e, this.requestedTimeRange = i.timeRange, this.timeRange = r, this.requestedTime = i.time ?? r[0], this.loop = i.loop ?? this.loop, this.playbackRate = i.playbackRate ?? this.playbackRate, this.stepsPerSecond = i.stepsPerSecond ?? this.stepsPerSecond, this.lastTick = null, this.prepare(this.pendingField).catch(
+      (s) => this.reportError(s)
+    ), !0;
+  }
+  /** Decode the next chunk ahead of its swap, including its static mask. */
+  preloadManifest(e, i = {}) {
+    const r = this.replacementTimeRange(e, i);
+    if (!r || !this.gl || e.media.url === this.manifest?.media.url)
+      return !1;
+    const n = F(r, i.time ?? r[0]);
+    this.standby?.field.manifest.media.url !== e.media.url && (this.discardStandby(), this.standby = { field: this.createField(e), time: n });
+    const s = this.standby;
+    return s.time = n, s.field.prime(n).catch(() => {
+      this.standby === s && this.discardStandby();
+    }), !0;
+  }
+  discardStandby() {
+    this.standby?.field.destroy(), this.standby = null;
+  }
+  /** Clamped time range of a compatible replacement, else null. */
+  replacementTimeRange(e, i) {
+    const r = this.manifest;
+    if (!r || e.encoding.kind !== r.encoding.kind || e.media.width !== r.media.width || e.media.height !== r.media.height || e.mask.width !== r.mask.width || e.mask.height !== r.mask.height)
+      return null;
+    const n = I(
+      k(e),
+      i.timeRange
+    );
+    return n[0] <= n[1] ? n : 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(
+      (r) => this.reportError(r)
+    );
+    const e = this.endEmitted;
+    this.endEmitted = !1;
+    const i = this.playbackRange(this.field);
+    e && this.setTime(i[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: i } = R(this.field.times, this.clock.ms);
+      this.prepare(this.field, this.field.times[i]).catch(
+        (r) => this.reportError(r)
+      );
+    }
+    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 i = I(
+      this.manifest ? k(this.manifest) : e,
+      e
+    );
+    if (i[0] > i[1])
+      throw new Error(
+        "GeoVideo time range does not overlap the manifest timeline"
+      );
+    this.requestedTimeRange = e, this.timeRange = i, this.setTime(
+      this.pendingField ? this.requestedTime ?? i[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 i = new ut(this.gl, e, {
+      repeatLongitude: !1,
+      animateSnapshot: !0,
+      onError: (r) => {
+        this.field === i && !this.seeking && this.reportError(r);
+      },
+      onReady: () => this.repaint()
+    });
+    return i;
+  }
+  reportError(e) {
+    const i = e instanceof Error ? e : new Error(String(e));
+    i.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: i }), this.emit("error", i));
+  }
+}
+function G(t) {
+  const { start: e, end: i } = t.temporal ?? {};
+  return {
+    source: t,
+    start: Date.parse(e ?? ""),
+    end: Date.parse(i ?? e ?? "")
+  };
+}
+function Ot(t, e, i = {}) {
+  const r = t.filter((s) => s.id === e.id && s.temporal?.start != null).map(G), n = tt(
+    r,
+    Date.parse(e.temporal?.end ?? ""),
+    i
+  );
+  return n ? { source: n.chunk.source, time: n.time } : null;
+}
+function qt(t, e) {
+  return it(G(t), e.map(G))?.source ?? null;
+}
+const mt = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+function Et(t) {
+  return t instanceof Date ? t.getTime() : typeof t == "number" ? t : new Date(t).getTime();
+}
+function Y(t, e) {
+  const i = Et(t);
+  if (!Number.isFinite(i))
+    throw new Error(`Invalid ${e}`);
+  return i;
+}
+function ee(t, e) {
+  const i = e.match(mt);
+  if (!i)
+    throw new Error(`Invalid trailing time duration: ${e}`);
+  const r = i.slice(1).map((y) => Number(y ?? 0));
+  if (!r.some((y) => y > 0))
+    throw new Error("Trailing time duration must be positive");
+  const [n, s, o, a, d, c, l] = r, h = new Date(t), f = h.getUTCFullYear() * 12 + h.getUTCMonth() - n * 12 - s, 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 + d) * 60 + c) * 6e4 - l * 1e3;
+}
+function $t(t, [e, i]) {
+  let r = e, n = i;
+  if (typeof t.trailing == "string" ? r = ee(i, t.trailing) : (t.start != null && (r = Y(t.start, "time range start")), t.end != null && (n = Y(t.end, "time range end"))), r > n)
+    throw new Error("Time range start must not follow its end");
+  return [Math.max(e, r), Math.min(i, n)];
+}
+const pt = (t) => typeof t == "object" && t !== null && !Array.isArray(t);
+function Wt(t, e) {
+  if (!pt(t))
+    throw new Error(`${e} must be an object`);
+  for (const s of Object.keys(t))
+    if (s !== "start" && s !== "end" && s !== "trailing")
+      throw new Error(`${e}.${s} is not a time range key`);
+  if (t.trailing !== void 0) {
+    if (t.start !== void 0 || t.end !== void 0)
+      throw new Error(`${e}.trailing excludes start and end`);
+    if (typeof t.trailing != "string")
+      throw new Error(`${e}.trailing must be an ISO 8601 duration`);
+    return ee(0, t.trailing), { trailing: t.trailing };
+  }
+  const i = (s) => {
+    const o = t[s];
+    if (o !== void 0) {
+      if (typeof o != "string" || !Number.isFinite(Date.parse(o)))
+        throw new Error(`${e}.${s} is not a date`);
+      return o;
+    }
+  }, r = i("start"), n = i("end");
+  if (r !== void 0 && n !== void 0 && Date.parse(r) > Date.parse(n))
+    throw new Error(`${e}.start must not follow its end`);
+  return {
+    ...r !== void 0 && { start: r },
+    ...n !== void 0 && { end: n }
+  };
+}
+function Ht(t) {
+  return t.type === "geovideo" && typeof t.indexUrl == "string";
+}
+function Yt(t, e) {
+  return t.id === e.id && (t.type !== "geovideo" || e.type !== "geovideo" || t.manifestUrl === e.manifestUrl);
+}
+function j(t) {
+  return typeof t == "string" && Number.isFinite(Date.parse(t));
+}
+function Tt(t) {
+  const e = t;
+  if (!e || e.schemaVersion !== 1 || e.type !== "geovideo-index" || !Array.isArray(e.chunks))
+    throw new Error("Unsupported GeoVideo index");
+  for (const i of e.chunks)
+    if (!j(i?.start) || !j(i.end) || Date.parse(i.end) < Date.parse(i.start) || typeof i.manifestUrl != "string")
+      throw new Error("Invalid GeoVideo index chunk");
+  return e;
+}
+async function jt(t, e) {
+  const i = await fetch(t, { signal: e });
+  if (!i.ok)
+    throw new Error(
+      `GeoVideo index request failed (${i.status}): ${t}`
+    );
+  return Tt(await i.json());
+}
+function bt(t) {
+  return typeof document < "u" ? new URL(t, document.baseURI).href : t;
+}
+function Rt(t, e) {
+  const i = bt(e);
+  return t.chunks.map((r) => ({
+    key: r.key,
+    manifestUrl: new URL(r.manifestUrl, i).href,
+    start: Date.parse(r.start),
+    end: Date.parse(r.end),
+    samples: r.samples,
+    ...r.provisional ? { provisional: !0 } : {}
+  }));
+}
+function gt(t, e, i) {
+  if (e.sourceId !== t.id || e.catalogEntryId !== i.id)
+    throw new Error(
+      `GeoVideo index identity does not match catalog entry/source: ${t.id}`
+    );
+}
+function Kt(t, e, i) {
+  gt(t, e, i);
+  const r = Rt(e, t.indexUrl);
+  return e.chunks.map(
+    (n, s) => ({
+      id: t.id,
+      type: "geovideo",
+      title: t.title,
+      provenance: t.provenance,
+      temporal: {
+        mode: "fixed",
+        cadence: t.temporal?.cadence,
+        start: n.start,
+        end: n.end
+      },
+      manifestUrl: r[s].manifestUrl
+    })
+  );
+}
+export {
+  ee as $,
+  Ht as A,
+  Ot as B,
+  jt as C,
+  Kt as D,
+  $t as E,
+  Vt as F,
+  Xt as G,
+  W as H,
+  Bt as I,
+  ft as J,
+  ut as K,
+  J as L,
+  ze as M,
+  et as N,
+  xe as O,
+  gt as P,
+  Q,
+  O as R,
+  Ve as S,
+  Gt as T,
+  rt as U,
+  Rt as V,
+  tt as W,
+  qt as X,
+  it as Y,
+  Wt as Z,
+  Ze as _,
+  St as a,
+  R as a0,
+  N as a1,
+  Tt as a2,
+  ht as a3,
+  Ut as b,
+  _t as c,
+  At as d,
+  kt as e,
+  vt as f,
+  Pt as g,
+  yt as h,
+  Ft as i,
+  xt as j,
+  Mt as k,
+  It as l,
+  qe as m,
+  Ke as n,
+  Ue as o,
+  $e as p,
+  wt as q,
+  Me as r,
+  Dt as s,
+  Y as t,
+  w as u,
+  Lt as v,
+  Yt as w,
+  Ct as x,
+  z as y,
+  Nt as z
+};