@eodash/eodash 5.2.0 → 5.3.1

package/dist/client/{helpers-wXK7Ywio.js → helpers-CI_7CUmn.js}

@@ -54,7 +54,7 @@ const isUndefined = typeOfTest('undefined');
  */
 function isBuffer(val) {
   return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+    && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
 }
 
 /**
@@ -99,7 +99,7 @@ const isString = typeOfTest('string');
  * @param {*} val The value to test
  * @returns {boolean} True if value is a Function, otherwise false
  */
-const isFunction = typeOfTest('function');
+const isFunction$1 = typeOfTest('function');
 
 /**
  * Determine if a value is a Number
@@ -155,7 +155,7 @@ const isEmptyObject = (val) => {
   if (!isObject(val) || isBuffer(val)) {
     return false;
   }
-  
+
   try {
     return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
   } catch (e) {
@@ -207,7 +207,7 @@ const isFileList = kindOfTest('FileList');
  *
  * @returns {boolean} True if value is a Stream, otherwise false
  */
-const isStream = (val) => isObject(val) && isFunction(val.pipe);
+const isStream = (val) => isObject(val) && isFunction$1(val.pipe);
 
 /**
  * Determine if a value is a FormData
@@ -220,10 +220,10 @@ const isFormData = (thing) => {
   let kind;
   return thing && (
     (typeof FormData === 'function' && thing instanceof FormData) || (
-      isFunction(thing.append) && (
+      isFunction$1(thing.append) && (
         (kind = kindOf(thing)) === 'formdata' ||
         // detect form-data instance
-        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
+        (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]')
       )
     )
   )
@@ -348,7 +348,7 @@ const isContextDefined = (context) => !isUndefined(context) && context !== _glob
  * @returns {Object} Result of all merge properties
  */
 function merge(/* obj1, obj2, obj3, ... */) {
-  const {caseless} = isContextDefined(this) && this || {};
+  const {caseless, skipUndefined} = isContextDefined(this) && this || {};
   const result = {};
   const assignValue = (val, key) => {
     const targetKey = caseless && findKey(result, key) || key;
@@ -358,7 +358,7 @@ function merge(/* obj1, obj2, obj3, ... */) {
       result[targetKey] = merge({}, val);
     } else if (isArray(val)) {
       result[targetKey] = val.slice();
-    } else {
+    } else if (!skipUndefined || !isUndefined(val)) {
       result[targetKey] = val;
     }
   };
@@ -381,7 +381,7 @@ function merge(/* obj1, obj2, obj3, ... */) {
  */
 const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
   forEach(b, (val, key) => {
-    if (thisArg && isFunction(val)) {
+    if (thisArg && isFunction$1(val)) {
       a[key] = bind(val, thisArg);
     } else {
       a[key] = val;
@@ -597,13 +597,13 @@ const reduceDescriptors = (obj, reducer) => {
 const freezeMethods = (obj) => {
   reduceDescriptors(obj, (descriptor, name) => {
     // skip restricted props in strict mode
-    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+    if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
       return false;
     }
 
     const value = obj[name];
 
-    if (!isFunction(value)) return;
+    if (!isFunction$1(value)) return;
 
     descriptor.enumerable = false;
 
@@ -640,6 +640,8 @@ const toFiniteNumber = (value, defaultValue) => {
   return value != null && Number.isFinite(value = +value) ? value : defaultValue;
 };
 
+
+
 /**
  * If the thing is a FormData object, return true, otherwise return false.
  *
@@ -648,7 +650,7 @@ const toFiniteNumber = (value, defaultValue) => {
  * @returns {boolean}
  */
 function isSpecCompliantForm(thing) {
-  return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
+  return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
 }
 
 const toJSONObject = (obj) => {
@@ -690,7 +692,7 @@ const toJSONObject = (obj) => {
 const isAsyncFn = kindOfTest('AsyncFunction');
 
 const isThenable = (thing) =>
-  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+  thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
 
 // original code
 // https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
@@ -714,7 +716,7 @@ const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
   })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
 })(
   typeof setImmediate === 'function',
-  isFunction(_global.postMessage)
+  isFunction$1(_global.postMessage)
 );
 
 const asap = typeof queueMicrotask !== 'undefined' ?
@@ -723,7 +725,7 @@ const asap = typeof queueMicrotask !== 'undefined' ?
 // *********************
 
 
-const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
+const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
 
 
 const utils$1 = {
@@ -747,7 +749,7 @@ const utils$1 = {
   isFile,
   isBlob,
   isRegExp,
-  isFunction,
+  isFunction: isFunction$1,
   isStream,
   isURLSearchParams,
   isTypedArray,
@@ -873,11 +875,18 @@ AxiosError.from = (error, code, config, request, response, customProps) => {
     return prop !== 'isAxiosError';
   });
 
-  AxiosError.call(axiosError, error.message, code, config, request, response);
+  const msg = error && error.message ? error.message : 'Error';
+
+  // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
+  const errCode = code == null && error ? error.code : code;
+  AxiosError.call(axiosError, msg, errCode, config, request, response);
 
-  axiosError.cause = error;
+  // Chain the original error on the standard field; non-enumerable to avoid JSON noise
+  if (error && axiosError.cause == null) {
+    Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });
+  }
 
-  axiosError.name = error.name;
+  axiosError.name = (error && error.name) || 'Error';
 
   customProps && Object.assign(axiosError, customProps);
 
@@ -1168,9 +1177,7 @@ function encode(val) {
     replace(/%3A/gi, ':').
     replace(/%24/g, '$').
     replace(/%2C/gi, ',').
-    replace(/%20/g, '+').
-    replace(/%5B/gi, '[').
-    replace(/%5D/gi, ']');
+    replace(/%20/g, '+');
 }
 
 /**
@@ -1573,7 +1580,7 @@ const defaults = {
       const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
       try {
-        return JSON.parse(data);
+        return JSON.parse(data, this.parseReviver);
       } catch (e) {
         if (strictJSONParsing) {
           if (e.name === 'SyntaxError') {
@@ -2394,7 +2401,7 @@ function mergeConfig(config1, config2) {
 const resolveConfig = (config) => {
   const newConfig = mergeConfig({}, config);
 
-  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
+  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
 
   newConfig.headers = headers = AxiosHeaders.from(headers);
 
@@ -2407,17 +2414,21 @@ const resolveConfig = (config) => {
     );
   }
 
-  let contentType;
-
   if (utils$1.isFormData(data)) {
     if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-      headers.setContentType(undefined); // Let the browser set it
-    } else if ((contentType = headers.getContentType()) !== false) {
-      // fix semicolon duplication issue for ReactNative FormData implementation
-      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
-      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
+      headers.setContentType(undefined); // browser handles it
+    } else if (utils$1.isFunction(data.getHeaders)) {
+      // Node.js FormData (like form-data package)
+      const formHeaders = data.getHeaders();
+      // Only set safe headers to avoid overwriting security headers
+      const allowedHeaders = ['content-type', 'content-length'];
+      Object.entries(formHeaders).forEach(([key, val]) => {
+        if (allowedHeaders.includes(key.toLowerCase())) {
+          headers.set(key, val);
+        }
+      });
     }
-  }
+  }  
 
   // Add xsrf header
   // This is only done if running in a standard browser environment.
@@ -2534,15 +2545,18 @@ const xhrAdapter = isXHRAdapterSupported && function (config) {
     };
 
     // Handle low level network errors
-    request.onerror = function handleError() {
-      // Real errors are hidden from us by the browser
-      // onerror should only fire if it's a network error
-      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
-
-      // Clean up request
-      request = null;
+  request.onerror = function handleError(event) {
+       // Browsers deliver a ProgressEvent in XHR onerror
+       // (message may be empty; when present, surface it)
+       // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event
+       const msg = event && event.message ? event.message : 'Network Error';
+       const err = new AxiosError(msg, AxiosError.ERR_NETWORK, config, request);
+       // attach the underlying event for consumers who want details
+       err.event = event || null;
+       reject(err);
+       request = null;
     };
-
+    
     // Handle timeout
     request.ontimeout = function handleTimeout() {
       let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
@@ -2756,14 +2770,18 @@ const trackStream = (stream, chunkSize, onProgress, onFinish) => {
   })
 };
 
-const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
-const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+const {isFunction} = utils$1;
+
+const globalFetchAPI = (({Request, Response}) => ({
+  Request, Response
+}))(utils$1.global);
+
+const {
+  ReadableStream: ReadableStream$1, TextEncoder
+} = utils$1.global;
 
-// used only inside the fetch adapter
-const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
-    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
-    async (str) => new Uint8Array(await new Response(str).arrayBuffer())
-);
 
 const test = (fn, ...args) => {
   try {
@@ -2773,211 +2791,268 @@ const test = (fn, ...args) => {
   }
 };
 
-const supportsRequestStream = isReadableStreamSupported && test(() => {
-  let duplexAccessed = false;
+const factory = (env) => {
+  env = utils$1.merge.call({
+    skipUndefined: true
+  }, globalFetchAPI, env);
 
-  const hasContentType = new Request(platform.origin, {
-    body: new ReadableStream(),
-    method: 'POST',
-    get duplex() {
-      duplexAccessed = true;
-      return 'half';
-    },
-  }).headers.has('Content-Type');
+  const {fetch: envFetch, Request, Response} = env;
+  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
+  const isRequestSupported = isFunction(Request);
+  const isResponseSupported = isFunction(Response);
 
-  return duplexAccessed && !hasContentType;
-});
+  if (!isFetchSupported) {
+    return false;
+  }
 
-const DEFAULT_CHUNK_SIZE = 64 * 1024;
+  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
 
-const supportsResponseStream = isReadableStreamSupported &&
-  test(() => utils$1.isReadableStream(new Response('').body));
+  const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
+      ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
+      async (str) => new Uint8Array(await new Request(str).arrayBuffer())
+  );
 
+  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+    let duplexAccessed = false;
 
-const resolvers = {
-  stream: supportsResponseStream && ((res) => res.body)
-};
+    const hasContentType = new Request(platform.origin, {
+      body: new ReadableStream$1(),
+      method: 'POST',
+      get duplex() {
+        duplexAccessed = true;
+        return 'half';
+      },
+    }).headers.has('Content-Type');
 
-isFetchSupported && (((res) => {
-  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
-    !resolvers[type] && (resolvers[type] = utils$1.isFunction(res[type]) ? (res) => res[type]() :
-      (_, config) => {
-        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
-      });
+    return duplexAccessed && !hasContentType;
   });
-})(new Response));
 
-const getBodyLength = async (body) => {
-  if (body == null) {
-    return 0;
-  }
+  const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&
+    test(() => utils$1.isReadableStream(new Response('').body));
 
-  if(utils$1.isBlob(body)) {
-    return body.size;
-  }
+  const resolvers = {
+    stream: supportsResponseStream && ((res) => res.body)
+  };
 
-  if(utils$1.isSpecCompliantForm(body)) {
-    const _request = new Request(platform.origin, {
-      method: 'POST',
-      body,
+  isFetchSupported && ((() => {
+    ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
+      !resolvers[type] && (resolvers[type] = (res, config) => {
+        let method = res && res[type];
+
+        if (method) {
+          return method.call(res);
+        }
+
+        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+      });
     });
-    return (await _request.arrayBuffer()).byteLength;
-  }
+  })());
 
-  if(utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
-    return body.byteLength;
-  }
+  const getBodyLength = async (body) => {
+    if (body == null) {
+      return 0;
+    }
 
-  if(utils$1.isURLSearchParams(body)) {
-    body = body + '';
-  }
+    if (utils$1.isBlob(body)) {
+      return body.size;
+    }
 
-  if(utils$1.isString(body)) {
-    return (await encodeText(body)).byteLength;
-  }
-};
+    if (utils$1.isSpecCompliantForm(body)) {
+      const _request = new Request(platform.origin, {
+        method: 'POST',
+        body,
+      });
+      return (await _request.arrayBuffer()).byteLength;
+    }
 
-const resolveBodyLength = async (headers, body) => {
-  const length = utils$1.toFiniteNumber(headers.getContentLength());
+    if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
+      return body.byteLength;
+    }
 
-  return length == null ? getBodyLength(body) : length;
-};
+    if (utils$1.isURLSearchParams(body)) {
+      body = body + '';
+    }
 
-const fetchAdapter = isFetchSupported && (async (config) => {
-  let {
-    url,
-    method,
-    data,
-    signal,
-    cancelToken,
-    timeout,
-    onDownloadProgress,
-    onUploadProgress,
-    responseType,
-    headers,
-    withCredentials = 'same-origin',
-    fetchOptions
-  } = resolveConfig(config);
-
-  responseType = responseType ? (responseType + '').toLowerCase() : 'text';
-
-  let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
-
-  let request;
-
-  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+    if (utils$1.isString(body)) {
+      return (await encodeText(body)).byteLength;
+    }
+  };
+
+  const resolveBodyLength = async (headers, body) => {
+    const length = utils$1.toFiniteNumber(headers.getContentLength());
+
+    return length == null ? getBodyLength(body) : length;
+  };
+
+  return async (config) => {
+    let {
+      url,
+      method,
+      data,
+      signal,
+      cancelToken,
+      timeout,
+      onDownloadProgress,
+      onUploadProgress,
+      responseType,
+      headers,
+      withCredentials = 'same-origin',
+      fetchOptions
+    } = resolveConfig(config);
+
+    let _fetch = envFetch || fetch;
+
+    responseType = responseType ? (responseType + '').toLowerCase() : 'text';
+
+    let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+
+    let request = null;
+
+    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
       composedSignal.unsubscribe();
-  });
+    });
 
-  let requestContentLength;
+    let requestContentLength;
 
-  try {
-    if (
-      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
-      (requestContentLength = await resolveBodyLength(headers, data)) !== 0
-    ) {
-      let _request = new Request(url, {
-        method: 'POST',
-        body: data,
-        duplex: "half"
-      });
+    try {
+      if (
+        onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
+        (requestContentLength = await resolveBodyLength(headers, data)) !== 0
+      ) {
+        let _request = new Request(url, {
+          method: 'POST',
+          body: data,
+          duplex: "half"
+        });
 
-      let contentTypeHeader;
+        let contentTypeHeader;
 
-      if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
-        headers.setContentType(contentTypeHeader);
-      }
+        if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+          headers.setContentType(contentTypeHeader);
+        }
 
-      if (_request.body) {
-        const [onProgress, flush] = progressEventDecorator(
-          requestContentLength,
-          progressEventReducer(asyncDecorator(onUploadProgress))
-        );
+        if (_request.body) {
+          const [onProgress, flush] = progressEventDecorator(
+            requestContentLength,
+            progressEventReducer(asyncDecorator(onUploadProgress))
+          );
 
-        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+        }
       }
-    }
 
-    if (!utils$1.isString(withCredentials)) {
-      withCredentials = withCredentials ? 'include' : 'omit';
-    }
+      if (!utils$1.isString(withCredentials)) {
+        withCredentials = withCredentials ? 'include' : 'omit';
+      }
 
-    // Cloudflare Workers throws when credentials are defined
-    // see https://github.com/cloudflare/workerd/issues/902
-    const isCredentialsSupported = "credentials" in Request.prototype;
-    request = new Request(url, {
-      ...fetchOptions,
-      signal: composedSignal,
-      method: method.toUpperCase(),
-      headers: headers.normalize().toJSON(),
-      body: data,
-      duplex: "half",
-      credentials: isCredentialsSupported ? withCredentials : undefined
-    });
+      // Cloudflare Workers throws when credentials are defined
+      // see https://github.com/cloudflare/workerd/issues/902
+      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
 
-    let response = await fetch(request, fetchOptions);
+      const resolvedOptions = {
+        ...fetchOptions,
+        signal: composedSignal,
+        method: method.toUpperCase(),
+        headers: headers.normalize().toJSON(),
+        body: data,
+        duplex: "half",
+        credentials: isCredentialsSupported ? withCredentials : undefined
+      };
 
-    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
+      request = isRequestSupported && new Request(url, resolvedOptions);
 
-    if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
-      const options = {};
+      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
 
-      ['status', 'statusText', 'headers'].forEach(prop => {
-        options[prop] = response[prop];
-      });
+      const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
 
-      const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
+      if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
+        const options = {};
 
-      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
-        responseContentLength,
-        progressEventReducer(asyncDecorator(onDownloadProgress), true)
-      ) || [];
+        ['status', 'statusText', 'headers'].forEach(prop => {
+          options[prop] = response[prop];
+        });
 
-      response = new Response(
-        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
-          flush && flush();
-          unsubscribe && unsubscribe();
-        }),
-        options
-      );
-    }
+        const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
 
-    responseType = responseType || 'text';
+        const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+          responseContentLength,
+          progressEventReducer(asyncDecorator(onDownloadProgress), true)
+        ) || [];
 
-    let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+        response = new Response(
+          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+            flush && flush();
+            unsubscribe && unsubscribe();
+          }),
+          options
+        );
+      }
 
-    !isStreamResponse && unsubscribe && unsubscribe();
+      responseType = responseType || 'text';
 
-    return await new Promise((resolve, reject) => {
-      settle(resolve, reject, {
-        data: responseData,
-        headers: AxiosHeaders.from(response.headers),
-        status: response.status,
-        statusText: response.statusText,
-        config,
-        request
-      });
-    })
-  } catch (err) {
-    unsubscribe && unsubscribe();
-
-    if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
-      throw Object.assign(
-        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
-        {
-          cause: err.cause || err
-        }
-      )
+      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+
+      !isStreamResponse && unsubscribe && unsubscribe();
+
+      return await new Promise((resolve, reject) => {
+        settle(resolve, reject, {
+          data: responseData,
+          headers: AxiosHeaders.from(response.headers),
+          status: response.status,
+          statusText: response.statusText,
+          config,
+          request
+        });
+      })
+    } catch (err) {
+      unsubscribe && unsubscribe();
+
+      if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
+        throw Object.assign(
+          new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
+          {
+            cause: err.cause || err
+          }
+        )
+      }
+
+      throw AxiosError.from(err, err && err.code, config, request);
     }
+  }
+};
+
+const seedCache = new Map();
+
+const getFetch = (config) => {
+  let env = config ? config.env : {};
+  const {fetch, Request, Response} = env;
+  const seeds = [
+    Request, Response, fetch
+  ];
+
+  let len = seeds.length, i = len,
+    seed, target, map = seedCache;
 
-    throw AxiosError.from(err, err && err.code, config, request);
+  while (i--) {
+    seed = seeds[i];
+    target = map.get(seed);
+
+    target === undefined && map.set(seed, target = (i ? new Map() : factory(env)));
+
+    map = target;
   }
-});
+
+  return target;
+};
+
+getFetch();
 
 const knownAdapters = {
   http: httpAdapter,
   xhr: xhrAdapter,
-  fetch: fetchAdapter
+  fetch: {
+    get: getFetch,
+  }
 };
 
 utils$1.forEach(knownAdapters, (fn, value) => {
@@ -2996,7 +3071,7 @@ const renderReason = (reason) => `- ${reason}`;
 const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;
 
 const adapters = {
-  getAdapter: (adapters) => {
+  getAdapter: (adapters, config) => {
     adapters = utils$1.isArray(adapters) ? adapters : [adapters];
 
     const {length} = adapters;
@@ -3019,7 +3094,7 @@ const adapters = {
         }
       }
 
-      if (adapter) {
+      if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config)))) {
         break;
       }
 
@@ -3087,7 +3162,7 @@ function dispatchRequest(config) {
     config.headers.setContentType('application/x-www-form-urlencoded', false);
   }
 
-  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);
+  const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);
 
   return adapter(config).then(function onAdapterResolution(response) {
     throwIfCancellationRequested(config);
@@ -3121,7 +3196,7 @@ function dispatchRequest(config) {
   });
 }
 
-const VERSION = "1.11.0";
+const VERSION = "1.12.2";
 
 const validators$1 = {};
 
@@ -3377,8 +3452,6 @@ class Axios {
 
     let newConfig = config;
 
-    i = 0;
-
     while (i < len) {
       const onFulfilled = requestInterceptorChain[i++];
       const onRejected = requestInterceptorChain[i++];
@@ -3800,10 +3873,18 @@ const poi = ref("");
  */
 const comparePoi = ref("");
 
+/** @type {import("vue").Ref<import("@eox/chart").EOxChart | null>} */
+const chartEl = shallowRef(null);
+
+/** @type {import("vue").Ref<import("@eox/chart").EOxChart | null>} */
+const compareChartEl = shallowRef(null);
+
 const states = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   activeTemplate,
   availableMapProjection,
+  chartEl,
+  compareChartEl,
   compareIndicator,
   comparePoi,
   currentCompareUrl,
@@ -3830,6 +3911,18 @@ const getLayers = () => mapEl.value?.layers.toReversed() ?? [];
 const getCompareLayers = () =>
   mapCompareEl.value?.layers.toReversed() ?? [];
 
+/**
+ * Returns the current chart spec from {@link chartEl}
+ * @returns {import("vega-embed").VisualizationSpec | null}
+ */
+const getChartSpec = () => chartEl.value?.spec ?? null;
+
+/**
+ * Returns the current chart spec from {@link compareChartEl}
+ * @returns {import("vega-embed").VisualizationSpec | null}
+ */
+const getCompareChartSpec = () => compareChartEl.value?.spec ?? null;
+
 /**
  * Register EPSG projection in `eox-map`
  * @param {string|number|{name: string, def: string, extent?:number[]}} [projection]*/
@@ -3906,6 +3999,8 @@ const includesProcess = (collection, compare = false) => {
 const actions = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   changeMapProjection,
+  getChartSpec,
+  getCompareChartSpec,
   getCompareLayers,
   getLayers,
   includesProcess,
@@ -3973,14 +4068,14 @@ function getStyleVariablesState(collectionId, variables) {
     return variables;
   }
   const matchingLayer = analysisGroup.layers?.find((layer) => {
-    const [collection, ..._other] = layer.properties?.id.split(";:;") ?? [
+    const [collection] = layer.properties?.id.split(";:;") ?? [
       "",
       "",
       "",
     ];
     return (
       collection === collectionId &&
-      ["Vector", "WebGLTile"].includes(layer?.type ?? "")
+      ["Vector", "WebGLTile", "VectorTile"].includes(layer?.type ?? "")
     );
   });
 
@@ -4054,14 +4149,28 @@ function generateFeatures(links, extraProperties = {}, rel = "item") {
  *
  * @param {string} collectionId
  *  @param { import("@/types").EodashStyleJson} [style]
+ * @param {Record<string,any>} [rasterJsonform]
  * */
-function extractLayerConfig(collectionId, style) {
-  if (!style) {
+function extractLayerConfig(collectionId, style, rasterJsonform) {
+  if (!style && !rasterJsonform) {
     return { layerConfig: undefined, style: undefined };
   }
-  style = { ...style };
+  if (style) {
+    style = { ...style };
+  }
 
-  if (Object.keys(style.variables ?? {}).length) {
+  if (rasterJsonform) {
+    return {
+      layerConfig: {
+        schema: rasterJsonform.jsonform,
+        legend: rasterJsonform.legend,
+        type: "tileUrl",
+      },
+      style,
+    };
+  }
+
+  if (style?.variables && Object.keys(style.variables ?? {}).length) {
     style.variables = getStyleVariablesState(collectionId, style.variables);
   }
 
@@ -4069,6 +4178,7 @@ function extractLayerConfig(collectionId, style) {
   let layerConfig = undefined;
 
   if (style?.jsonform) {
+    // this explicitly sets legend only if jsonform is configured
     layerConfig = { schema: style.jsonform, type: "style" };
     delete style.jsonform;
     if (style?.legend) {
@@ -4083,7 +4193,25 @@ function extractLayerConfig(collectionId, style) {
 
   return { layerConfig, style };
 }
-
+/**
+ *
+ * @param {number[]} bbox
+ * @returns
+ */
+const sanitizeBbox = (bbox) => {
+  if (!bbox || !bbox.length || bbox.length !== 4) {
+    return [0, 0, 0, 0];
+  }
+  let [minX, minY, maxX, maxY] = bbox;
+  // Normalize longitudes to be within -180 to 180
+  minX = Math.max(((minX + 180) % 360) - 180, -180);
+  maxX = Math.min(((maxX - 180) % 360) + 180, 180);
+  // Normalize latitudes to be within -90 to 90
+  minY = Math.max(((minY + 90) % 180) - 90, -90);
+  maxY = Math.min(((maxY - 90) % 180) + 90, 90);
+
+  return [minX, minY, maxX, maxY];
+};
 /**
  * Function to extract collection urls from an indicator
  * @param {import("stac-ts").StacCatalog
@@ -4108,6 +4236,10 @@ function extractCollectionUrls(stacObject, basepath) {
     return collectionUrls;
   }
   children.forEach((link) => {
+    if (link.href.startsWith("http")) {
+      collectionUrls.push(link.href);
+      return;
+    }
     collectionUrls.push(toAbsolute(link.href, basepath));
   });
   return collectionUrls;
@@ -4123,6 +4255,8 @@ const extractRoles = (properties, linkOrAsset) => {
   roles?.forEach((role) => {
     if (role === "visible") {
       properties.visible = true;
+    } else if (role === "invisible") {
+      properties.visible = false;
     }
     if (role === "overlay" || role === "baselayer") {
       properties.group = role;
@@ -4132,13 +4266,19 @@ const extractRoles = (properties, linkOrAsset) => {
 };
 
 /**
- * Extracts style JSON from a STAC Item
+ * Extracts a single non-link style JSON from a STAC Item optionally for a selected key mapping
  * @param {import("stac-ts").StacItem} item
  * @param {string} itemUrl
- * @returns
+ * @param {string | undefined} key
+ * @returns 
  **/
-const fetchStyle = async (item, itemUrl) => {
-  const styleLink = item.links.find((link) => link.rel.includes("style"));
+const fetchStyle = async (item, itemUrl, key=undefined) => {
+  let styleLink = null;
+  if (key) {
+    styleLink = item.links.find((link) => link.rel.includes("style") && link["links:keys"] && /** @type {Array<string>} */ (link["links:keys"]).includes(key) );
+  } else {
+    styleLink = item.links.find((link) => link.rel.includes("style") && !link["links:keys"]);
+  }
   if (styleLink) {
     let url = "";
     if (styleLink.href.startsWith("http")) {
@@ -4155,6 +4295,27 @@ const fetchStyle = async (item, itemUrl) => {
   }
 };
 
+/**
+ * Fetches all style JSONs from a STAC Item and returns an array with style objects
+ * @param {import("stac-ts").StacItem} item
+ * @param {string} itemUrl
+ * @returns { Promise <Array<import("@/types").EodashStyleJson>>}
+ **/
+const fetchAllStyles = async (item, itemUrl) => {
+  const styleLinks = item.links.filter((link) => link.rel.includes("style"));
+  const fetchPromises = styleLinks.map(async (link) => {
+    let url = link.href.startsWith("http")
+      ? link.href
+      : toAbsolute(link.href, itemUrl);
+
+    const styleJson = await axios.get(url).then((resp) => resp.data);
+    log.debug("fetched styles JSON", JSON.parse(JSON.stringify(styleJson)));
+    return styleJson;
+  });
+  const results = await Promise.all(fetchPromises);
+  return results;
+};
+
 /**
  * Return projection code which is to be registered in `eox-map`
  * @param {string|number|{name: string, def: string}} [projection]
@@ -4177,60 +4338,90 @@ const getProjectionCode = (projection) => {
 
 /**
  * Extracts layercontrol LayerDatetime property from STAC Links
- * @param {import("stac-ts").StacLink[]} [links]
+ * @param {import("stac-ts").StacLink[] | import("stac-ts").StacItem[] | undefined} [items]
  * @param {string|null} [currentStep]
  **/
-const extractLayerDatetime = (links, currentStep) => {
-  if (!currentStep || !links?.length) {
-    return undefined;
+const extractLayerTimeValues = (items, currentStep) => {
+  if (!currentStep || !items?.length) {
+    return { layerDatetime: undefined, timeControlValues: undefined };
   }
 
-  // check if links has a datetime value
-  const dateProperty = getDatetimeProperty(links);
+  // check if items has a datetime value
+  const dateProperty = getDatetimeProperty(items);
 
   if (!dateProperty) {
-    return undefined;
+    return { layerDatetime: undefined, timeControlValues: undefined };
   }
-
-  /** @type {string[]} */
-  const controlValues = [];
+  /** @type {{date:string;itemId:string}[]} */
+  const timeValues = [];
   try {
-    currentStep = new Date(currentStep).toISOString();
-    links.reduce((vals, link) => {
+    /**
+     *  @param {typeof timeValues} vals
+     *  @param {import("stac-ts").StacLink} link
+     */
+    const reduceLinks = (vals, link) => {
       if (link[dateProperty] && link.rel === "item") {
-        vals.push(
-          new Date(/** @type {string} */ (link[dateProperty])).toISOString(),
-        );
+        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;
-    }, controlValues);
+    };
+    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 undefined;
+    return { layerDatetime: undefined, timeControlValues: undefined };
   }
-  // not enough controlValues
-  if (controlValues.length <= 1) {
-    return undefined;
+  // not enough timeValues
+  if (timeValues.length <= 1) {
+    return { layerDatetime: undefined, timeControlValues: undefined };
   }
 
   // item datetime is not included in the item links datetime
-  if (!controlValues.includes(currentStep)) {
+  if (!timeValues.some((val) => val.date === currentStep)) {
     const currentStepTime = new Date(currentStep).getTime();
-    currentStep = controlValues.reduce((a, b) => {
-      const aDiff = Math.abs(new Date(a).getTime() - currentStepTime);
-      const bDiff = Math.abs(new Date(b).getTime() - currentStepTime);
-      return bDiff < aDiff ? b : a;
-    });
+    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);
   }
 
-  return {
-    controlValues,
+  const layerDatetime = {
+    controlValues: timeValues.map((d) => d.date).sort(),
     currentStep,
     slider: true,
     navigation: true,
     play: false,
     displayFormat: "DD.MM.YYYY HH:mm",
   };
+
+  return {
+    layerDatetime,
+    timeControlValues: timeValues,
+  };
 };
 
 /**
@@ -4293,25 +4484,17 @@ const replaceLayer = (currentLayers, oldLayer, newLayers) => {
  * @param {import('../eodashSTAC/EodashCollection.js').EodashCollection[]} indicators
  * @param {import('ol/layer').Layer} layer
  */
-const getColFromLayer = (indicators, layer) => {
-  // init cols
-  const collections = indicators.map((ind) => ind.collectionStac);
-  const [collectionId, itemId, ..._other] = layer.get("id").split(";:;");
-
-  const chosen = collections.find((col) => {
-    const isInd =
-      col?.id === collectionId &&
-      col?.links?.some(
-        (link) =>
-          link.rel === "item" &&
-          (link.href.includes(itemId) ||
-            link.id === itemId ||
-            //@ts-expect-error attaching the item in link when parsing .parquet items, see @/eodashSTAC/parquet.js
-            (link["item"] && link["item"].id === itemId)),
-      );
-    return isInd;
-  });
-  return indicators.find((ind) => ind.collectionStac?.id === chosen?.id);
+const getColFromLayer = async (indicators, layer) => {
+  const [collectionId, itemId] = layer.get("id").split(";:;");
+
+  for (const ind of indicators) {
+    if (ind.collectionStac?.id !== collectionId) continue;
+    const items = await ind.getItems();
+    const itemIds = items?.map(item => item.id || item.datetime) ?? [];
+    if (itemIds.includes(itemId)) {
+      return ind;
+    }
+  }
 };
 
 /**
@@ -4326,14 +4509,14 @@ const getColFromLayer = (indicators, layer) => {
  */
 const createLayerID = (collectionId, itemId, link, projectionCode) => {
   const linkId = link.id || link.title || link.href;
-  let lId = `${collectionId ?? ""};:;${itemId ?? ""};:;${linkId ?? ""};:;${projectionCode}`;
+  let lId = `${collectionId ?? ""};:;${itemId ?? ""};:;${linkId ?? ""};:;${projectionCode ?? ""}`;
   // If we are looking at base layers and overlays we remove the collection and item part
   // as we want to make sure tiles are not reloaded when switching layers
   if (
     /** @type {string[]} */
     (link.roles)?.find((r) => ["baselayer", "overlay"].includes(r))
   ) {
-    lId = `${linkId ?? ""};:;${projectionCode}`;
+    lId = `${linkId ?? ""};:;${projectionCode ?? ""}`;
   }
   log.debug("Generated Layer ID", lId);
   return lId;
@@ -4393,12 +4576,20 @@ async function mergeGeojsons(geojsonUrls) {
     features: [],
   };
   await Promise.all(
-    geojsonUrls.map((url) =>
-      axios.get(url).then((resp) => {
+    geojsonUrls.map((url) => {
+      // Use native fetch for blob URLs to avoid axios/cache interceptor issues
+      if (url.startsWith("blob:")) {
+        return fetch(url)
+          .then(async (resp) => await resp.json())
+          .then((geojson) => {
+            merged.features.push(...(geojson.features ?? []));
+          });
+      }
+      return axios.get(url).then((resp) => {
         const geojson = resp.data;
         merged.features.push(...(geojson.features ?? []));
-      }),
-    ),
+      });
+    }),
   );
 
   return encodeURI(
@@ -4512,16 +4703,37 @@ const addTooltipInteraction = (layer, style) => {
 
 /**
  *
- * @param {import("stac-ts").StacLink[]} [links]
+ * @param {import("stac-ts").StacLink[] | import("stac-ts").StacItem[] |undefined |null} [linksOrItems]
  */
-function getDatetimeProperty(links) {
-  if (!links?.length) {
+function getDatetimeProperty(linksOrItems) {
+  if (!linksOrItems?.length) {
     return undefined;
   }
+  const first = linksOrItems[0];
+  let checkProperties = false;
+  if (isSTACItem(first)) {
+    checkProperties = true;
+  }
+
   // TODO: consider other properties for datetime ranges
   const datetimeProperties = ["datetime", "start_datetime", "end_datetime"];
+  if (checkProperties) {
+    for (const prop of datetimeProperties) {
+      const propExists = linksOrItems.some(
+        (l) =>
+          //@ts-expect-error TODO
+          l["properties"]?.[prop] &&
+          //@ts-expect-error TODO
+          typeof l["properties"]?.[prop] === "string",
+      );
+      if (!propExists) {
+        continue;
+      }
+      return prop;
+    }
+  }
   for (const prop of datetimeProperties) {
-    const propExists = links.some(
+    const propExists = linksOrItems.some(
       (l) => l[prop] && typeof l[prop] === "string",
     );
     if (!propExists) {
@@ -4530,7 +4742,82 @@ function getDatetimeProperty(links) {
     return prop;
   }
 }
+/**
+ *
+ * @param {*} stacObject
+ * @returns {stacObject is import("stac-ts").StacItem}
+ */
+function isSTACItem(stacObject) {
+  return (
+    stacObject &&
+    typeof stacObject === "object" &&
+    stacObject.collection &&
+    stacObject.id &&
+    stacObject.properties &&
+    typeof stacObject.properties === "object"
+  );
+}
+
+/**
+ * Fetch all STAC items from a STAC API endpoint.
+ * @param {string} itemsUrl
+ * @param {string} [query]
+ * @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.
+ */
+async function fetchApiItems(
+  itemsUrl,
+  query,
+  limit = 100,
+  returnFirst = false,
+  maxNumber = 1000,
+) {
+  itemsUrl = itemsUrl.includes("?") ? itemsUrl.split("?")[0] : itemsUrl;
+  itemsUrl += query ? `?limit=${limit}&${query}` : `?limit=${limit}`;
+
+  const itemsFeatureCollection = await axios
+    .get(itemsUrl)
+    .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) {
+    return items;
+  }
+  /** @type {number} */
+  const matchedItems = itemsFeatureCollection.numberMatched;
+  // Avoid fetching too many items
+  if (matchedItems >= maxNumber) {
+    console.warn(
+      `[eodash] The number of items matched (${matchedItems}) exceeds the maximum allowed (${maxNumber})`,
+    );
+    return items;
+  }
 
+  let [nextLinkURL, nextLinkQuery] = nextLink.href.split("?");
+  nextLinkQuery = nextLinkQuery.replace(/limit=\d+/, "");
+  if (query) {
+    const queryParams = new URLSearchParams(query);
+    const nextLinkParams = new URLSearchParams(nextLinkQuery);
+
+    for (const key of nextLinkParams.keys()) {
+      queryParams.delete(key);
+    }
+    const remainingQuery = queryParams.toString();
+    if (remainingQuery) {
+      nextLinkQuery += `&${remainingQuery}`;
+    }
+  }
+
+  const nextPage = await fetchApiItems(nextLinkURL, nextLinkQuery);
+  items.push(...nextPage);
+  return items;
+}
 /**
  * @param {import ("stac-ts").StacCollection | undefined | null} collection
  * @returns {object}
@@ -4553,4 +4840,4 @@ function extractLayerLegend(collection) {
   return extraProperties;
 }
 
-export { activeTemplate as A, mapPosition as B, indicator as C, compareIndicator as D, comparePoi as E, states as F, actions as G, includesProcess as H, mapCompareEl as I, getColFromLayer as J, setMapProjFromCol as K, availableMapProjection as L, changeMapProjection as M, setActiveTemplate as N, axios$1 as O, removeUnneededProperties as P, createAssetID as a, addTooltipInteraction as b, createLayerID as c, mapEl as d, extractRoles as e, axios as f, getProjectionCode as g, extractLayerConfig as h, fetchStyle as i, extractLayerDatetime as j, getDatetimeProperty as k, getLayers as l, mergeGeojsons as m, getCompareLayers as n, findLayer as o, replaceLayer as p, generateFeatures as q, registerProjection as r, extractLayerLegend as s, extractCollectionUrls as t, generateLinksFromItems as u, revokeCollectionBlobUrls as v, currentCompareUrl as w, currentUrl as x, datetime as y, poi as z };
+export { datetime as A, poi as B, activeTemplate as C, mapPosition as D, indicator as E, currentCompareUrl as F, compareIndicator as G, comparePoi as H, states as I, actions as J, includesProcess as K, sanitizeBbox as L, mapCompareEl as M, getColFromLayer as N, setMapProjFromCol as O, availableMapProjection as P, changeMapProjection as Q, setActiveTemplate as R, compareChartEl as S, chartEl as T, axios$1 as U, removeUnneededProperties as V, getChartSpec as W, extractLayerConfig as a, addTooltipInteraction as b, createLayerID as c, createAssetID as d, extractRoles as e, fetchStyle as f, getProjectionCode as g, mapEl as h, isSTACItem as i, axios as j, extractLayerTimeValues as k, fetchApiItems as l, mergeGeojsons as m, getDatetimeProperty as n, fetchAllStyles as o, getLayers as p, getCompareLayers as q, registerProjection as r, findLayer as s, replaceLayer as t, generateFeatures as u, extractLayerLegend as v, extractCollectionUrls as w, generateLinksFromItems as x, revokeCollectionBlobUrls as y, currentUrl as z };