@fxi/zartigl 0.5.0 → 0.7.0

package/dist/geovideo-index-CMGVia5M.js

@@ -0,0 +1,1148 @@
+const $ = { label: "Thermal", tags: ["sequential", "temperature"], colors: ["#042333", "#2c3395", "#744796", "#b15f82", "#eb7958", "#fbb43d", "#e8fa5b"] }, W = { label: "Haline", tags: ["sequential", "salinity"], colors: ["#2a186c", "#17568b", "#1a7e8f", "#22a785", "#55c666", "#aadc32", "#fde333"] }, H = { label: "Solar", tags: ["sequential", "irradiance"], colors: ["#330f0b", "#6b2313", "#a83c12", "#d6621a", "#f3951e", "#f7c741", "#f9f871"] }, Y = { label: "Ice", tags: ["sequential"], colors: ["#040d1a", "#123365", "#1c5f9e", "#2b8ece", "#62bde3", "#aaddf2", "#f2faff"] }, z = { label: "Deep", tags: ["sequential", "depth"], colors: ["#fdfecc", "#c8e59b", "#74c8a3", "#3194b0", "#2a5b8e", "#281a5e", "#0c0820"] }, j = { label: "RdYlBu", tags: ["diverging"], colors: ["#3288bd", "#66c2a5", "#abdda4", "#e6f598", "#fee08b", "#fdae61", "#f46d43", "#d53e4f"] }, K = { label: "Dense", tags: ["sequential"], colors: ["#e6f1f1", "#92c4ca", "#44929a", "#20627a", "#1a3c6a", "#211a50", "#0d0621"] }, J = { label: "Algae", tags: ["sequential", "biology", "log"], colors: ["#d7f9d0", "#a2d595", "#64b463", "#129450", "#126e45", "#1a482f", "#122414"] }, Q = { label: "Oxygen", tags: ["sequential", "biology", "hypoxia"], colors: ["#09060f", "#5b1028", "#d43d2f", "#f39b3d", "#f3e7b3", "#79cbd1", "#176b9c"] }, Z = { label: "Matter", tags: ["sequential", "biology"], colors: ["#fdfecc", "#f2c98a", "#e07c4e", "#bc3754", "#8d1a6d", "#51156b", "#1c0c3f"] }, ee = { label: "Viridis", tags: ["sequential", "perceptual"], colors: ["#440154", "#443983", "#31688e", "#21918c", "#35b779", "#90d743", "#fde725"] }, te = { label: "Plasma", tags: ["sequential", "perceptual"], colors: ["#0d0887", "#5e01a6", "#9c179e", "#cc4778", "#ed7953", "#fdb42f", "#f0f921"] }, re = { label: "Cyclic", tags: ["cyclic", "direction"], colors: ["#2e22ea", "#b541fb", "#fc93c0", "#f1ee35", "#77c80d", "#458776", "#2c24e9"] }, ne = { label: "Tempo", tags: ["sequential"], colors: ["#fff6f4", "#c2d1b9", "#7db390", "#2a937f", "#156d73", "#1c455b", "#151d44"] }, ae = { label: "Turbid", tags: ["sequential", "biology", "log"], colors: ["#e9f5a0", "#c8c86e", "#a09845", "#786031", "#533324", "#341423", "#150d17"] }, ie = { label: "Speed", tags: ["sequential", "velocity"], colors: ["#fcfea4", "#d5e429", "#94c63e", "#52a657", "#2d8169", "#1d5b6d", "#0d3361"] }, oe = { label: "Amp", tags: ["sequential"], colors: ["#f2f2f2", "#c0b8db", "#9180b6", "#6c4e9e", "#4e2e83", "#32185d", "#110a35"] }, se = { label: "Balance", tags: ["diverging"], colors: ["#181c43", "#3066af", "#9bbcdd", "#f2f2f2", "#e07d53", "#b13626", "#2c0b0e"] }, ce = { label: "Delta", tags: ["diverging"], colors: ["#0e3f31", "#20877b", "#99d4c1", "#f2f2f2", "#a1b0d4", "#3c5b9e", "#0d1938"] }, de = { label: "Curl", tags: ["diverging"], colors: ["#152237", "#2471b3", "#8dbac4", "#f2f2f2", "#c79f84", "#a63827", "#270b17"] }, ue = { label: "Gray", tags: ["sequential"], colors: ["#000000", "#252525", "#4d4d4d", "#7a7a7a", "#a8a8a8", "#d4d4d4", "#ffffff"] }, g = {
+  thermal: $,
+  "thermal-alt": { label: "Thermal Alt", tags: ["sequential", "temperature"], colors: ["#176b9c", "#79cbd1", "#f3e7b3", "#f39b3d", "#d43d2f", "#5b1028", "#09060f"] },
+  haline: W,
+  solar: H,
+  ice: Y,
+  deep: z,
+  rdylbu: j,
+  dense: K,
+  algae: J,
+  oxygen: Q,
+  matter: Z,
+  viridis: ee,
+  plasma: te,
+  cyclic: re,
+  tempo: ne,
+  turbid: ae,
+  speed: ie,
+  amp: oe,
+  balance: se,
+  delta: ce,
+  curl: de,
+  "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: ue
+};
+function I(e) {
+  const t = {}, r = e.length - 1;
+  return e.forEach((n, a) => {
+    t[r === 0 ? 0 : a / r] = n;
+  }), t;
+}
+function fe(e, t) {
+  const r = g;
+  if (typeof e == "string") {
+    const n = r[e];
+    if (!n)
+      throw new Error(
+        `Palette "${e}" not found. Available palettes: ${Object.keys(
+          r
+        ).join(", ")}`
+      );
+    const a = t?.reverse ? [...n.colors].reverse() : n.colors;
+    return I(a);
+  }
+  if (Array.isArray(e)) {
+    const n = t?.reverse ? [...e].reverse() : e;
+    return I(n);
+  }
+  return e;
+}
+function Ye() {
+  return Object.entries(g).map(([t, r]) => ({ id: t, ...r }));
+}
+function N(e, t, r) {
+  const n = e.createShader(t);
+  if (!n)
+    throw new Error("Failed to create shader");
+  if (e.shaderSource(n, r), e.compileShader(n), !e.getShaderParameter(n, e.COMPILE_STATUS)) {
+    const a = e.getShaderInfoLog(n);
+    throw e.deleteShader(n), new Error(`Shader compile error: ${a}`);
+  }
+  return n;
+}
+function ze(e, t, r) {
+  const n = e.createProgram();
+  if (!n)
+    throw new Error("Failed to create program");
+  const a = N(e, e.VERTEX_SHADER, t), i = N(e, e.FRAGMENT_SHADER, r);
+  if (e.attachShader(n, a), e.attachShader(n, i), e.linkProgram(n), !e.getProgramParameter(n, e.LINK_STATUS)) {
+    const s = e.getProgramInfoLog(n);
+    throw e.deleteProgram(n), new Error(`Program link error: ${s}`);
+  }
+  return e.deleteShader(a), e.deleteShader(i), n;
+}
+function je(e, t, r, n, a) {
+  const i = e.createTexture();
+  if (!i)
+    throw new Error("Failed to create texture");
+  return e.bindTexture(e.TEXTURE_2D, i), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, 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, t), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, t), e.texImage2D(
+    e.TEXTURE_2D,
+    0,
+    e.RGBA,
+    n,
+    a,
+    0,
+    e.RGBA,
+    e.UNSIGNED_BYTE,
+    r
+  ), e.bindTexture(e.TEXTURE_2D, null), i;
+}
+function le(e, t, r) {
+  const n = e.getParameter(
+    e.TEXTURE_BINDING_2D
+  ), a = e.getParameter(
+    e.FRAMEBUFFER_BINDING
+  ), i = e.createTexture(), s = e.createFramebuffer();
+  if (!i || !s)
+    return i && e.deleteTexture(i), s && e.deleteFramebuffer(s), e.bindTexture(e.TEXTURE_2D, n), e.bindFramebuffer(e.FRAMEBUFFER, a), !1;
+  let o = !1;
+  try {
+    e.bindTexture(e.TEXTURE_2D, i), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, 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, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texImage2D(
+      e.TEXTURE_2D,
+      0,
+      t,
+      1,
+      1,
+      0,
+      e.RGBA,
+      r,
+      null
+    ), e.bindFramebuffer(e.FRAMEBUFFER, s), e.framebufferTexture2D(
+      e.FRAMEBUFFER,
+      e.COLOR_ATTACHMENT0,
+      e.TEXTURE_2D,
+      i,
+      0
+    ), o = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+  } finally {
+    e.bindFramebuffer(e.FRAMEBUFFER, a), e.bindTexture(e.TEXTURE_2D, n), e.deleteFramebuffer(s), e.deleteTexture(i);
+  }
+  return o;
+}
+function he(e) {
+  return {
+    kind: "rgba8-packed",
+    internalFormat: e.RGBA,
+    type: e.UNSIGNED_BYTE
+  };
+}
+function Ke(e) {
+  if (typeof WebGL2RenderingContext > "u" || !(e instanceof WebGL2RenderingContext))
+    throw new Error("zartigl requires WebGL2");
+  return e;
+}
+function Je(e) {
+  const t = [];
+  e.getExtension("EXT_color_buffer_float") ? t.push(
+    { kind: "float32", internalFormat: e.RGBA32F, type: e.FLOAT },
+    { kind: "float16", internalFormat: e.RGBA16F, type: e.HALF_FLOAT }
+  ) : e.getExtension("EXT_color_buffer_half_float") && t.push({
+    kind: "float16",
+    internalFormat: e.RGBA16F,
+    type: e.HALF_FLOAT
+  });
+  for (const r of t)
+    if (le(
+      e,
+      r.internalFormat,
+      r.type
+    ))
+      return r;
+  return he(e);
+}
+function Qe(e, t, r, n, a, i, s) {
+  const o = e.createTexture();
+  if (!o)
+    throw new Error("Failed to create texture");
+  return e.bindTexture(e.TEXTURE_2D, o), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, 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, t), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, t), e.texImage2D(
+    e.TEXTURE_2D,
+    0,
+    i,
+    n,
+    a,
+    0,
+    e.RGBA,
+    s,
+    r
+  ), e.bindTexture(e.TEXTURE_2D, null), o;
+}
+function Ze(e, t, r) {
+  e.activeTexture(e.TEXTURE0 + r), e.bindTexture(e.TEXTURE_2D, t);
+}
+function et(e, t) {
+  const r = e.createFramebuffer();
+  if (!r)
+    throw new Error("Failed to create framebuffer");
+  return e.bindFramebuffer(e.FRAMEBUFFER, r), e.framebufferTexture2D(
+    e.FRAMEBUFFER,
+    e.COLOR_ATTACHMENT0,
+    e.TEXTURE_2D,
+    t,
+    0
+  ), e.bindFramebuffer(e.FRAMEBUFFER, null), r;
+}
+function tt(e) {
+  const t = e.createBuffer();
+  if (!t)
+    throw new Error("Failed to create buffer");
+  return e.bindBuffer(e.ARRAY_BUFFER, t), e.bufferData(
+    e.ARRAY_BUFFER,
+    new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+    e.STATIC_DRAW
+  ), t;
+}
+const me = {
+  0: "#3288bd",
+  0.1: "#66c2a5",
+  0.2: "#abdda4",
+  0.3: "#e6f598",
+  0.4: "#fee08b",
+  0.5: "#fdae61",
+  0.6: "#f46d43",
+  1: "#d53e4f"
+};
+function rt(e, t) {
+  const r = t != null ? fe(t) : me, n = document.createElement("canvas");
+  n.width = 256, n.height = 1;
+  const a = n.getContext("2d"), i = a.createLinearGradient(0, 0, 256, 0);
+  for (const [o, c] of Object.entries(r))
+    i.addColorStop(Number(o), c);
+  a.fillStyle = i, a.fillRect(0, 0, 256, 1);
+  const s = e.createTexture();
+  if (!s)
+    throw new Error("Failed to create color ramp texture");
+  return e.bindTexture(e.TEXTURE_2D, s), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, 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, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, n), e.bindTexture(e.TEXTURE_2D, null), s;
+}
+function nt(e) {
+  const t = e.getExtension("WEBGL_debug_renderer_info");
+  return {
+    vendor: String(e.getParameter(e.VENDOR) ?? ""),
+    renderer: String(e.getParameter(e.RENDERER) ?? ""),
+    unmaskedVendor: t ? String(e.getParameter(t.UNMASKED_VENDOR_WEBGL) ?? "") : void 0,
+    unmaskedRenderer: t ? String(e.getParameter(t.UNMASKED_RENDERER_WEBGL) ?? "") : void 0,
+    version: String(e.getParameter(e.VERSION) ?? "")
+  };
+}
+function at(e) {
+  return {
+    program: e.getParameter(e.CURRENT_PROGRAM),
+    activeTexture: e.getParameter(e.ACTIVE_TEXTURE),
+    arrayBuffer: e.getParameter(e.ARRAY_BUFFER_BINDING),
+    elementBuffer: e.getParameter(e.ELEMENT_ARRAY_BUFFER_BINDING),
+    framebuffer: e.getParameter(e.FRAMEBUFFER_BINDING),
+    blend: e.isEnabled(e.BLEND),
+    depthTest: e.isEnabled(e.DEPTH_TEST),
+    stencilTest: e.isEnabled(e.STENCIL_TEST),
+    viewport: e.getParameter(e.VIEWPORT),
+    blendFunc: [
+      e.getParameter(e.BLEND_SRC_RGB),
+      e.getParameter(e.BLEND_DST_RGB)
+    ]
+  };
+}
+function it(e, t) {
+  e.useProgram(t.program), e.activeTexture(t.activeTexture), e.bindBuffer(e.ARRAY_BUFFER, t.arrayBuffer), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, t.elementBuffer), e.bindFramebuffer(e.FRAMEBUFFER, t.framebuffer), t.blend ? e.enable(e.BLEND) : e.disable(e.BLEND), t.depthTest ? e.enable(e.DEPTH_TEST) : e.disable(e.DEPTH_TEST), t.stencilTest ? e.enable(e.STENCIL_TEST) : e.disable(e.STENCIL_TEST), e.viewport(t.viewport[0], t.viewport[1], t.viewport[2], t.viewport[3]), e.blendFunc(t.blendFunc[0], t.blendFunc[1]);
+}
+const L = 20, Ee = 600;
+function Te(e) {
+  const t = Math.max(0, Math.min(1, e));
+  return L * Math.pow(Ee / L, t);
+}
+function ot(e) {
+  return Math.exp(-1 / Te(e));
+}
+const pe = 0.8, be = 120, we = 300;
+class st {
+  constructor(t) {
+    this.base = t, this.moving = !1, this.start = 0, this.duration = 0, this.from = t, this.to = t;
+  }
+  /** Configured opacity, applied at once unless the camera moves. */
+  setBase(t) {
+    this.base = t, this.moving || (this.from = t, this.to = t, this.duration = 0);
+  }
+  setMoving(t, r) {
+    t !== this.moving && (this.from = this.value(r), this.moving = t, this.to = t ? pe : this.base, this.start = r, this.duration = t ? be : we);
+  }
+  value(t) {
+    if (this.duration === 0)
+      return this.to;
+    const r = Math.min(1, Math.max(0, (t - this.start) / this.duration));
+    return r === 1 ? (this.duration = 0, this.from = this.to, this.to) : this.from + (this.to - this.from) * r * r * (3 - 2 * r);
+  }
+}
+function ct(e) {
+  if (e == null)
+    return null;
+  if (!Number.isFinite(e[0]) || !Number.isFinite(e[1]) || e[0] >= e[1])
+    throw new RangeError(
+      "colorDomain must contain two finite, increasing values"
+    );
+  return [e[0], e[1]];
+}
+function m(e, t) {
+  if (typeof e != "number" || !Number.isFinite(e))
+    throw new Error(`Invalid GeoVideo manifest ${t}`);
+  return e;
+}
+function F(e, t) {
+  if (typeof e != "string")
+    throw new Error(`Invalid GeoVideo manifest ${t}`);
+  const r = new Date(e).getTime();
+  if (!Number.isFinite(r))
+    throw new Error(`Invalid GeoVideo manifest ${t}`);
+  return r;
+}
+function D(e) {
+  return typeof e == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(
+    e
+  );
+}
+function V(e) {
+  if (!e || typeof e != "object")
+    throw new Error("Invalid GeoVideo manifest");
+  const t = e;
+  if (t.schemaVersion !== 3 || t.type !== "geovideo")
+    throw new Error("Unsupported GeoVideo manifest version or type");
+  if (t.projection !== "equirectangular")
+    throw new Error(
+      `Unsupported GeoVideo projection: ${String(t.projection)}`
+    );
+  if (!Array.isArray(t.bounds) || t.bounds.length !== 4)
+    throw new Error("Invalid GeoVideo manifest bounds");
+  const [r, n, a, i] = t.bounds.map(
+    (f, T) => m(f, `bounds[${T}]`)
+  );
+  if (n < -90 || i > 90 || n >= i || r === a)
+    throw new Error("Invalid GeoVideo geographic bounds");
+  const s = t.media;
+  if (!s || typeof s.url != "string" || !s.url)
+    throw new Error("Invalid GeoVideo media");
+  for (const f of ["width", "height", "fps", "durationSeconds"])
+    if (m(s[f], `media.${f}`) <= 0)
+      throw new Error(`Invalid GeoVideo media.${f}`);
+  const o = t.encoding;
+  if (!o || o.bits !== 8 || o.colorSpace !== "bt709" || o.colorRange !== "limited" && o.colorRange !== "full")
+    throw new Error("Invalid GeoVideo encoding");
+  const c = m(o.codeMin, "encoding.codeMin"), d = m(o.codeMax, "encoding.codeMax");
+  if (c < 0 || d > 255 || c >= d)
+    throw new Error("Invalid GeoVideo code range");
+  let h = s.height;
+  if (o.kind === "scalar-luma") {
+    if (o.transfer !== "linear" || m(o.valueMin, "encoding.valueMin") >= m(o.valueMax, "encoding.valueMax"))
+      throw new Error("Invalid GeoVideo scalar-luma encoding");
+  } else if (o.kind === "vector-luma") {
+    if (o.transfer !== "linear" && o.transfer !== "sqrt" || o.layout !== "stacked-uv" || m(o.valueDomain, "encoding.valueDomain") <= 0 || s.height % 2 !== 0)
+      throw new Error("Invalid GeoVideo vector-luma encoding");
+    h = s.height / 2;
+  } else
+    throw new Error("Unsupported GeoVideo encoding");
+  const u = t.mask;
+  if (!u || u.kind !== "static-validity" || typeof u.url != "string" || !u.url || m(u.width, "mask.width") !== s.width || m(u.height, "mask.height") !== h || m(u.threshold, "mask.threshold") < 0 || u.threshold > 1)
+    throw new Error("Invalid GeoVideo static mask");
+  if (t.timeline?.kind === "range") {
+    const f = F(t.timeline.dateStart, "timeline.dateStart");
+    if (F(t.timeline.dateEnd, "timeline.dateEnd") <= f)
+      throw new Error("GeoVideo timeline end must follow start");
+    if (t.timeline.interpolation !== "linear" && t.timeline.interpolation !== "nearest")
+      throw new Error("Invalid GeoVideo interpolation");
+  } else if (t.timeline?.kind === "snapshot-loop")
+    F(t.timeline.date, "timeline.date");
+  else if (t.timeline?.kind === "sample-sequence") {
+    if (!Array.isArray(t.timeline.values) || t.timeline.values.length === 0)
+      throw new Error("GeoVideo sample sequence must contain values");
+    const f = t.timeline.values.map(
+      (T, b) => F(T, `timeline.values[${b}]`)
+    );
+    if (f.some((T, b) => b > 0 && T <= f[b - 1]))
+      throw new Error(
+        "GeoVideo sample sequence values must be strictly increasing"
+      );
+  } else
+    throw new Error("Invalid GeoVideo timeline");
+  const E = t.style?.colorDomain;
+  if (!Array.isArray(E) || E.length !== 2 || !E.every(Number.isFinite) || E[0] >= E[1])
+    throw new Error("Invalid GeoVideo color domain");
+  if (!D(t.id) || !t.provenance || !D(t.provenance.catalogEntryId) || !D(t.provenance.inputSourceId) || !Array.isArray(t.provenance.variables) || t.provenance.variables.length === 0)
+    throw new Error("Invalid GeoVideo provenance");
+  return { ...t, bounds: [r, n, a, i] };
+}
+async function Re(e, t) {
+  if (typeof e != "string")
+    return V(e);
+  const r = await fetch(e, { signal: t });
+  if (!r.ok)
+    throw new Error(
+      `GeoVideo manifest request failed (${r.status}): ${e}`
+    );
+  const n = await r.json(), a = V(n), i = typeof document < "u" ? new URL(e, document.baseURI).href : e;
+  return {
+    ...a,
+    media: { ...a.media, url: new URL(a.media.url, i).href },
+    mask: { ...a.mask, url: new URL(a.mask.url, i).href }
+  };
+}
+function _(e) {
+  if (e.timeline.kind === "snapshot-loop")
+    return [new Date(e.timeline.date).getTime()];
+  if (e.timeline.kind === "sample-sequence")
+    return e.timeline.values.map((a) => new Date(a).getTime());
+  const t = new Date(e.timeline.dateStart).getTime(), r = new Date(e.timeline.dateEnd).getTime(), n = Math.max(
+    2,
+    Math.round(e.media.durationSeconds * e.media.fps)
+  );
+  return Array.from(
+    { length: n },
+    (a, i) => t + (r - t) * i / (n - 1)
+  );
+}
+function _e(e) {
+  return e.timeline.kind === "sample-sequence" ? e.timeline.values.length / e.media.durationSeconds : e.media.fps;
+}
+function dt(e, t) {
+  return t / _e(e);
+}
+function Ae(e, t) {
+  if (e.timeline.kind === "snapshot-loop")
+    return 0;
+  if (e.timeline.kind === "sample-sequence") {
+    const i = _(e);
+    let s = 0;
+    for (let c = 1; c < i.length; c += 1)
+      Math.abs(i[c] - t) < Math.abs(i[s] - t) && (s = c);
+    const o = e.media.durationSeconds / i.length;
+    return s * o + Math.min(o / 2, 0.5 / e.media.fps);
+  }
+  const r = new Date(e.timeline.dateStart).getTime(), n = new Date(e.timeline.dateEnd).getTime();
+  return Math.max(0, Math.min(1, (t - r) / (n - r))) * X(e);
+}
+function ut(e, t) {
+  if (e.timeline.kind === "snapshot-loop")
+    return new Date(e.timeline.date).getTime();
+  if (e.timeline.kind === "sample-sequence") {
+    const s = _(e), o = e.media.durationSeconds / s.length, c = Math.floor((t + 0.25 / e.media.fps) / o);
+    return s[Math.max(0, Math.min(s.length - 1, c))];
+  }
+  const r = new Date(e.timeline.dateStart).getTime(), n = new Date(e.timeline.dateEnd).getTime(), a = X(e), i = a > 0 ? Math.max(0, Math.min(1, t / a)) : 0;
+  return r + (n - r) * i;
+}
+function X(e) {
+  return Math.max(0, e.media.durationSeconds - 1 / e.media.fps);
+}
+function Fe(e, t) {
+  const r = new Uint8Array(e.length / 4);
+  for (let n = 0; n < r.length; n++) {
+    const a = e[n * 4];
+    r[n] = t === "limited" ? Math.round(a * 219 / 255 + 16) : a;
+  }
+  return r;
+}
+class xe {
+  constructor() {
+    this.gl = null, this.texture = null, this.framebuffer = null;
+  }
+  read(t, r, n) {
+    const a = this.context();
+    a.bindTexture(a.TEXTURE_2D, this.texture), a.pixelStorei(a.UNPACK_FLIP_Y_WEBGL, !1), a.pixelStorei(a.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), a.pixelStorei(a.UNPACK_COLORSPACE_CONVERSION_WEBGL, a.NONE), a.texParameteri(a.TEXTURE_2D, a.TEXTURE_MIN_FILTER, a.NEAREST), a.texParameteri(a.TEXTURE_2D, a.TEXTURE_MAG_FILTER, a.NEAREST), a.texParameteri(a.TEXTURE_2D, a.TEXTURE_WRAP_S, a.CLAMP_TO_EDGE), a.texParameteri(a.TEXTURE_2D, a.TEXTURE_WRAP_T, a.CLAMP_TO_EDGE), a.texImage2D(a.TEXTURE_2D, 0, a.RGBA, a.RGBA, a.UNSIGNED_BYTE, t), a.bindFramebuffer(a.FRAMEBUFFER, this.framebuffer), a.framebufferTexture2D(
+      a.FRAMEBUFFER,
+      a.COLOR_ATTACHMENT0,
+      a.TEXTURE_2D,
+      this.texture,
+      0
+    );
+    const i = new Uint8Array(r * n * 4);
+    return a.readPixels(0, 0, r, n, a.RGBA, a.UNSIGNED_BYTE, i), a.bindFramebuffer(a.FRAMEBUFFER, null), i;
+  }
+  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 t = document.createElement("canvas"), r = {
+      premultipliedAlpha: !1,
+      antialias: !1
+    }, n = t.getContext("webgl2", r);
+    if (!n)
+      throw new Error("WebGL2 is required to decode GeoVideo frames");
+    return this.gl = n, this.texture = n.createTexture(), this.framebuffer = n.createFramebuffer(), n;
+  }
+}
+function C(e) {
+  const t = Math.max(4, Math.floor(e.length / 4 / 997) * 4);
+  for (let r = 3; r < e.length; r += t)
+    if (e[r] !== 0)
+      return !1;
+  return !0;
+}
+function l() {
+  return new DOMException("GeoVideo frame request was cancelled", "AbortError");
+}
+function R(e, t, r) {
+  return t ? t.aborted ? (e.catch(() => {
+  }), r?.(), Promise.reject(l())) : new Promise((n, a) => {
+    const i = () => {
+      r?.(), a(l());
+    };
+    t.addEventListener("abort", i, { once: !0 }), e.then(n, a).finally(() => {
+      t.removeEventListener("abort", i);
+    });
+  }) : e;
+}
+function M(e, t) {
+  return new Promise(
+    (r) => e.addEventListener(t, () => r(), { once: !0 })
+  );
+}
+const ve = 250;
+function ye(e) {
+  return "requestVideoFrameCallback" in e ? Promise.race([
+    new Promise(
+      (t) => e.requestVideoFrameCallback(() => t())
+    ),
+    new Promise((t) => setTimeout(t, ve))
+  ]) : Promise.resolve();
+}
+class O {
+  constructor(t, r, n = {}) {
+    this.reader = new xe(), this.video = null, this.mask = 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 = t, this.planes = r, this.cacheSize = Math.max(1, n.cacheSize ?? 3), this.width = t.media.width, this.height = t.media.height / r, this.times = Float64Array.from(_(t));
+  }
+  init() {
+    return this.initPromise ??= this.load().catch((t) => {
+      throw this.initPromise = null, t;
+    }), this.initPromise;
+  }
+  /** Abort every pending frame decode; frames already decoded stay cached. */
+  cancelAll() {
+    for (const t of [...this.pending])
+      this.drop(t);
+  }
+  /** 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.mask = 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(t, r = {}) {
+    const { signal: n } = r;
+    if (n?.aborted)
+      return Promise.reject(l());
+    let a = this.frames.get(t);
+    if (a ? (this.frames.delete(t), this.frames.set(t, a)) : a = this.enqueue(t), a.settled)
+      return a.promise;
+    const i = a;
+    return i.waiters++, R(i.promise, n, () => this.leave(i));
+  }
+  enqueue(t) {
+    const r = new AbortController(), n = this.queue.then(
+      () => r.signal.aborted ? Promise.reject(l()) : this.decode(t, r.signal)
+    );
+    this.queue = n.catch(() => {
+    });
+    const a = {
+      index: t,
+      controller: r,
+      promise: R(n, r.signal),
+      waiters: 0,
+      settled: !1
+    };
+    for (this.pending.add(a), a.promise.then(
+      () => {
+        a.settled = !0, this.pending.delete(a);
+      },
+      () => {
+        a.settled = !0, this.pending.delete(a), this.frames.get(t) === a && this.frames.delete(t);
+      }
+    ), this.frames.set(t, a); this.frames.size > this.cacheSize; )
+      this.frames.delete(this.frames.keys().next().value);
+    return a;
+  }
+  /** A request left; drop the decode when it was the last one waiting. */
+  leave(t) {
+    t.waiters--, t.waiters <= 0 && !t.settled && this.drop(t);
+  }
+  drop(t) {
+    t.controller.abort(), this.pending.delete(t), this.frames.get(t.index) === t && this.frames.delete(t.index);
+  }
+  async load() {
+    const [t] = await Promise.all([this.loadMask(), this.loadVideo()]);
+    this.mask = t;
+  }
+  async loadMask() {
+    const { url: t, width: r, height: n } = this.manifest.mask, a = new Image();
+    a.crossOrigin = "anonymous", a.src = t;
+    try {
+      await a.decode();
+    } catch {
+      throw new Error(`Failed to load GeoVideo mask: ${t}`);
+    }
+    if (a.naturalWidth !== r || a.naturalHeight !== n)
+      throw new Error(
+        `GeoVideo mask dimensions ${a.naturalWidth}x${a.naturalHeight} do not match manifest ${r}x${n}`
+      );
+    const i = this.reader.read(a, r, n), s = new Uint8Array(r * n);
+    for (let o = 0; o < s.length; o++)
+      s[o] = i[o * 4];
+    return s;
+  }
+  async loadVideo() {
+    const t = document.createElement("video");
+    t.crossOrigin = "anonymous", t.muted = !0, t.playsInline = !0, t.preload = "metadata", t.src = this.manifest.media.url, this.video = t, await new Promise((r, n) => {
+      t.addEventListener("loadedmetadata", () => r(), {
+        once: !0
+      }), t.addEventListener(
+        "error",
+        () => n(
+          new Error(
+            `Failed to load GeoVideo media: ${this.manifest.media.url}`
+          )
+        ),
+        { once: !0 }
+      );
+    });
+  }
+  /** Seek to a frame and wait until it is presented. */
+  async presentFrame(t, r) {
+    if (this.presented && Math.abs(t.currentTime - r) <= 1e-3 && !t.seeking)
+      return;
+    const n = ye(t), a = M(t, "seeked");
+    t.currentTime = r, await a, t.readyState < HTMLMediaElement.HAVE_CURRENT_DATA && await Promise.race([M(t, "loadeddata"), M(t, "canplay")]), await n, 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(t) {
+    this.primed = !0;
+    try {
+      await t.play();
+    } catch {
+    }
+    t.pause(), this.presented = !1;
+  }
+  /**
+   * Seek, read back and decode one step. `signal` aborts it between steps;
+   * a seek already started completes first, keeping the queue serial.
+   */
+  async decode(t, r) {
+    if (r.aborted)
+      throw l();
+    await this.init();
+    const n = this.video, a = this.mask;
+    if (r.aborted || !n || !a)
+      throw l();
+    const i = Ae(this.manifest, this.times[t]);
+    if (await this.presentFrame(n, i), r.aborted || n !== this.video)
+      throw l();
+    const s = this.height * this.planes;
+    let o = this.reader.read(n, this.width, s);
+    if (C(o) && !this.primed) {
+      if (await this.primeDecoder(n), await this.presentFrame(n, i), r.aborted || n !== this.video)
+        throw l();
+      o = this.reader.read(n, this.width, s);
+    }
+    if (C(o))
+      throw new Error("GeoVideo frame could not be read back from the decoder");
+    const c = Fe(o, this.manifest.encoding.colorRange);
+    return this.decodeCodes(c, a, this.manifest.mask.threshold);
+  }
+}
+function De(e, t) {
+  let r = (e - t.codeMin) / (t.codeMax - t.codeMin) * 2 - 1;
+  return r = Math.max(-1, Math.min(1, r)), t.transfer === "sqrt" && (r = Math.sign(r) * r * r), r * t.valueDomain;
+}
+function Me(e, t, r, n) {
+  const a = t.length;
+  if (e.length !== 2 * a)
+    throw new Error(
+      `GeoVideo vector frame has ${e.length} codes, expected ${2 * a}`
+    );
+  const i = new Float32Array(256);
+  for (let d = 0; d < 256; d++)
+    i[d] = De(d, n);
+  const s = r * 255, o = new Float32Array(a), c = new Float32Array(a);
+  for (let d = 0; d < a; d++) {
+    const h = t[d] >= s;
+    o[d] = h ? i[e[d]] : NaN, c[d] = h ? i[e[a + d]] : NaN;
+  }
+  return { u: o, v: c };
+}
+class Ue extends O {
+  constructor(t, r = {}) {
+    if (t.encoding.kind !== "vector-luma")
+      throw new Error("GeoVideoVectorSource requires a vector-luma manifest");
+    super(t, 2, r), this.encoding = t.encoding;
+    const [n, a, i, s] = t.bounds, o = (i - n) / this.width, c = (s - a) / this.height;
+    this.coords = {
+      time: this.times,
+      vertical: new Float32Array([0]),
+      latitude: Float32Array.from(
+        { length: this.height },
+        (d, h) => s - (h + 0.5) * c
+      ),
+      longitude: Float32Array.from(
+        { length: this.width },
+        (d, h) => n + (h + 0.5) * o
+      )
+    };
+  }
+  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(t) {
+    const r = typeof t == "number" ? t : new Date(t).getTime(), n = this.coords.time;
+    let a = 0;
+    for (let i = 1; i < n.length; i++)
+      Math.abs(n[i] - r) < Math.abs(n[a] - r) && (a = i);
+    return a;
+  }
+  getChunksForBounds(t, r, n) {
+    const { latitude: a, longitude: i } = this.coords;
+    return [
+      {
+        timeIdx: r,
+        depthIdx: n,
+        latIdx: 0,
+        lonIdx: 0,
+        latRange: [a[0], a[this.height - 1]],
+        lonRange: [i[0], i[this.width - 1]],
+        latSize: this.height,
+        lonSize: this.width
+      }
+    ];
+  }
+  async fetchSpatialChunkResult(t, r) {
+    const n = await this.frame(r.timeIndex);
+    return {
+      data: t === "v" ? n.v : n.u,
+      missing: !1,
+      url: this.manifest.media.url
+    };
+  }
+  decodeCodes(t, r, n) {
+    return Me(t, r, n, this.encoding);
+  }
+}
+function Se(e, t) {
+  const r = Math.max(
+    0,
+    Math.min(
+      1,
+      (e - t.codeMin) / (t.codeMax - t.codeMin)
+    )
+  );
+  return t.valueMin + r * (t.valueMax - t.valueMin);
+}
+function Ge(e, t, r, n) {
+  const a = t.length;
+  if (e.length !== a)
+    throw new Error(
+      `GeoVideo scalar frame has ${e.length} codes, expected ${a}`
+    );
+  const i = new Float32Array(256);
+  for (let c = 0; c < 256; c++)
+    i[c] = Se(c, n);
+  const s = r * 255, o = new Float32Array(a);
+  for (let c = 0; c < a; c++)
+    o[c] = t[c] >= s ? i[e[c]] : NaN;
+  return o;
+}
+class Pe extends O {
+  constructor(t, r = {}) {
+    if (t.encoding.kind !== "scalar-luma")
+      throw new Error("GeoVideoScalarSource requires a scalar-luma manifest");
+    super(t, 1, r), this.encoding = t.encoding;
+  }
+  decodeCodes(t, r, n) {
+    return Ge(t, r, n, this.encoding);
+  }
+}
+function ke(e, t, r = {}) {
+  const [n, a] = r.range ?? [-1 / 0, 1 / 0], i = [...e].sort((o, c) => o.start - c.start), s = i.find(
+    (o) => o.start > t && o.start <= a
+  ) ?? (r.loop ? i.find(
+    (o) => o.end >= n && o.start <= a
+  ) : void 0);
+  return s ? { chunk: s, time: Math.max(s.start, n) } : null;
+}
+function Ie(e, t) {
+  let r = null, n = -1 / 0;
+  for (const a of t) {
+    const i = Math.min(e.end, a.end) - Math.max(e.start, a.start);
+    Number.isFinite(i) && i >= 0 && i > n && (r = a, n = i);
+  }
+  return r;
+}
+function Ne(e) {
+  return {
+    width: e.mask.width,
+    height: e.mask.height,
+    bounds: e.bounds,
+    rowOrder: "north-to-south"
+  };
+}
+function Le(e, t = {}) {
+  return e.encoding.kind === "vector-luma" ? new Ue(e, t) : new Pe(e, t);
+}
+const Ve = 3, Ce = 3, Be = 0.6, ge = 1.5;
+function Xe(e, t) {
+  const r = e.length - 1;
+  if (t <= e[0])
+    return { step: 0, fraction: 0 };
+  if (t >= e[r])
+    return { step: r, fraction: 0 };
+  let n = 0, a = r;
+  for (; a - n > 1; ) {
+    const i = n + a >> 1;
+    e[i] <= t ? n = i : a = i;
+  }
+  return { step: n, fraction: (t - e[n]) / (e[a] - e[n]) };
+}
+function Oe(e) {
+  const t = new AbortController();
+  if (!e)
+    return { controller: t, unlink: () => {
+    } };
+  const r = () => t.abort();
+  return e.aborted && r(), e.addEventListener("abort", r, { once: !0 }), {
+    controller: t,
+    unlink: () => e.removeEventListener("abort", r)
+  };
+}
+class ft {
+  constructor(t) {
+    this.manifests = /* @__PURE__ */ new Map(), this.open = /* @__PURE__ */ new Map(), this.id = t.id, this.chunks = t.chunks.filter(
+      (r) => Number.isFinite(r.start) && Number.isFinite(r.end) && r.end >= r.start
+    ).sort((r, n) => r.start - n.start), this.maxOpenChunks = Math.max(2, t.maxOpenChunks ?? Ve), this.frameCacheSize = Math.max(
+      1,
+      t.frameCacheSize ?? Ce
+    ), this.prefetchAt = t.prefetchAt ?? Be, this.maxGap = t.maxGap, this.loadManifest = t.loadManifest ?? Re, this.createFrameSource = t.createFrameSource ?? ((r, n) => Le(
+      r,
+      n
+    ));
+  }
+  /** First and last sample of the archive, or null without chunks. */
+  get range() {
+    const { chunks: t } = this;
+    return t.length ? [t[0].start, Math.max(...t.map((r) => r.end))] : null;
+  }
+  /** The chunk whose sample range holds `time`, or null. */
+  chunkAt(t) {
+    const r = this.chunkIndexAt(t), n = r >= 0 ? this.chunks[r] : null;
+    return n && t <= n.end ? n : null;
+  }
+  /** Every step time of the archive; loads all chunk manifests. */
+  async steps(t = {}) {
+    if (t.signal?.aborted)
+      throw l();
+    const r = await R(
+      Promise.all(this.chunks.map((n) => this.manifest(n))),
+      t.signal
+    );
+    return Float64Array.from(r.flatMap(_));
+  }
+  /**
+   * 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(t, r = {}) {
+    const { signal: n } = r, a = r.mode ?? "interpolate";
+    if (n?.aborted)
+      throw l();
+    const i = this.chunkIndexAt(t);
+    if (i < 0)
+      return null;
+    const s = [], { controller: o, unlink: c } = Oe(n);
+    try {
+      const d = this.acquire(this.chunks[i], s), h = await R(d.ready, o.signal), { times: u } = h;
+      let E;
+      if (t <= u[u.length - 1]) {
+        const { step: p, fraction: w } = Xe(u, t);
+        E = a === "discrete" || w === 0 ? [d, p, d, p, 0] : [d, p, d, p + 1, w];
+      } else {
+        const p = this.chunks[i + 1];
+        if (!p)
+          return null;
+        const w = this.acquire(p, s), k = await R(w.ready, o.signal), A = u.length - 1, v = u[A], y = k.times[0];
+        if (y - v > this.gapLimit(u, k.times))
+          return null;
+        E = a === "discrete" ? [d, A, d, A, 0] : t >= y ? [w, 0, w, 0, 0] : [d, A, w, 0, (t - v) / (y - v)];
+      }
+      const [f, T, b, S, q] = E, G = f === b && T === S, P = [this.frame(f, T, o.signal)];
+      G || P.push(this.frame(b, S, o.signal));
+      let x;
+      try {
+        x = await Promise.all(P);
+      } catch (p) {
+        throw o.abort(), p;
+      }
+      return this.prefetchAfter(i, t), {
+        time: t,
+        a: x[0],
+        b: x[G ? 0 : 1],
+        mix: q
+      };
+    } finally {
+      c();
+      for (const d of s)
+        d.users--;
+      this.trim();
+    }
+  }
+  /** Open `chunk` and decode its first frame ahead of a request. */
+  prefetch(t) {
+    if (this.open.has(t.key))
+      return;
+    const r = this.touch(t), n = new AbortController();
+    r.prefetch = n, r.ready.then(({ source: a }) => a.frame(0, { signal: n.signal })).catch(() => {
+    }).finally(() => {
+      r.prefetch === n && (r.prefetch = null);
+    }), this.trim();
+  }
+  /** Release every open chunk source; later requests reopen them. */
+  release() {
+    for (const t of [...this.open.values()])
+      this.close(t);
+  }
+  chunkIndexAt(t) {
+    let r = 0, n = this.chunks.length - 1, a = -1;
+    for (; r <= n; ) {
+      const i = r + n >> 1;
+      this.chunks[i].start <= t ? (a = i, r = i + 1) : n = i - 1;
+    }
+    return a;
+  }
+  gapLimit(t, r) {
+    if (this.maxGap !== void 0)
+      return this.maxGap;
+    const n = [
+      t.length > 1 ? t[t.length - 1] - t[t.length - 2] : 0,
+      r.length > 1 ? r[1] - r[0] : 0
+    ], a = Math.max(...n);
+    return a > 0 ? a * ge : -1 / 0;
+  }
+  prefetchAfter(t, r) {
+    const n = this.chunks[t], a = this.chunks[t + 1], i = n.end - n.start, s = i > 0 ? (r - n.start) / i : 1;
+    a && s > this.prefetchAt && this.prefetch(a);
+  }
+  manifest(t) {
+    let r = this.manifests.get(t.manifestUrl);
+    return r || (r = this.loadManifest(t.manifestUrl), this.manifests.set(t.manifestUrl, r), r.catch(() => {
+      this.manifests.get(t.manifestUrl) === r && this.manifests.delete(t.manifestUrl);
+    })), r;
+  }
+  /** The open chunk, pinned for a running sample listed in `used`. */
+  acquire(t, r) {
+    const n = this.touch(t);
+    return n.users++, r.push(n), n;
+  }
+  /** The open chunk, opened when needed, most recently used; not pinned. */
+  touch(t) {
+    let r = this.open.get(t.key);
+    if (r)
+      this.open.delete(t.key);
+    else {
+      const n = {
+        chunk: t,
+        ready: null,
+        opened: null,
+        users: 0,
+        prefetch: null,
+        released: !1
+      };
+      n.ready = this.manifest(t).then((a) => {
+        if (n.released)
+          throw l();
+        return n.opened = {
+          manifest: a,
+          times: Float64Array.from(_(a)),
+          grid: Ne(a),
+          source: this.createFrameSource(a, {
+            cacheSize: this.frameCacheSize
+          })
+        }, n.opened;
+      }), n.ready.catch(() => {
+        this.open.get(t.key) === n && this.open.delete(t.key);
+      }), r = n;
+    }
+    return this.open.set(t.key, r), r;
+  }
+  async frame(t, r, n) {
+    const { manifest: a, times: i, grid: s, source: o } = await R(
+      t.ready,
+      n
+    );
+    if (t.released)
+      throw l();
+    const c = await o.frame(r, { signal: n });
+    return {
+      key: `${this.id}/${t.chunk.key}/${r}`,
+      chunk: t.chunk,
+      step: r,
+      time: i[r],
+      data: c,
+      grid: s,
+      manifest: a
+    };
+  }
+  /** Release least recently used chunks beyond the bound, unless in use. */
+  trim() {
+    let t = this.open.size - this.maxOpenChunks;
+    for (const r of [...this.open.values()]) {
+      if (t <= 0)
+        return;
+      r.users === 0 && (this.close(r), t--);
+    }
+  }
+  close(t) {
+    t.released = !0, t.prefetch?.abort(), t.prefetch = null, t.opened?.source.release(), t.opened = null, this.open.get(t.chunk.key) === t && this.open.delete(t.chunk.key);
+  }
+}
+function U(e) {
+  const { start: t, end: r } = e.temporal ?? {};
+  return {
+    source: e,
+    start: Date.parse(t ?? ""),
+    end: Date.parse(r ?? t ?? "")
+  };
+}
+function lt(e, t, r = {}) {
+  const n = e.filter((i) => i.id === t.id && i.temporal?.start != null).map(U), a = ke(
+    n,
+    Date.parse(t.temporal?.end ?? ""),
+    r
+  );
+  return a ? { source: a.chunk.source, time: a.time } : null;
+}
+function ht(e, t) {
+  return Ie(U(e), t.map(U))?.source ?? null;
+}
+function mt(e) {
+  return e.type === "geovideo" && typeof e.indexUrl == "string";
+}
+function Et(e, t) {
+  return e.id === t.id && (e.type !== "geovideo" || t.type !== "geovideo" || e.manifestUrl === t.manifestUrl);
+}
+function B(e) {
+  return typeof e == "string" && Number.isFinite(Date.parse(e));
+}
+function qe(e) {
+  const t = e;
+  if (!t || t.schemaVersion !== 1 || t.type !== "geovideo-index" || !Array.isArray(t.chunks))
+    throw new Error("Unsupported GeoVideo index");
+  for (const r of t.chunks)
+    if (!B(r?.start) || !B(r.end) || Date.parse(r.end) < Date.parse(r.start) || typeof r.manifestUrl != "string")
+      throw new Error("Invalid GeoVideo index chunk");
+  return t;
+}
+async function Tt(e, t) {
+  const r = await fetch(e, { signal: t });
+  if (!r.ok)
+    throw new Error(
+      `GeoVideo index request failed (${r.status}): ${e}`
+    );
+  return qe(await r.json());
+}
+function $e(e) {
+  return typeof document < "u" ? new URL(e, document.baseURI).href : e;
+}
+function We(e, t) {
+  const r = $e(t);
+  return e.chunks.map((n) => ({
+    key: n.key,
+    manifestUrl: new URL(n.manifestUrl, r).href,
+    start: Date.parse(n.start),
+    end: Date.parse(n.end),
+    samples: n.samples,
+    ...n.provisional ? { provisional: !0 } : {}
+  }));
+}
+function He(e, t, r) {
+  if (t.sourceId !== e.id || t.catalogEntryId !== r.id)
+    throw new Error(
+      `GeoVideo index identity does not match catalog entry/source: ${e.id}`
+    );
+}
+function pt(e, t, r) {
+  He(e, t, r);
+  const n = We(t, e.indexUrl);
+  return t.chunks.map(
+    (a, i) => ({
+      id: e.id,
+      type: "geovideo",
+      title: e.title,
+      provenance: e.provenance,
+      temporal: {
+        mode: "fixed",
+        cadence: e.temporal?.cadence,
+        start: a.start,
+        end: a.end
+      },
+      manifestUrl: n[i].manifestUrl
+    })
+  );
+}
+export {
+  Tt as A,
+  pt as B,
+  V as C,
+  ft as D,
+  O as E,
+  Pe as F,
+  Ue as G,
+  He as H,
+  Le as I,
+  N as J,
+  Te as K,
+  Ne as L,
+  We as M,
+  ke as N,
+  ht as O,
+  Ie as P,
+  qe as Q,
+  st as T,
+  tt as a,
+  rt as b,
+  ze as c,
+  Je as d,
+  Qe as e,
+  et as f,
+  nt as g,
+  je as h,
+  Ze as i,
+  Ke as j,
+  it as k,
+  ot as l,
+  Re as m,
+  Ae as n,
+  fe as o,
+  ut as p,
+  _ as q,
+  he as r,
+  at as s,
+  Et as t,
+  dt as u,
+  ct as v,
+  _e as w,
+  Ye as x,
+  mt as y,
+  lt as z
+};