@eodash/eodash 5.7.0 → 5.8.0

package/dist/client/{helpers-DjZVl_WF.js → helpers-BFuh19CP.js}

@@ -1,7 +1,10 @@
 import { toAbsolute } from 'stac-js/src/http.js';
 import { setupCache } from 'axios-cache-interceptor';
 import log from 'loglevel';
-import { ref, shallowRef } from 'vue';
+import { ref, shallowRef, reactive, shallowReactive } from 'vue';
+import mustache from 'mustache';
+import { updateVectorLayerStyle } from '@eox/layercontrol';
+import { mdiWrench, mdiSnowflake, mdiVolleyball, mdiHiking, mdiLightningBolt, mdiLeaf, mdiAccountMultiple, mdiCurrencyEur, mdiWeatherWindy, mdiSetCenter, mdiHospitalBoxOutline, mdiImageFilterHdr, mdiWater, mdiBarley } from '@mdi/js';
 
 /**
  * Create a bound version of a function with a specified `this` context
@@ -426,7 +429,9 @@ function merge(...objs) {
       return;
     }
 
-    const targetKey = (caseless && findKey(result, key)) || key;
+    // findKey lowercases the key, so caseless lookup only applies to strings —
+    // symbol keys are identity-matched.
+    const targetKey = (caseless && typeof key === 'string' && findKey(result, key)) || key;
     // Read via own-prop only — a bare `result[targetKey]` walks the prototype
     // chain, so a polluted Object.prototype value could surface here and get
     // copied into the merged result.
@@ -443,7 +448,24 @@ function merge(...objs) {
   };
 
   for (let i = 0, l = objs.length; i < l; i++) {
-    objs[i] && forEach(objs[i], assignValue);
+    const source = objs[i];
+    if (!source || isBuffer(source)) {
+      continue;
+    }
+
+    forEach(source, assignValue);
+
+    if (typeof source !== 'object' || isArray(source)) {
+      continue;
+    }
+
+    const symbols = Object.getOwnPropertySymbols(source);
+    for (let j = 0; j < symbols.length; j++) {
+      const symbol = symbols[j];
+      if (propertyIsEnumerable.call(source, symbol)) {
+        assignValue(source[symbol], symbol);
+      }
+    }
   }
   return result;
 }
@@ -672,6 +694,8 @@ const hasOwnProperty = (
     hasOwnProperty.call(obj, prop)
 )(Object.prototype);
 
+const { propertyIsEnumerable } = Object.prototype;
+
 /**
  * Determine if a value is a RegExp object
  *
@@ -777,11 +801,11 @@ function isSpecCompliantForm(thing) {
  * @returns {Object} The JSON-compatible object.
  */
 const toJSONObject = (obj) => {
-  const stack = new Array(10);
+  const visited = new WeakSet();
 
-  const visit = (source, i) => {
+  const visit = (source) => {
     if (isObject(source)) {
-      if (stack.indexOf(source) >= 0) {
+      if (visited.has(source)) {
         return;
       }
 
@@ -791,15 +815,16 @@ const toJSONObject = (obj) => {
       }
 
       if (!('toJSON' in source)) {
-        stack[i] = source;
+        // add-on descent / delete-on-ascent: preserves path semantics, so DAG nodes serialise at every occurrence (see #7230).
+        visited.add(source);
         const target = isArray(source) ? [] : {};
 
         forEach(source, (value, key) => {
-          const reducedValue = visit(value, i + 1);
+          const reducedValue = visit(value);
           !isUndefined(reducedValue) && (target[key] = reducedValue);
         });
 
-        stack[i] = undefined;
+        visited.delete(source);
 
         return target;
       }
@@ -808,7 +833,7 @@ const toJSONObject = (obj) => {
     return source;
   };
 
-  return visit(obj, 0);
+  return visit(obj);
 };
 
 /**
@@ -1010,10 +1035,6 @@ const parseHeaders = (rawHeaders) => {
   return parsed;
 };
 
-const $internals = Symbol('internals');
-
-const INVALID_HEADER_VALUE_CHARS_RE = /[^\x09\x20-\x7E\x80-\xFF]/g;
-
 function trimSPorHTAB(str) {
   let start = 0;
   let end = str.length;
@@ -1041,12 +1062,40 @@ function trimSPorHTAB(str) {
   return start === 0 && end === str.length ? str : str.slice(start, end);
 }
 
-function normalizeHeader(header) {
-  return header && String(header).trim().toLowerCase();
+// The control-code ranges are intentional: header sanitization strips C0/DEL bytes.
+// eslint-disable-next-line no-control-regex
+const INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp('[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+', 'g');
+// eslint-disable-next-line no-control-regex
+const INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp('[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+', 'g');
+
+function sanitizeValue(value, invalidChars) {
+  if (utils$1.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, invalidChars));
+  }
+
+  return trimSPorHTAB(String(value).replace(invalidChars, ''));
 }
 
-function sanitizeHeaderValue(str) {
-  return trimSPorHTAB(str.replace(INVALID_HEADER_VALUE_CHARS_RE, ''));
+const sanitizeHeaderValue = (value) =>
+  sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);
+
+const sanitizeByteStringHeaderValue = (value) =>
+  sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
+
+function toByteStringHeaderObject(headers) {
+  const byteStringHeaders = Object.create(null);
+
+  utils$1.forEach(headers.toJSON(), (value, header) => {
+    byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
+  });
+
+  return byteStringHeaders;
+}
+
+const $internals = Symbol('internals');
+
+function normalizeHeader(header) {
+  return header && String(header).trim().toLowerCase();
 }
 
 function normalizeValue(value) {
@@ -1128,7 +1177,7 @@ class AxiosHeaders {
       const lHeader = normalizeHeader(_header);
 
       if (!lHeader) {
-        throw new Error('header name must be a non-empty string');
+        return;
       }
 
       const key = utils$1.findKey(self, lHeader);
@@ -1156,7 +1205,7 @@ class AxiosHeaders {
         key;
       for (const entry of header) {
         if (!utils$1.isArray(entry)) {
-          throw TypeError('Object iterator must return a key-value pair');
+          throw new TypeError('Object iterator must return a key-value pair');
         }
 
         obj[(key = entry[0])] = (dest = obj[key])
@@ -1771,7 +1820,7 @@ function toFormData(obj, formData, options) {
     }
 
     if (stack.indexOf(value) !== -1) {
-      throw Error('Circular reference detected in ' + path.join('.'));
+      throw new Error('Circular reference detected in ' + path.join('.'));
     }
 
     stack.push(value);
@@ -1988,6 +2037,7 @@ const transitionalDefaults = {
   forcedJSONParsing: true,
   clarifyTimeoutError: false,
   legacyInterceptorReqResOrdering: true,
+  advertiseZstdAcceptEncoding: false,
 };
 
 const URLSearchParams$1 = typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;
@@ -2145,7 +2195,7 @@ function formDataToJSON(formData) {
       return !isNumericKey;
     }
 
-    if (!target[name] || !utils$1.isObject(target[name])) {
+    if (!utils$1.hasOwnProp(target, name) || !utils$1.isObject(target[name])) {
       target[name] = [];
     }
 
@@ -2510,6 +2560,9 @@ const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   const _speedometer = speedometer(50, 250);
 
   return throttle((e) => {
+    if (!e || typeof e.loaded !== 'number') {
+      return;
+    }
     const rawLoaded = e.loaded;
     const total = e.lengthComputable ? e.total : undefined;
     const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
@@ -2819,12 +2872,12 @@ function setFormDataHeaders(headers, formHeaders, policy) {
  *
  * @returns {string} UTF-8 bytes as a Latin-1 string
  */
-const encodeUTF8 = (str) =>
+const encodeUTF8$1 = (str) =>
   encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) =>
     String.fromCharCode(parseInt(hex, 16))
   );
 
-const resolveConfig = (config) => {
+function resolveConfig(config) {
   const newConfig = mergeConfig({}, config);
 
   // Read only own properties to prevent prototype pollution gadgets
@@ -2845,8 +2898,8 @@ const resolveConfig = (config) => {
 
   newConfig.url = buildURL(
     buildFullPath(baseURL, url, allowAbsoluteUrls),
-    config.params,
-    config.paramsSerializer
+    own('params'),
+    own('paramsSerializer')
   );
 
   // HTTP basic authentication
@@ -2854,13 +2907,17 @@ const resolveConfig = (config) => {
     headers.set(
       'Authorization',
       'Basic ' +
-        btoa((auth.username || '') + ':' + (auth.password ? encodeUTF8(auth.password) : ''))
+        btoa((auth.username || '') + ':' + (auth.password ? encodeUTF8$1(auth.password) : ''))
     );
   }
 
   if (utils$1.isFormData(data)) {
-    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-      headers.setContentType(undefined); // browser handles it
+    if (
+      platform.hasStandardBrowserEnv ||
+      platform.hasStandardBrowserWebWorkerEnv ||
+      utils$1.isReactNative(data)
+    ) {
+      headers.setContentType(undefined); // browser/web worker/RN handles it
     } else if (utils$1.isFunction(data.getHeaders)) {
       // Node.js FormData (like form-data package)
       setFormDataHeaders(headers, data.getHeaders(), own('formDataHeaderPolicy'));
@@ -2892,7 +2949,7 @@ const resolveConfig = (config) => {
   }
 
   return newConfig;
-};
+}
 
 const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
 
@@ -3041,7 +3098,7 @@ const xhrAdapter = isXHRAdapterSupported &&
 
       // Add headers to the request
       if ('setRequestHeader' in request) {
-        utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+        utils$1.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {
           request.setRequestHeader(key, val);
         });
       }
@@ -3111,54 +3168,55 @@ const xhrAdapter = isXHRAdapterSupported &&
   };
 
 const composeSignals = (signals, timeout) => {
-  const { length } = (signals = signals ? signals.filter(Boolean) : []);
-
-  if (timeout || length) {
-    let controller = new AbortController();
-
-    let aborted;
-
-    const onabort = function (reason) {
-      if (!aborted) {
-        aborted = true;
-        unsubscribe();
-        const err = reason instanceof Error ? reason : this.reason;
-        controller.abort(
-          err instanceof AxiosError
-            ? err
-            : new CanceledError(err instanceof Error ? err.message : err)
-        );
-      }
-    };
+  signals = signals ? signals.filter(Boolean) : [];
 
-    let timer =
-      timeout &&
-      setTimeout(() => {
-        timer = null;
-        onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
-      }, timeout);
-
-    const unsubscribe = () => {
-      if (signals) {
-        timer && clearTimeout(timer);
-        timer = null;
-        signals.forEach((signal) => {
-          signal.unsubscribe
-            ? signal.unsubscribe(onabort)
-            : signal.removeEventListener('abort', onabort);
-        });
-        signals = null;
-      }
-    };
+  if (!timeout && !signals.length) {
+    return;
+  }
 
-    signals.forEach((signal) => signal.addEventListener('abort', onabort));
+  const controller = new AbortController();
 
-    const { signal } = controller;
+  let aborted = false;
 
-    signal.unsubscribe = () => utils$1.asap(unsubscribe);
+  const onabort = function (reason) {
+    if (!aborted) {
+      aborted = true;
+      unsubscribe();
+      const err = reason instanceof Error ? reason : this.reason;
+      controller.abort(
+        err instanceof AxiosError
+          ? err
+          : new CanceledError(err instanceof Error ? err.message : err)
+      );
+    }
+  };
 
-    return signal;
-  }
+  let timer =
+    timeout &&
+    setTimeout(() => {
+      timer = null;
+      onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
+    }, timeout);
+
+  const unsubscribe = () => {
+    if (!signals) { return; }
+    timer && clearTimeout(timer);
+    timer = null;
+    signals.forEach((signal) => {
+      signal.unsubscribe
+        ? signal.unsubscribe(onabort)
+        : signal.removeEventListener('abort', onabort);
+    });
+    signals = null;
+  };
+
+  signals.forEach((signal) => signal.addEventListener('abort', onabort));
+
+  const { signal } = controller;
+
+  signal.unsubscribe = () => utils$1.asap(unsubscribe);
+
+  return signal;
 };
 
 const streamChunk = function* (chunk, chunkSize) {
@@ -3352,12 +3410,41 @@ function estimateDataURLDecodedBytes(url) {
   return bytes;
 }
 
-const VERSION = "1.16.0";
+const VERSION = "1.17.0";
 
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
 const { isFunction } = utils$1;
 
+/**
+ * Encode a UTF-8 string to a Latin-1 byte string for use with btoa().
+ * This is a modern replacement for the deprecated unescape(encodeURIComponent(str)) pattern.
+ *
+ * @param {string} str The string to encode
+ *
+ * @returns {string} UTF-8 bytes as a Latin-1 string
+ */
+const encodeUTF8 = (str) =>
+  encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) =>
+    String.fromCharCode(parseInt(hex, 16))
+  );
+
+// Node's WHATWG URL parser returns `username` and `password` percent-encoded.
+// Decode before composing the `auth` option so credentials such as
+// `my%40email.com:pass` are sent as `my@email.com:pass`. Falls back to the
+// original value for malformed input so a bad encoding never throws.
+const decodeURIComponentSafe = (value) => {
+  if (!utils$1.isString(value)) {
+    return value;
+  }
+
+  try {
+    return decodeURIComponent(value);
+  } catch (error) {
+    return value;
+  }
+};
+
 const test = (fn, ...args) => {
   try {
     return !!fn(...args);
@@ -3366,8 +3453,20 @@ const test = (fn, ...args) => {
   }
 };
 
+const maybeWithAuthCredentials = (url) => {
+  const protocolIndex = url.indexOf('://');
+  let urlToCheck = url;
+  if (protocolIndex !== -1) {
+    urlToCheck = urlToCheck.slice(protocolIndex + 3);
+  }
+  return urlToCheck.includes('@') || urlToCheck.includes(':');
+};
+
 const factory = (env) => {
-  const globalObject = utils$1.global ?? globalThis;
+  const globalObject =
+    utils$1.global !== undefined && utils$1.global !== null
+      ? utils$1.global
+      : globalThis;
   const { ReadableStream, TextEncoder } = globalObject;
 
   env = utils$1.merge.call(
@@ -3510,6 +3609,7 @@ const factory = (env) => {
 
     const hasMaxContentLength = utils$1.isNumber(maxContentLength) && maxContentLength > -1;
     const hasMaxBodyLength = utils$1.isNumber(maxBodyLength) && maxBodyLength > -1;
+    const own = (key) => (utils$1.hasOwnProp(config, key) ? config[key] : undefined);
 
     let _fetch = envFetch || fetch;
 
@@ -3532,6 +3632,46 @@ const factory = (env) => {
     let requestContentLength;
 
     try {
+      // HTTP basic authentication
+      let auth = undefined;
+      const configAuth = own('auth');
+
+      if (configAuth) {
+        const username = configAuth.username || '';
+        const password = configAuth.password || '';
+        auth = {
+          username,
+          password
+        };
+      }
+
+      if (maybeWithAuthCredentials(url)) {
+        const parsedURL = new URL(url, platform.origin);
+
+        if (!auth && (parsedURL.username || parsedURL.password)) {
+          const urlUsername = decodeURIComponentSafe(parsedURL.username);
+          const urlPassword = decodeURIComponentSafe(parsedURL.password);
+          auth = {
+            username: urlUsername,
+            password: urlPassword
+          };
+        }
+
+        if (parsedURL.username || parsedURL.password) {
+          parsedURL.username = '';
+          parsedURL.password = '';
+          url = parsedURL.href;
+        }
+      }
+
+      if (auth) {
+        headers.delete('authorization');
+        headers.set(
+          'Authorization',
+          'Basic ' + btoa(encodeUTF8((auth.username || '') + ':' + (auth.password || '')))
+        );
+      }
+
       // Enforce maxContentLength for data: URLs up-front so we never materialize
       // an oversized payload. The HTTP adapter applies the same check (see http.js
       // "if (protocol === 'data:')" branch).
@@ -3624,7 +3764,7 @@ const factory = (env) => {
         ...fetchOptions,
         signal: composedSignal,
         method: method.toUpperCase(),
-        headers: headers.normalize().toJSON(),
+        headers: toByteStringHeaderObject(headers.normalize()),
         body: data,
         duplex: 'half',
         credentials: isCredentialsSupported ? withCredentials : undefined,
@@ -4213,6 +4353,7 @@ class Axios {
           forcedJSONParsing: validators.transitional(validators.boolean),
           clarifyTimeoutError: validators.transitional(validators.boolean),
           legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),
+          advertiseZstdAcceptEncoding: validators.transitional(validators.boolean),
         },
         false
       );
@@ -4699,10 +4840,6 @@ axios$1.HttpStatusCode = HttpStatusCode;
 
 axios$1.default = axios$1;
 
-const instance = axios$1.create();
-
-const axios = setupCache(instance, { cacheTakeover: false });
-
 /** setting default log level globally to warning */
 log.setLevel(log.levels.WARN, true);
 
@@ -4732,7 +4869,7 @@ const registeredProjections = ["EPSG:4326", "EPSG:3857"];
 /** available projection to be rendered by `EodashMap` */
 const availableMapProjection = ref("EPSG:3857");
 
-/** @type {import("vue").Ref<import("@eox/map").EOxMap | null>} */
+/** @type {import("vue").Ref<import("@eox/map").EOxMap & { mapUpdateId?: number } | null>} */
 const mapEl = shallowRef(null);
 
 /** @type {import("vue").Ref<import("@eox/map").EOxMap | null>} */
@@ -4776,6 +4913,24 @@ const chartSpec = ref(null);
  */
 const compareChartSpec = ref(null);
 
+/**
+ * Global loading state.
+ * - `loading.activeLoads` — increment/decrement to track concurrent loads
+ * - `loading.value` — derived boolean, true when `activeLoads > 0`
+ */
+const loading = reactive({
+  activeLoads: 0,
+  get value() {
+    return this.activeLoads > 0;
+  },
+});
+
+/**
+ * Adapter allows external widgets to hook into tooltip property transformation
+ * @type {import("vue").Ref<((param: {key: string, value: any}, map?: string) => {key: string, value: any} | undefined) | null>}
+ */
+const tooltipAdapter = shallowRef(null);
+
 const states = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   activeTemplate,
@@ -4792,13 +4947,180 @@ const states = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   datetime,
   indicator,
   isGlobe,
+  loading,
   mapCompareEl,
   mapEl,
   mapPosition,
   poi,
-  registeredProjections
+  registeredProjections,
+  tooltipAdapter
 }, Symbol.toStringTag, { value: 'Module' }));
 
+const instance = axios$1.create();
+const axios = setupCache(instance, { cacheTakeover: false });
+function installLoadingInterceptors() {
+  const reqId = axios.interceptors.request.use((config) => {
+    loading.activeLoads++;
+    return config;
+  });
+  const resId = axios.interceptors.response.use(
+    (response) => {
+      loading.activeLoads = Math.max(0, loading.activeLoads - 1);
+      return response;
+    },
+    (error) => {
+      loading.activeLoads = Math.max(0, loading.activeLoads - 1);
+      return Promise.reject(error);
+    }
+  );
+  return () => {
+    axios.interceptors.request.eject(reqId);
+    axios.interceptors.response.eject(resId);
+  };
+}
+installLoadingInterceptors();
+
+/**
+ * Array of eodash STAC Collections extracted from the current selected indicator.
+ * Updated in {@link file://./../store/stac.js `loadSelectedSTAC`} widget
+ *
+ * @type {import('../eodashSTAC/EodashCollection').EodashCollection[]}
+ * @private
+ */
+const eodashCollections = shallowReactive([]);
+
+/**
+ * Array of eodash STAC Collections extracted from the current selected COMPARE indicator.
+ * Updated in {@link file://./../store/stac.js ` loadSelectedCompareSTAC`} widget
+ *
+ * @type {import('../eodashSTAC/EodashCollection').EodashCollection[]}
+ * @private
+ */
+const eodashCompareCollections = shallowReactive([]);
+
+/** whether it's the first load of the app, used to track if there are params in the url */
+const isFirstLoad = ref(false);
+
+/**
+ * Current value of the layer control JSON form for the latest layer the user interacted with.
+ * @type {import("vue").Ref<Record<string, any> | undefined>}
+ */
+const layerControlFormValue = ref({});
+
+/**
+ * Current value of the layer control JSON form for the latest layer the user interacted with.
+ * @type {import("vue").Ref<Record<string, any> | undefined>}
+ */
+const layerControlFormValueCompare = ref({});
+
+/**
+ * STAC indicators color palette, defaults to Bank-Wong palette
+ *  @type {string[]} */
+const collectionsPalette = reactive([
+  "#009E73",
+  "#0072B2",
+  "#E69F00",
+  "#CC79A7",
+  "#56B4E9",
+  "#D55E00",
+]);
+
+/**
+ * Object containing data themes and their associated brand properties (icon and color).
+ */
+const dataThemesBrands = {
+  agriculture: {
+    icon: mdiBarley,
+    color: "#F2AF25",
+  },
+  water: {
+    icon: mdiWater,
+    color: "#73A6C7",
+  },
+  oceans: {
+    icon: mdiWater,
+    color: "#6DA2C5",
+  },
+  land: {
+    icon: mdiImageFilterHdr,
+    color: "#019E73",
+  },
+  health: {
+    icon: mdiHospitalBoxOutline,
+    color: "#32322C",
+  },
+  "covid-19": {
+    icon: mdiHospitalBoxOutline,
+    color: "#32322C",
+  },
+  combined: {
+    icon: mdiSetCenter,
+    color: "#56B4E9",
+  },
+  air: {
+    icon: mdiWeatherWindy,
+    color: "#475faf",
+  },
+  atmosphere: {
+    icon: mdiWeatherWindy,
+    color: "#475faf",
+  },
+  climate: {
+    icon: mdiWeatherWindy,
+    color: "#475faf",
+  },
+  economy: {
+    icon: mdiCurrencyEur,
+    color: "#8E81AF",
+  },
+  commerce: {
+    icon: mdiCurrencyEur,
+    color: "#8E81AF",
+  },
+  society: {
+    icon: mdiAccountMultiple,
+    color: "#8ac501",
+  },
+  biomass: {
+    icon: mdiLeaf,
+    color: "#009E73",
+  },
+  extremes: {
+    icon: mdiLightningBolt,
+    color: "#a1280a",
+  },
+  energy: {
+    icon: mdiLightningBolt,
+    color: "#475faf",
+  },
+  tourism: {
+    icon: mdiHiking,
+    color: "#80510aff",
+  },
+  sport: {
+    icon: mdiVolleyball,
+    color: "#e98e65ff",
+  },
+  cryosphere: {
+    icon: mdiSnowflake,
+    color: "#42C7B8",
+  },
+  industry: {
+    icon: mdiWrench,
+    color: "#8d845cff",
+  },
+};
+
+/** @type {Map<string, import("stac-ts").StacItem[]>} */
+const itemsCache = new Map();
+/**
+ * Split items cache stores items with their time range metadata
+ * @type {Map<string, {items: import("stac-ts").StacItem[], minTime: number, maxTime: number}>}
+ */
+const splitItemsCache = new Map();
+
+ref(0);
+
 /**
  * Returns the current layers of {@link mapEl}
  * @returns {import("@eox/map").EoxLayer[]}
@@ -4807,7 +5129,7 @@ const getLayers = () => mapEl.value?.layers ?? [];
 
 /**
  * Returns the current layers of {@link mapCompareEl}
- * * @returns {import("@eox/map").EoxLayer[]}
+ * @returns {import("@eox/map").EoxLayer[]}
  */
 const getCompareLayers = () => mapCompareEl.value?.layers ?? [];
 
@@ -5043,6 +5365,26 @@ function generateFeatures(links, extraProperties = {}, rel = "item") {
   return geojsonObject;
 }
 
+/**
+ * Fetches or extracts the raster form configuration for a STAC object.
+ * Supports direct JSON objects, data URIs, and URL strings.
+ *
+ * @param {string|object|undefined} rasterform - The rasterform property from the STAC object.
+ * @returns {Promise<import("@/types").EodashRasterJSONForm|undefined>}
+ */
+async function fetchRasterForm(rasterform) {
+  if (!rasterform) {
+    return undefined;
+  }
+  if (typeof rasterform === "object") {
+    return /** @type {import("@/types").EodashRasterJSONForm} */ (rasterform);
+  }
+  if (typeof rasterform === "string") {
+    return await axios.get(rasterform).then((resp) => resp.data);
+  }
+  return undefined;
+}
+
 /**
  * Spearates and extracts layerConfig (jsonform schema & legend) from a style json
  *
@@ -5099,6 +5441,39 @@ function extractLayerConfig(
   return { layerConfig, style };
 }
 
+/**
+ * Recursively extracts URL keys from a JSON Schema.
+ * Maps schema property names to their defined `url_key`.
+ * @param {Record<string, any> | null | undefined} schema
+ * @returns {Record<string, string>}
+ */
+function extractUrlKeys(schema) {
+  /** @type {Record<string, string>} */
+  const keys = {};
+  if (!schema || typeof schema !== "object") return keys;
+
+  if (schema.properties) {
+    for (const [key, propDef] of Object.entries(schema.properties)) {
+      if (propDef && typeof propDef === "object") {
+        if (typeof propDef.url_key === "string") {
+          keys[key] = propDef.url_key;
+        }
+        Object.assign(keys, extractUrlKeys(propDef));
+      }
+    }
+  }
+
+  for (const combinator of ["oneOf", "allOf", "anyOf"]) {
+    if (Array.isArray(schema[combinator])) {
+      for (const sub of schema[combinator]) {
+        Object.assign(keys, extractUrlKeys(sub));
+      }
+    }
+  }
+
+  return keys;
+}
+
 /**
  *
  * @param {number[]} bbox
@@ -5173,7 +5548,7 @@ const extractRoles = (properties, linkOrAsset) => {
 
 /**
  * Extracts a single non-link style JSON from a STAC Item optionally for a selected key mapping
- * @param { import("stac-ts").StacItem | import("stac-ts").StacCollection } stacObject
+ * @param { import("stac-ts").StacItem | import("stac-ts").StacCollection | null | undefined} stacObject
  * @param {string | undefined} linkKey
  * @param {string | undefined} assetKey
  * @returns
@@ -5183,6 +5558,7 @@ const fetchStyle = async (
   linkKey = undefined,
   assetKey = undefined,
 ) => {
+  if (!stacObject) return undefined;
   let styleLink = null;
   if (linkKey) {
     styleLink = stacObject.links.find(
@@ -5214,6 +5590,20 @@ const fetchStyle = async (
   }
 };
 
+/**
+ * Resolves a style by preferring the item's own `style` link and falling back
+ * to the collection's. Takes the same key arguments as `fetchStyle`.
+ *
+ * @param {import("stac-ts").StacItem | import("stac-ts").StacCollection} item
+ * @param {import("stac-ts").StacCollection | null | undefined} collection
+ * @param {string} [linkKey]
+ * @param {string} [assetKey]
+ * @returns {Promise<import("@/types").EodashStyleJson | undefined>}
+ */
+const resolveStyle = async (item, collection, linkKey, assetKey) =>
+  (await fetchStyle(item, linkKey, assetKey)) ??
+  (await fetchStyle(collection, linkKey, assetKey));
+
 /**
  * Fetches all style JSONs from a STAC Item and returns an array with style objects
  * @param {import("stac-ts").StacItem | import("stac-ts").StacCollection} stacObject
@@ -5224,6 +5614,7 @@ const fetchAllStyles = async (stacObject) => {
     link.rel.includes("style"),
   );
   const fetchPromises = styleLinks.map(async (link) => {
+    /** @type {import("@/types").EodashStyleJson} */
     const styleJson = await axios.get(link.href).then((resp) => resp.data);
     log.debug("fetched styles JSON", JSON.parse(JSON.stringify(styleJson)));
     return styleJson;
@@ -5253,94 +5644,74 @@ const getProjectionCode = (projection) => {
 };
 
 /**
- * Extracts layercontrol LayerDatetime property from STAC Links
- * @param {import("stac-ts").StacLink[] | import("stac-ts").StacItem[] | undefined} [items]
- * @param {string|null} [currentStep]
- **/
-const extractLayerTimeValues = (items, currentStep) => {
-  if (!currentStep || !items?.length) {
-    return { layerDatetime: undefined, timeControlValues: undefined };
-  }
-
-  // check if items has a datetime value
-  const dateProperty = getDatetimeProperty(items);
-
-  if (!dateProperty) {
+ * Builds layercontrol LayerDatetime + timeControlValues from a list of dates.
+ *
+ * @param {Date[] | undefined} dates
+ * @param {string | null} [currentStep] - target datetime; snapped to the closest available date
+ * @returns {{ layerDatetime: Record<string, any> | undefined, timeControlValues: { date: string }[] | undefined }}
+ */
+const extractLayerTimeValues = (dates, currentStep) => {
+  if (!currentStep || !dates?.length || dates.length <= 1) {
     return { layerDatetime: undefined, timeControlValues: undefined };
   }
-  /** @type {{date:string;itemId:string}[]} */
-  const timeValues = [];
-  try {
-    /**
-     *  @param {typeof timeValues} vals
-     *  @param {import("stac-ts").StacLink} link
-     */
-    const reduceLinks = (vals, link) => {
-      if (link[dateProperty] && link.rel === "item") {
-        vals.push({
-          itemId: /** @type {string} */ (link.id),
-          date: new Date(
-            /** @type {string} */ (link[dateProperty]),
-          ).toISOString(),
-        });
-      }
-      return vals;
-    };
 
-    /**
-     *
-     * @param {typeof timeValues} vals
-     * @param {import("stac-ts").StacItem} item
-     */
-    const reduceItems = (vals, item) => {
-      const date = item.properties?.[dateProperty];
-      if (date) {
-        vals.push({
-          itemId: /** @type {string} */ (item.id),
-          date: new Date(/** @type {string} */ (date)).toISOString(),
-          ...item.properties,
-        });
-      }
-      return vals;
-    };
-    currentStep = new Date(currentStep).toISOString();
-    //@ts-expect-error TODO
-    items.reduce(isSTACItem(items[0]) ? reduceItems : reduceLinks, timeValues);
-  } catch (e) {
-    console.warn("[eodash] not supported datetime format was provided", e);
-    return { layerDatetime: undefined, timeControlValues: undefined };
-  }
-  // not enough timeValues
-  if (timeValues.length <= 1) {
-    return { layerDatetime: undefined, timeControlValues: undefined };
-  }
+  const controlValues = dates.map((d) => d.toISOString()).sort();
+  const timeControlValues = controlValues.map((date) => ({ date }));
 
-  // item datetime is not included in the item links datetime
-  if (!timeValues.some((val) => val.date === currentStep)) {
-    const currentStepTime = new Date(currentStep).getTime();
-    currentStep = timeValues.reduce((time, step) => {
-      const aDiff = Math.abs(new Date(time).getTime() - currentStepTime);
-      const bDiff = Math.abs(new Date(step.date).getTime() - currentStepTime);
-      return bDiff < aDiff ? step.date : time;
-    }, timeValues[0].date);
+  currentStep = new Date(currentStep).toISOString();
+  if (!controlValues.includes(currentStep)) {
+    const target = new Date(currentStep).getTime();
+    currentStep = controlValues.reduce((best, d) =>
+      Math.abs(new Date(d).getTime() - target) <
+      Math.abs(new Date(best).getTime() - target)
+        ? d
+        : best,
+    );
   }
 
   const layerDatetime = {
-    controlValues: timeValues.map((d) => d.date).sort(),
+    controlValues,
     currentStep,
     slider: true,
     navigation: true,
     play: false,
     displayFormat: "DD.MM.YYYY HH:mm",
     animateOnClickInterval: false,
+    showUTC: true,
   };
 
-  return {
-    layerDatetime,
-    timeControlValues: timeValues,
-  };
+  return { layerDatetime, timeControlValues };
 };
 
+/**
+ * Fetches the daily pre-aggregation data for a STAC collection if available.
+ * Returns the raw AggregationCollection,
+ * or null if no daily pre-aggregation link exists, or the fetch fails.
+ *
+ * @param {import("stac-ts").StacCollection | undefined} stacCollection
+ * @param {string} fallbackBaseUrl - base for relative href resolution when no `self` link is present
+ * @returns {Promise<any | null>}
+ */
+async function fetchPreAggregations(stacCollection, fallbackBaseUrl) {
+  if (!stacCollection) return null;
+  const preAggregationLink = stacCollection.links?.find(
+    (l) => l.rel === "pre-aggregation" && l["aggregation:interval"] === "daily",
+  );
+  if (!preAggregationLink) return null;
+
+  try {
+    const selfLink = stacCollection.links?.find((l) => l.rel === "self")?.href;
+    const url = toAbsolute(
+      preAggregationLink.href,
+      selfLink || fallbackBaseUrl,
+    );
+    return await axios.get(url).then((resp) => resp.data);
+  } catch (e) {
+    console.warn("[eodash] Failed to fetch pre-aggregation", e);
+    return null;
+  }
+}
+
 /**
  * Recursively find all layers whose ID up to the first ; is same as given layer
  *
@@ -5349,6 +5720,9 @@ const extractLayerTimeValues = (items, currentStep) => {
  * @returns {import("@eox/map").EoxLayer[]} Matching layer objects.
  */
 const findLayersByLayerPrefix = (layers, referenceLayer) => {
+  if (!layers || !referenceLayer) {
+    return [];
+  }
   const refId = referenceLayer?.properties?.id;
 
   if (typeof refId !== "string" || !refId.includes(";:;")) {
@@ -5535,20 +5909,147 @@ const createAssetID = (collectionId, itemId, index) => {
  *
  * @param {Record<string,any>[]} layers
  */
-const removeUnneededProperties = (layers) => {
-  const cloned = structuredClone(layers);
-  cloned.forEach((layer) => {
-    const id = layer.properties.id;
-    const title = layer.properties.title;
-    layer.properties = { id, title };
-    if (layer["interactions"]) {
-      delete layer["interactions"];
+const removeUnneededProperties = (layers, formValues = {}) => {
+  /**
+   * @param {Record<string,any>} layer
+   * @returns {Record<string,any>[]}
+   */
+  const processLayer = (layer) => {
+    // If the layer (or group) is explicitly marked as not visible, skip it and all children
+    if (layer.properties?.visible === false) {
+      return [];
+    }
+
+    // If it's a Group, we just want its children
+    if (layer.type === "Group" && Array.isArray(layer.layers)) {
+      return layer.layers.flatMap(processLayer);
     }
-    if (layer.type === "Group") {
-      layer.layers = removeUnneededProperties(layer.layers);
+
+    // Break any Vue Proxies/OpenLayers getters by stringifying first
+    let clonedLayer;
+    try {
+      clonedLayer = JSON.parse(JSON.stringify(layer));
+    } catch (_e) {
+      clonedLayer = structuredClone(layer);
     }
-  });
-  return cloned;
+
+    // Flatten formValues to handle nested properties (e.g., vminmax: { vmin, vmax })
+    /**
+     * @param {Record<string,any>} obj
+     * @returns {Record<string,any>}
+     */
+    const flattenFormValues = (obj) => {
+      /** @type {Record<string,any>} */
+      let result = {};
+      for (const key in obj) {
+        if (
+          obj[key] !== null &&
+          typeof obj[key] === "object" &&
+          !Array.isArray(obj[key])
+        ) {
+          Object.assign(result, flattenFormValues(obj[key]));
+        } else {
+          result[key] = obj[key];
+        }
+      }
+      return result;
+    };
+    const flatFormValues = flattenFormValues(formValues);
+
+    // Burn in style variables using Mustache if formValues are provided
+    if (Object.keys(flatFormValues).length > 0) {
+      // Stringify, render mustache, then parse back
+      try {
+        const renderedString = mustache.render(
+          JSON.stringify(clonedLayer),
+          flatFormValues,
+        );
+        clonedLayer = JSON.parse(renderedString);
+      } catch (e) {
+        log.warn(
+          "[eodash] Failed to apply mustache templating during export cleanup:",
+          e,
+        );
+      }
+    }
+
+    const {
+      id,
+      title,
+      mapboxStyle,
+      projection,
+      applyOptions,
+      layerConfig,
+      visible,
+    } = clonedLayer.properties || {};
+
+    // If style was not at root but in properties (layerConfig), move it to root early
+    if (!clonedLayer.style && layerConfig?.style) {
+      clonedLayer.style = layerConfig.style;
+    }
+
+    // Burn in OpenLayers ["var", "name"] variables using flatFormValues overriding style.variables
+    const styleVariables = {
+      ...(clonedLayer.style?.variables || {}),
+      ...flatFormValues,
+    };
+
+    if (clonedLayer.style && Object.keys(styleVariables).length > 0) {
+      clonedLayer.style = updateVectorLayerStyle({
+        ...clonedLayer.style,
+        variables: styleVariables,
+      });
+    }
+
+    clonedLayer.properties = {
+      id,
+      title,
+      ...(mapboxStyle && { mapboxStyle }),
+      ...(projection && { projection }),
+      ...(applyOptions && { applyOptions }),
+      ...(visible !== undefined && { visible }),
+    };
+
+    if (clonedLayer["interactions"]) {
+      delete clonedLayer["interactions"];
+    }
+
+    // Cleanup unnecessary properties
+    /**
+     * @param {any} obj
+     */
+    const cleanupProperties = (obj) => {
+      if (!obj || typeof obj !== "object") return;
+
+      for (const key in obj) {
+        if (obj[key] === null) {
+          delete obj[key];
+        } else if (Array.isArray(obj[key])) {
+          if (obj[key].length === 0) {
+            // Remove empty arrays like empty interactions
+            delete obj[key];
+          } else {
+            obj[key].forEach(cleanupProperties);
+          }
+        } else if (typeof obj[key] === "object") {
+          cleanupProperties(obj[key]);
+        }
+      }
+    };
+    cleanupProperties(clonedLayer);
+
+    return [clonedLayer];
+  };
+
+  // ensure the top level array is also deeply un-proxied if needed
+  let rawLayers = layers;
+  try {
+    rawLayers = JSON.parse(JSON.stringify(layers));
+  } catch (_e) {
+    rawLayers = structuredClone(layers);
+  }
+
+  return rawLayers.flatMap(processLayer);
 };
 
 /**
@@ -5708,7 +6209,12 @@ function getDatetimeProperty(linksOrItems) {
   }
 
   // TODO: consider other properties for datetime ranges
-  const datetimeProperties = ["datetime", "start_datetime", "end_datetime"];
+
+  const datetimeProperties = /** @type {const} */ ([
+    "datetime",
+    "start_datetime",
+    "end_datetime",
+  ]);
   if (checkProperties) {
     for (const prop of datetimeProperties) {
       const propExists = linksOrItems.some(
@@ -5734,6 +6240,7 @@ function getDatetimeProperty(linksOrItems) {
     return prop;
   }
 }
+
 /**
  *
  * @param {*} stacObject
@@ -5750,6 +6257,65 @@ function isSTACItem(stacObject) {
   );
 }
 
+/**
+ * Fetches items using a split strategy (past/future) around a center date
+ * @param {string} itemsUrl
+ * @param {string} query
+ * @param {string | Date} centerDatetime
+ * @param {number} maxNumber
+ * @returns {Promise<import("stac-ts").StacItem[]>}
+ */
+const fetchSplitItems = async (
+  itemsUrl,
+  query,
+  centerDatetime,
+  maxNumber,
+) => {
+  const center = new Date(centerDatetime).toISOString();
+  const limit = Math.ceil(maxNumber / 2);
+
+  /** @param {"past"|"future"} direction */
+  const fetchSide = async (direction) => {
+    const isPast = direction === "past";
+    const datetimeRange = isPast ? `../${center}` : `${center}/..`;
+    const sortOrder = isPast ? "-datetime" : "+datetime";
+    const queryParams = new URLSearchParams(query);
+
+    queryParams.set("limit", limit.toString());
+    queryParams.set("datetime", datetimeRange);
+    queryParams.set("sortby", sortOrder);
+
+    const splitUrl = itemsUrl.split("/");
+    const collectionId = /** @type {string} */ (splitUrl.at(-2));
+    queryParams.set("collection", collectionId);
+
+    const searchEndpoint = `${splitUrl.slice(0, -3).join("/")}/search`;
+    const items = await axios
+      .get(searchEndpoint, { params: queryParams })
+      .then((res) => res.data.features);
+    return items;
+  };
+
+  const [pastItems, futureItems] = await Promise.all([
+    fetchSide("past"),
+    fetchSide("future"),
+  ]);
+
+  const allItems = [...pastItems, ...futureItems];
+
+  // check for duplicates by ids
+  const seen = new Set();
+  const uniqueItems = [];
+  for (const item of allItems) {
+    if (!seen.has(item.id)) {
+      seen.add(item.id);
+      uniqueItems.push(item);
+    }
+  }
+
+  return uniqueItems;
+};
+
 /**
  * Fetch all STAC items from a STAC API endpoint.
  * @param {string} itemsUrl
@@ -5757,6 +6323,8 @@ function isSTACItem(stacObject) {
  * @param {number} [limit=100] - The maximum number of items to fetch per request.
  * @param {boolean} [returnFirst] - If true, only the first page of results will be returned.
  * @param {number} [maxNumber=1000] - if the matched number of items exceed this, only the first page will be returned.
+ * @param {string | Date} [centerDatetime] - Date to center the search around if items exceed maxNumber
+ * @returns {Promise<import("stac-ts").StacItem[]>}
  */
 async function fetchApiItems(
   itemsUrl,
@@ -5764,23 +6332,42 @@ async function fetchApiItems(
   limit = 100,
   returnFirst = false,
   maxNumber = 1000,
+  centerDatetime,
 ) {
-  itemsUrl = itemsUrl.includes("?") ? itemsUrl.split("?")[0] : itemsUrl;
-  itemsUrl += query ? `?limit=${limit}&${query}` : `?limit=${limit}`;
+  // Exclude centerDatetime from cache key - it's only used for split search fallback
+  const cacheKey = JSON.stringify({
+    itemsUrl,
+    query,
+    limit,
+    returnFirst,
+    maxNumber,
+  });
+
+  if (itemsCache.has(cacheKey)) {
+    return itemsCache.get(cacheKey) ?? [];
+  }
+
+  const urlQuery = new URLSearchParams(query);
+  urlQuery.set("limit", limit.toString());
+
+  let finalItemsUrl = itemsUrl.includes("?")
+    ? itemsUrl.split("?")[0]
+    : itemsUrl;
+  finalItemsUrl += urlQuery.keys().toArray().length
+    ? `?${urlQuery.toString()}`
+    : "";
 
   const itemsFeatureCollection = await axios
-    .get(itemsUrl)
+    .get(finalItemsUrl)
     .then((resp) => resp.data);
+
   /** @type {import("stac-ts").StacItem[]} */
   const items = itemsFeatureCollection.features;
-  const nextLink = itemsFeatureCollection.links?.find(
-    //@ts-expect-error TODO: itemsFeatureCollection is not typed
-    (link) => link.rel === "next",
-  );
-
-  if (!nextLink || returnFirst) {
+  if (returnFirst) {
+    itemsCache.set(cacheKey, items);
     return items;
   }
+
   /** @type {number} */
   const matchedItems = itemsFeatureCollection.numberMatched;
   // Avoid fetching too many items
@@ -5788,26 +6375,70 @@ async function fetchApiItems(
     console.warn(
       `[eodash] The number of items matched (${matchedItems}) exceeds the maximum allowed (${maxNumber})`,
     );
-    return items;
-  }
+    // we try to narrow down the search around the center datetime
+    if (centerDatetime) {
+      // Check if we have a cached split result that covers this centerDatetime
+      const splitCacheKey = JSON.stringify({ itemsUrl, query, maxNumber });
+      const cachedSplit = splitItemsCache.get(splitCacheKey);
+      const centerTime = new Date(centerDatetime).getTime();
 
-  let [nextLinkURL, nextLinkQuery] = nextLink.href.split("?");
-  nextLinkQuery = nextLinkQuery.replace(/limit=\d+/, "");
-  if (query) {
-    const queryParams = new URLSearchParams(query);
-    const nextLinkParams = new URLSearchParams(nextLinkQuery);
+      if (
+        cachedSplit &&
+        centerTime >= cachedSplit.minTime &&
+        centerTime <= cachedSplit.maxTime
+      ) {
+        return cachedSplit.items;
+      }
 
-    for (const key of nextLinkParams.keys()) {
-      queryParams.delete(key);
-    }
-    const remainingQuery = queryParams.toString();
-    if (remainingQuery) {
-      nextLinkQuery += `&${remainingQuery}`;
+      const narrowedItems = await fetchSplitItems(
+        itemsUrl,
+        query ?? "",
+        centerDatetime,
+        maxNumber,
+      );
+
+      if (!narrowedItems.length) {
+        return narrowedItems;
+      }
+      const datetimeProperty = getDatetimeProperty(narrowedItems);
+      if (!datetimeProperty) {
+        return narrowedItems;
+      }
+
+      const times = narrowedItems
+        .map((i) =>
+          i.properties[datetimeProperty]
+            ? new Date(i.properties[datetimeProperty]).getTime()
+            : null,
+        )
+        .filter((t) => t !== null);
+      if (!times.length) {
+        return narrowedItems;
+      }
+      splitItemsCache.set(splitCacheKey, {
+        items: narrowedItems,
+        minTime: Math.min(...times),
+        maxTime: Math.max(...times),
+      });
+
+      return narrowedItems;
     }
+
+    itemsCache.set(cacheKey, items);
+    return items;
   }
 
-  const nextPage = await fetchApiItems(nextLinkURL, nextLinkQuery);
-  items.push(...nextPage);
+  urlQuery.set("limit", maxNumber.toString());
+
+  const allItems = await axios
+    .get(itemsUrl + "?" + urlQuery.toString())
+    .then((resp) => resp.data.features)
+    .catch((err) => {
+      console.error(err);
+      return [];
+    });
+  items.splice(0, items.length, ...allItems);
+  itemsCache.set(cacheKey, items);
   return items;
 }
 /**
@@ -5846,4 +6477,273 @@ function extractEoxLegendLink(link) {
   return extraProperties;
 }
 
-export { axios$1 as $, datetime as A, poi as B, activeTemplate as C, mapPosition as D, indicator as E, currentUrl as F, currentCompareUrl as G, compareIndicator as H, comparePoi as I, states as J, actions as K, areChartsSeparateLayout as L, chartSpec as M, compareChartSpec as N, includesProcess as O, shouldShowChartWidget as P, sanitizeBbox as Q, mapCompareEl as R, getColFromLayer as S, setMapProjFromCol as T, isGlobe as U, setActiveTemplate as V, availableMapProjection as W, changeMapProjection as X, getCompareLayers as Y, compareChartData as Z, chartData as _, extractEoxLegendLink as a, removeLayers as a0, removeUnneededProperties as a1, extractLayerConfig as b, createLayerID as c, axios as d, extractRoles as e, fetchStyle as f, addTooltipInteraction as g, createAssetID as h, mapEl as i, getProjectionCode as j, isSTACItem as k, extractLayerTimeValues as l, mergeGeojsons as m, fetchApiItems as n, getDatetimeProperty as o, fetchAllStyles as p, findLayer as q, registerProjection as r, findLayersByLayerPrefix as s, replaceLayer as t, generateFeatures as u, getLayers as v, extractLayerLegend as w, extractCollectionUrls as x, generateLinksFromItems as y, revokeCollectionBlobUrls as z };
+/**
+ * Locate the first sub-schema whose `format` matches by walking `properties`
+ * and the `oneOf` / `allOf` / `anyOf` combinators. Returns the schema path
+ * (array of keys/indices) from the root schema to the matched node, or
+ * undefined if not found. Empty array means the input schema itself matched.
+ *
+ * @param {Record<string, any> | null | undefined} schema
+ * @param {string} [format="bands"]
+ * @returns {(string | number)[] | undefined}
+ */
+function getBandsProperty(schema, format = "bands") {
+  if (!schema || typeof schema !== "object") return undefined;
+  if (schema.format === format) return [];
+
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      const sub = getBandsProperty(schema.properties[key], format);
+      if (sub) return ["properties", key, ...sub];
+    }
+  }
+
+  for (const combinator of ["oneOf", "allOf", "anyOf"]) {
+    if (!Array.isArray(schema[combinator])) continue;
+    for (let i = 0; i < schema[combinator].length; i++) {
+      const sub = getBandsProperty(schema[combinator][i], format);
+      if (sub) return [combinator, i, ...sub];
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Checks whether a GeoZarr layer's bands changed in the jsonform output and,
+ * if so, rebuilds the source with the new 3 selected bands.
+ * Gamma and rescale are handled automatically by `applyUpdatedStyles` via
+ * `updateStyleVariables` — this function only manages source reconstruction.
+ * Uses the existing source constructor to avoid import-version mismatches.
+ *
+ * @param {import("ol/layer/Layer").default} olLayer - Layer from layerConfig:change event
+ * @param {Record<string, any>} jsonformValue - Current jsonform output
+ * @returns {boolean} true if the source was rebuilt
+ */
+function updateGeoZarrBands(olLayer, jsonformValue) {
+  /** @type {import("@eox/map/src/layers").EOxLayerType<"WebGLTile","GeoZarr">} */
+  const jsonLayer = olLayer.get("_jsonDefinition");
+  const updatedBands = jsonformValue.bands;
+  const isGeoZarr =
+    jsonLayer?.type === "WebGLTile" && jsonLayer?.source?.type === "GeoZarr";
+  if (!jsonLayer || !jsonLayer.source || !isGeoZarr || !updatedBands) {
+    return false;
+  }
+
+  const oldBands = jsonLayer.source?.bands;
+  if (JSON.stringify(updatedBands) === JSON.stringify(oldBands)) {
+    return false;
+  }
+  jsonLayer.source.bands = [...updatedBands];
+  olLayer.setSource(
+    new window.eoxMapAdvancedOlSources.GeoZarr(jsonLayer.source),
+  );
+  return true;
+}
+
+/**
+ * Safely appends query parameters to a URL string, preserving templates like {z}/{x}/{y}
+ * @param {string} url
+ * @param {Record<string, string>} params
+ * @returns {string}
+ */
+function appendQueryParams(url, params) {
+  const [base, query] = url.split("?");
+  const searchParams = new URLSearchParams(query || "");
+
+  for (const [key, val] of Object.entries(params)) {
+    if (val !== undefined && val !== null && val !== "") {
+      searchParams.set(key, val);
+    } else {
+      searchParams.delete(key);
+    }
+  }
+
+  const newQuery = searchParams.toString();
+  return newQuery ? `${base}?${newQuery}` : base;
+}
+
+/**
+ * Checks whether a VectorTile layer's URL needs to be updated based on jsonform output.
+ * If the style's jsonform schema has properties with `url_key` defined, their values
+ * are injected as query parameters into the source URL.
+ *
+ * @param {import("ol/layer/Layer").default} olLayer - Layer from layerConfig:change event
+ * @param {Record<string, any>} jsonformValue - Current jsonform output
+ * @returns {boolean} true if the URL was updated
+ */
+function updateLayerUrl(olLayer, jsonformValue) {
+  const jsonLayer = olLayer.get("_jsonDefinition");
+  if (!jsonLayer || jsonLayer.type !== "VectorTile") {
+    return false;
+  }
+
+  const schema = jsonLayer.properties?.layerConfig?.schema;
+  const urlKeys = extractUrlKeys(schema);
+
+  if (Object.keys(urlKeys).length === 0) {
+    return false;
+  }
+
+  let originalUrl = olLayer.get("originalUrl") || jsonLayer.source?.url;
+
+  if (!originalUrl || typeof originalUrl !== "string") {
+    return false;
+  }
+
+  if (!olLayer.get("originalUrl")) {
+    olLayer.set("originalUrl", originalUrl);
+  }
+
+  /** @type {Record<string, string>} */
+  const queryParamsToInject = {};
+  for (const [propName, urlKey] of Object.entries(urlKeys)) {
+    queryParamsToInject[urlKey] = jsonformValue[propName];
+  }
+
+  const newUrl = appendQueryParams(originalUrl, queryParamsToInject);
+
+  if (jsonLayer.source?.url) {
+    if (jsonLayer.source.url === newUrl) {
+      return false;
+    }
+    jsonLayer.source.url = newUrl;
+    if (olLayer.get("injectedUrl") === newUrl) {
+      return false;
+    }
+    const source = olLayer.getSource();
+    olLayer.set("injectedUrl", newUrl);
+    if (source && "setUrl" in source) {
+      /** @type {any} */ (source).setUrl(newUrl);
+      return true;
+    }
+    if (source && "setUrls" in source) {
+      /** @type {any} */ (source).setUrls([newUrl]);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Applies titiler upscaling to an XYZ tile URL based on the matched endpoint config.
+ * - titiler v1: appends `@2x` to the `{y}` tile coordinate
+ * - titiler v2: adds `tilesize=512` query parameter (v2 removed the `@2x` suffix)
+ * Plain strings in the config default to v1 behavior for backward compatibility.
+ *
+ * @param {string} url - The XYZ tile URL template
+ * @param {Array<string | { url: string; titilerVersion?: 1 | 2 }>} upscalingEndpoints
+ * @returns {{ url: string; tileSize: [number, number] } | null} null if no endpoint matches
+ */
+function applyTitilerUpscaling(url, upscalingEndpoints) {
+  const match = upscalingEndpoints.find((entry) => {
+    const endpointUrl = typeof entry === "string" ? entry : entry.url;
+    return url.includes(endpointUrl);
+  });
+
+  if (!match) {
+    return null;
+  }
+
+  const version = typeof match === "string" ? 1 : (match.titilerVersion ?? 1);
+
+  if (version === 2) {
+    const [base, query] = url.split("?");
+    const params = new URLSearchParams(query);
+    params.set("tilesize", "512");
+    return { url: `${base}?${params.toString()}`, tileSize: [512, 512] };
+  }
+
+  return { url: url.replace("{y}", "{y}@2x"), tileSize: [512, 512] };
+}
+
+/**
+ * Picks the render presets for a collection, preferring client-provided config
+ * (`options.renders[collectionId]`) and falling back to the collection's own STAC
+ * `renders` extension when no config entry exists.
+ * @param {import("stac-ts").StacCollection | null | undefined} collection
+ * @param {Record<string, Record<string, import("@/types").Render>> | undefined} [configRenders]
+ * @returns {Record<string, import("@/types").Render> | undefined}
+ */
+function resolveRenders(collection, configRenders) {
+  const config = collection?.id ? configRenders?.[collection.id] : undefined;
+  if (config) return config;
+  return /** @type {Record<string, import("@/types").Render>|undefined} */ (
+    collection?.renders ?? undefined
+  );
+}
+
+/**
+ * TiTiler expects rescale as [min,max] pairs; chunks a flat numeric list
+ * into pairs (e.g. [0,0.4,0,0.1] -> [[0,0.4],[0,0.1]]). Nested input passes through.
+ * @param {number[]|number[][]|undefined} rescale - flat or nested rescale values
+ * @returns {number[][]|undefined} rescale as [min,max] pairs
+ */
+function normalizeRescale(rescale) {
+  if (!rescale?.length || Array.isArray(rescale[0])) {
+    return /** @type {number[][]|undefined} */ (rescale);
+  }
+  const pairs = [];
+  for (let i = 0; i < rescale.length; i += 2) {
+    pairs.push(/** @type {number[]} */ (rescale).slice(i, i + 2));
+  }
+  return pairs;
+}
+
+/**
+ * Drops NaN nodata values; NaN is already the implicit fill for float data,
+ * so forwarding `nodata=nan` to TiTiler is redundant.
+ * @param {string|number|undefined} nodata - nodata value from render/asset metadata
+ * @returns {string|number|undefined} nodata, or undefined when it is NaN
+ */
+function normalizeNodata(nodata) {
+  if (typeof nodata === "number" && Number.isNaN(nodata)) return undefined;
+  if (typeof nodata === "string" && nodata.trim().toLowerCase() === "nan")
+    return undefined;
+  return nodata;
+}
+
+/**
+ * Serializes an object into a TiTiler query string. Arrays repeat the key per
+ * element (TiTiler list params, e.g. `assets=a&assets=b`); nested elements
+ * comma-join (`rescale: [[0,1],[0,2]]` -> `rescale=0,1&rescale=0,2`); objects
+ * are JSON-encoded. Shared by the render-extension and mosaic paths.
+ * @param {Record<string,any>} obj
+ * @returns {string}
+ */
+function encodeURLObject(obj) {
+  let str = "";
+  for (const key in obj) {
+    const value = obj[key];
+    if (value === null || value === undefined || value === "") {
+      continue;
+    }
+
+    const valueType = Array.isArray(value) ? "array" : typeof value;
+
+    switch (valueType) {
+      case "array": {
+        for (const val of value) {
+          if (Array.isArray(val)) {
+            str += `${key}=${val.join(",")}&`;
+          } else {
+            str += `${key}=${encodeURIComponent(val)}&`;
+          }
+        }
+        break;
+      }
+      case "object": {
+        str += `${key}=${encodeURI(JSON.stringify(value))}&`;
+        break;
+      }
+      default: {
+        str += `${key}=${encodeURIComponent(value)}&`;
+        break;
+      }
+    }
+  }
+  return str;
+}
+
+export { compareChartSpec as $, findLayer as A, findLayersByLayerPrefix as B, replaceLayer as C, generateFeatures as D, dataThemesBrands as E, getLayers as F, extractLayerLegend as G, extractCollectionUrls as H, generateLinksFromItems as I, revokeCollectionBlobUrls as J, collectionsPalette as K, datetime as L, poi as M, activeTemplate as N, mapPosition as O, isFirstLoad as P, indicator as Q, currentUrl as R, currentCompareUrl as S, eodashCompareCollections as T, compareIndicator as U, comparePoi as V, eodashCollections as W, states as X, actions as Y, areChartsSeparateLayout as Z, chartSpec as _, extractRoles as a, loading as a0, includesProcess as a1, shouldShowChartWidget as a2, sanitizeBbox as a3, tooltipAdapter as a4, mapCompareEl as a5, updateGeoZarrBands as a6, updateLayerUrl as a7, layerControlFormValueCompare as a8, layerControlFormValue as a9, getColFromLayer as aa, isGlobe as ab, setMapProjFromCol as ac, setActiveTemplate as ad, availableMapProjection as ae, changeMapProjection as af, getCompareLayers as ag, compareChartData as ah, chartData as ai, axios$1 as aj, removeLayers as ak, removeUnneededProperties as al, extractEoxLegendLink as b, createLayerID as c, applyTitilerUpscaling as d, extractLayerConfig as e, fetchRasterForm as f, axios as g, resolveStyle as h, addTooltipInteraction as i, createAssetID as j, getBandsProperty as k, resolveRenders as l, mergeGeojsons as m, normalizeRescale as n, normalizeNodata as o, encodeURLObject as p, mapEl as q, registerProjection as r, getProjectionCode as s, isSTACItem as t, extractLayerTimeValues as u, fetchStyle as v, fetchApiItems as w, getDatetimeProperty as x, fetchPreAggregations as y, fetchAllStyles as z };