@microlink/mql 0.10.11 → 0.10.15

package/dist/mql.js

@@ -349,10 +349,10 @@
 	  const mapRules = rules => {
 	    if (!isObject(rules)) return
 	    const flatRules = flatten(rules);
-	    return Object.keys(flatRules).reduce(
-	      (acc, key) => ({ ...acc, [`data.${key}`]: flatRules[key].toString() }),
-	      {}
-	    )
+	    return Object.keys(flatRules).reduce((acc, key) => {
+	      acc[`data.${key}`] = flatRules[key].toString();
+	      return acc
+	    }, {})
 	  };
 
 	  const fetchFromApi = async (apiUrl, opts = {}, retryCount = 0) => {
@@ -432,503 +432,405 @@
 
 	(function (module, exports) {
 	(function (global, factory) {
-		module.exports = factory() ;
-	}(commonjsGlobal, (function () {
-		/*! MIT License © Sindre Sorhus */
-
-		const isObject = value => value !== null && typeof value === 'object';
-		const supportsAbortController = typeof globalThis.AbortController === 'function';
-		const supportsStreams = typeof globalThis.ReadableStream === 'function';
-		const supportsFormData = typeof globalThis.FormData === 'function';
-
-		const mergeHeaders = (source1, source2) => {
-			const result = new globalThis.Headers(source1 || {});
-			const isHeadersInstance = source2 instanceof globalThis.Headers;
-			const source = new globalThis.Headers(source2 || {});
-
-			for (const [key, value] of source) {
-				if ((isHeadersInstance && value === 'undefined') || value === undefined) {
-					result.delete(key);
-				} else {
-					result.set(key, value);
-				}
-			}
-
-			return result;
-		};
-
-		const deepMerge = (...sources) => {
-			let returnValue = {};
-			let headers = {};
-
-			for (const source of sources) {
-				if (Array.isArray(source)) {
-					if (!(Array.isArray(returnValue))) {
-						returnValue = [];
-					}
-
-					returnValue = [...returnValue, ...source];
-				} else if (isObject(source)) {
-					for (let [key, value] of Object.entries(source)) {
-						if (isObject(value) && (key in returnValue)) {
-							value = deepMerge(returnValue[key], value);
-						}
-
-						returnValue = {...returnValue, [key]: value};
-					}
-
-					if (isObject(source.headers)) {
-						headers = mergeHeaders(headers, source.headers);
-					}
-				}
-
-				returnValue.headers = headers;
-			}
-
-			return returnValue;
-		};
-
-		const requestMethods = [
-			'get',
-			'post',
-			'put',
-			'patch',
-			'head',
-			'delete'
-		];
-
-		const responseTypes = {
-			json: 'application/json',
-			text: 'text/*',
-			formData: 'multipart/form-data',
-			arrayBuffer: '*/*',
-			blob: '*/*'
-		};
-
-		const retryMethods = [
-			'get',
-			'put',
-			'head',
-			'delete',
-			'options',
-			'trace'
-		];
-
-		const retryStatusCodes = [
-			408,
-			413,
-			429,
-			500,
-			502,
-			503,
-			504
-		];
-
-		const retryAfterStatusCodes = [
-			413,
-			429,
-			503
-		];
-
-		const stop = Symbol('stop');
-
-		class HTTPError extends Error {
-			constructor(response, request, options) {
-				// Set the message to the status text, such as Unauthorized,
-				// with some fallbacks. This message should never be undefined.
-				super(
-					response.statusText ||
-					String(
-						(response.status === 0 || response.status) ?
-							response.status : 'Unknown response error'
-					)
-				);
-				this.name = 'HTTPError';
-				this.response = response;
-				this.request = request;
-				this.options = options;
-			}
-		}
-
-		class TimeoutError extends Error {
-			constructor(request) {
-				super('Request timed out');
-				this.name = 'TimeoutError';
-				this.request = request;
-			}
-		}
-
-		const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-		// `Promise.race()` workaround (#91)
-		const timeout = (request, abortController, options) =>
-			new Promise((resolve, reject) => {
-				const timeoutID = setTimeout(() => {
-					if (abortController) {
-						abortController.abort();
-					}
-
-					reject(new TimeoutError(request));
-				}, options.timeout);
-
-				/* eslint-disable promise/prefer-await-to-then */
-				options.fetch(request)
-					.then(resolve)
-					.catch(reject)
-					.then(() => {
-						clearTimeout(timeoutID);
-					});
-				/* eslint-enable promise/prefer-await-to-then */
-			});
-
-		const normalizeRequestMethod = input => requestMethods.includes(input) ? input.toUpperCase() : input;
-
-		const defaultRetryOptions = {
-			limit: 2,
-			methods: retryMethods,
-			statusCodes: retryStatusCodes,
-			afterStatusCodes: retryAfterStatusCodes
-		};
-
-		const normalizeRetryOptions = (retry = {}) => {
-			if (typeof retry === 'number') {
-				return {
-					...defaultRetryOptions,
-					limit: retry
-				};
-			}
-
-			if (retry.methods && !Array.isArray(retry.methods)) {
-				throw new Error('retry.methods must be an array');
-			}
-
-			if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-				throw new Error('retry.statusCodes must be an array');
-			}
-
-			return {
-				...defaultRetryOptions,
-				...retry,
-				afterStatusCodes: retryAfterStatusCodes
-			};
-		};
-
-		// The maximum value of a 32bit int (see issue #117)
-		const maxSafeTimeout = 2147483647;
-
-		class Ky {
-			constructor(input, options = {}) {
-				this._retryCount = 0;
-				this._input = input;
-				this._options = {
-					// TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
-					credentials: this._input.credentials || 'same-origin',
-					...options,
-					headers: mergeHeaders(this._input.headers, options.headers),
-					hooks: deepMerge({
-						beforeRequest: [],
-						beforeRetry: [],
-						afterResponse: []
-					}, options.hooks),
-					method: normalizeRequestMethod(options.method || this._input.method),
-					prefixUrl: String(options.prefixUrl || ''),
-					retry: normalizeRetryOptions(options.retry),
-					throwHttpErrors: options.throwHttpErrors !== false,
-					timeout: typeof options.timeout === 'undefined' ? 10000 : options.timeout,
-					fetch: options.fetch || globalThis.fetch.bind(globalThis)
-				};
-
-				if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
-					throw new TypeError('`input` must be a string, URL, or Request');
-				}
-
-				if (this._options.prefixUrl && typeof this._input === 'string') {
-					if (this._input.startsWith('/')) {
-						throw new Error('`input` must not begin with a slash when using `prefixUrl`');
-					}
-
-					if (!this._options.prefixUrl.endsWith('/')) {
-						this._options.prefixUrl += '/';
-					}
-
-					this._input = this._options.prefixUrl + this._input;
-				}
-
-				if (supportsAbortController) {
-					this.abortController = new globalThis.AbortController();
-					if (this._options.signal) {
-						this._options.signal.addEventListener('abort', () => {
-							this.abortController.abort();
-						});
-					}
-
-					this._options.signal = this.abortController.signal;
-				}
-
-				this.request = new globalThis.Request(this._input, this._options);
-
-				if (this._options.searchParams) {
-					const textSearchParams = typeof this._options.searchParams === 'string' ?
-						this._options.searchParams.replace(/^\?/, '') :
-						new URLSearchParams(this._options.searchParams).toString();
-					const searchParams = '?' + textSearchParams;
-					const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-
-					// To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one
-					if (((supportsFormData && this._options.body instanceof globalThis.FormData) || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
-						this.request.headers.delete('content-type');
-					}
-
-					this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
-				}
-
-				if (this._options.json !== undefined) {
-					this._options.body = JSON.stringify(this._options.json);
-					this.request.headers.set('content-type', 'application/json');
-					this.request = new globalThis.Request(this.request, {body: this._options.body});
-				}
-
-				const fn = async () => {
-					if (this._options.timeout > maxSafeTimeout) {
-						throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-					}
-
-					await delay(1);
-					let response = await this._fetch();
-
-					for (const hook of this._options.hooks.afterResponse) {
-						// eslint-disable-next-line no-await-in-loop
-						const modifiedResponse = await hook(
-							this.request,
-							this._options,
-							this._decorateResponse(response.clone())
-						);
-
-						if (modifiedResponse instanceof globalThis.Response) {
-							response = modifiedResponse;
-						}
-					}
-
-					this._decorateResponse(response);
-
-					if (!response.ok && this._options.throwHttpErrors) {
-						throw new HTTPError(response, this.request, this._options);
-					}
-
-					// If `onDownloadProgress` is passed, it uses the stream API internally
-					/* istanbul ignore next */
-					if (this._options.onDownloadProgress) {
-						if (typeof this._options.onDownloadProgress !== 'function') {
-							throw new TypeError('The `onDownloadProgress` option must be a function');
-						}
-
-						if (!supportsStreams) {
-							throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
-						}
-
-						return this._stream(response.clone(), this._options.onDownloadProgress);
-					}
-
-					return response;
-				};
-
-				const isRetriableMethod = this._options.retry.methods.includes(this.request.method.toLowerCase());
-				const result = isRetriableMethod ? this._retry(fn) : fn();
-
-				for (const [type, mimeType] of Object.entries(responseTypes)) {
-					result[type] = async () => {
-						this.request.headers.set('accept', this.request.headers.get('accept') || mimeType);
-
-						const response = (await result).clone();
-
-						if (type === 'json') {
-							if (response.status === 204) {
-								return '';
-							}
-
-							if (options.parseJson) {
-								return options.parseJson(await response.text());
-							}
-						}
-
-						return response[type]();
-					};
-				}
-
-				return result;
-			}
-
-			_calculateRetryDelay(error) {
-				this._retryCount++;
-
-				if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
-					if (error instanceof HTTPError) {
-						if (!this._options.retry.statusCodes.includes(error.response.status)) {
-							return 0;
-						}
-
-						const retryAfter = error.response.headers.get('Retry-After');
-						if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-							let after = Number(retryAfter);
-							if (Number.isNaN(after)) {
-								after = Date.parse(retryAfter) - Date.now();
-							} else {
-								after *= 1000;
-							}
-
-							if (typeof this._options.retry.maxRetryAfter !== 'undefined' && after > this._options.retry.maxRetryAfter) {
-								return 0;
-							}
-
-							return after;
-						}
-
-						if (error.response.status === 413) {
-							return 0;
-						}
-					}
-
-					const BACKOFF_FACTOR = 0.3;
-					return BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000;
-				}
-
-				return 0;
-			}
-
-			_decorateResponse(response) {
-				if (this._options.parseJson) {
-					response.json = async () => {
-						return this._options.parseJson(await response.text());
-					};
-				}
-
-				return response;
-			}
-
-			async _retry(fn) {
-				try {
-					return await fn();
-				} catch (error) {
-					const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-					if (ms !== 0 && this._retryCount > 0) {
-						await delay(ms);
-
-						for (const hook of this._options.hooks.beforeRetry) {
-							// eslint-disable-next-line no-await-in-loop
-							const hookResult = await hook({
-								request: this.request,
-								options: this._options,
-								error,
-								retryCount: this._retryCount
-							});
-
-							// If `stop` is returned from the hook, the retry process is stopped
-							if (hookResult === stop) {
-								return;
-							}
-						}
-
-						return this._retry(fn);
-					}
-
-					if (this._options.throwHttpErrors) {
-						throw error;
-					}
-				}
-			}
-
-			async _fetch() {
-				for (const hook of this._options.hooks.beforeRequest) {
-					// eslint-disable-next-line no-await-in-loop
-					const result = await hook(this.request, this._options);
-
-					if (result instanceof Request) {
-						this.request = result;
-						break;
-					}
-
-					if (result instanceof Response) {
-						return result;
-					}
-				}
-
-				if (this._options.timeout === false) {
-					return this._options.fetch(this.request.clone());
-				}
-
-				return timeout(this.request.clone(), this.abortController, this._options);
-			}
-
-			/* istanbul ignore next */
-			_stream(response, onDownloadProgress) {
-				const totalBytes = Number(response.headers.get('content-length')) || 0;
-				let transferredBytes = 0;
-
-				return new globalThis.Response(
-					new globalThis.ReadableStream({
-						async start(controller) {
-							const reader = response.body.getReader();
-
-							if (onDownloadProgress) {
-								onDownloadProgress({percent: 0, transferredBytes: 0, totalBytes}, new Uint8Array());
-							}
-
-							async function read() {
-								const {done, value} = await reader.read();
-								if (done) {
-									controller.close();
-									return;
-								}
-
-								if (onDownloadProgress) {
-									transferredBytes += value.byteLength;
-									const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-									onDownloadProgress({percent, transferredBytes, totalBytes}, value);
-								}
-
-								controller.enqueue(value);
-								await read();
-							}
-
-							await read();
-						}
-					})
-				);
-			}
-		}
-
-		const validateAndMerge = (...sources) => {
-			for (const source of sources) {
-				if ((!isObject(source) || Array.isArray(source)) && typeof source !== 'undefined') {
-					throw new TypeError('The `options` argument must be an object');
-				}
-			}
-
-			return deepMerge({}, ...sources);
-		};
-
-		const createInstance = defaults => {
-			const ky = (input, options) => new Ky(input, validateAndMerge(defaults, options));
-
-			for (const method of requestMethods) {
-				ky[method] = (input, options) => new Ky(input, validateAndMerge(defaults, options, {method}));
-			}
-
-			ky.HTTPError = HTTPError;
-			ky.TimeoutError = TimeoutError;
-			ky.create = newDefaults => createInstance(validateAndMerge(newDefaults));
-			ky.extend = newDefaults => createInstance(validateAndMerge(defaults, newDefaults));
-			ky.stop = stop;
+	    factory(exports) ;
+	})(commonjsGlobal, (function (exports) {
+	    // eslint-lint-disable-next-line @typescript-eslint/naming-convention
+	    class HTTPError extends Error {
+	        constructor(response, request, options) {
+	            const code = (response.status || response.status === 0) ? response.status : '';
+	            const title = response.statusText || '';
+	            const status = `${code} ${title}`.trim();
+	            const reason = status ? `status code ${status}` : 'an unknown error';
+	            super(`Request failed with ${reason}`);
+	            this.name = 'HTTPError';
+	            this.response = response;
+	            this.request = request;
+	            this.options = options;
+	        }
+	    }
 
-			return ky;
-		};
+	    class TimeoutError extends Error {
+	        constructor(request) {
+	            super('Request timed out');
+	            this.name = 'TimeoutError';
+	            this.request = request;
+	        }
+	    }
 
-		const ky = createInstance();
+	    // eslint-disable-next-line @typescript-eslint/ban-types
+	    const isObject = (value) => value !== null && typeof value === 'object';
+
+	    const validateAndMerge = (...sources) => {
+	        for (const source of sources) {
+	            if ((!isObject(source) || Array.isArray(source)) && typeof source !== 'undefined') {
+	                throw new TypeError('The `options` argument must be an object');
+	            }
+	        }
+	        return deepMerge({}, ...sources);
+	    };
+	    const mergeHeaders = (source1 = {}, source2 = {}) => {
+	        const result = new globalThis.Headers(source1);
+	        const isHeadersInstance = source2 instanceof globalThis.Headers;
+	        const source = new globalThis.Headers(source2);
+	        for (const [key, value] of source.entries()) {
+	            if ((isHeadersInstance && value === 'undefined') || value === undefined) {
+	                result.delete(key);
+	            }
+	            else {
+	                result.set(key, value);
+	            }
+	        }
+	        return result;
+	    };
+	    // TODO: Make this strongly-typed (no `any`).
+	    const deepMerge = (...sources) => {
+	        let returnValue = {};
+	        let headers = {};
+	        for (const source of sources) {
+	            if (Array.isArray(source)) {
+	                if (!Array.isArray(returnValue)) {
+	                    returnValue = [];
+	                }
+	                returnValue = [...returnValue, ...source];
+	            }
+	            else if (isObject(source)) {
+	                for (let [key, value] of Object.entries(source)) {
+	                    if (isObject(value) && key in returnValue) {
+	                        value = deepMerge(returnValue[key], value);
+	                    }
+	                    returnValue = { ...returnValue, [key]: value };
+	                }
+	                if (isObject(source.headers)) {
+	                    headers = mergeHeaders(headers, source.headers);
+	                    returnValue.headers = headers;
+	                }
+	            }
+	        }
+	        return returnValue;
+	    };
+
+	    const supportsAbortController = typeof globalThis.AbortController === 'function';
+	    const supportsStreams = typeof globalThis.ReadableStream === 'function';
+	    const supportsFormData = typeof globalThis.FormData === 'function';
+	    const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
+	    const responseTypes = {
+	        json: 'application/json',
+	        text: 'text/*',
+	        formData: 'multipart/form-data',
+	        arrayBuffer: '*/*',
+	        blob: '*/*',
+	    };
+	    // The maximum value of a 32bit int (see issue #117)
+	    const maxSafeTimeout = 2147483647;
+	    const stop = Symbol('stop');
+
+	    const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+	    const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];
+	    const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+	    const retryAfterStatusCodes = [413, 429, 503];
+	    const defaultRetryOptions = {
+	        limit: 2,
+	        methods: retryMethods,
+	        statusCodes: retryStatusCodes,
+	        afterStatusCodes: retryAfterStatusCodes,
+	        maxRetryAfter: Number.POSITIVE_INFINITY,
+	    };
+	    const normalizeRetryOptions = (retry = {}) => {
+	        if (typeof retry === 'number') {
+	            return {
+	                ...defaultRetryOptions,
+	                limit: retry,
+	            };
+	        }
+	        if (retry.methods && !Array.isArray(retry.methods)) {
+	            throw new Error('retry.methods must be an array');
+	        }
+	        if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+	            throw new Error('retry.statusCodes must be an array');
+	        }
+	        return {
+	            ...defaultRetryOptions,
+	            ...retry,
+	            afterStatusCodes: retryAfterStatusCodes,
+	        };
+	    };
+
+	    // `Promise.race()` workaround (#91)
+	    const timeout = async (request, abortController, options) => new Promise((resolve, reject) => {
+	        const timeoutId = setTimeout(() => {
+	            if (abortController) {
+	                abortController.abort();
+	            }
+	            reject(new TimeoutError(request));
+	        }, options.timeout);
+	        /* eslint-disable promise/prefer-await-to-then */
+	        void options
+	            .fetch(request)
+	            .then(resolve)
+	            .catch(reject)
+	            .then(() => {
+	            clearTimeout(timeoutId);
+	        });
+	        /* eslint-enable promise/prefer-await-to-then */
+	    });
+	    const delay = async (ms) => new Promise(resolve => {
+	        setTimeout(resolve, ms);
+	    });
 
-		return ky;
+	    class Ky {
+	        // eslint-disable-next-line complexity
+	        constructor(input, options = {}) {
+	            var _a, _b;
+	            this._retryCount = 0;
+	            this._input = input;
+	            this._options = {
+	                // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
+	                credentials: this._input.credentials || 'same-origin',
+	                ...options,
+	                headers: mergeHeaders(this._input.headers, options.headers),
+	                hooks: deepMerge({
+	                    beforeRequest: [],
+	                    beforeRetry: [],
+	                    afterResponse: [],
+	                }, options.hooks),
+	                method: normalizeRequestMethod((_a = options.method) !== null && _a !== void 0 ? _a : this._input.method),
+	                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+	                prefixUrl: String(options.prefixUrl || ''),
+	                retry: normalizeRetryOptions(options.retry),
+	                throwHttpErrors: options.throwHttpErrors !== false,
+	                timeout: typeof options.timeout === 'undefined' ? 10000 : options.timeout,
+	                fetch: (_b = options.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis),
+	            };
+	            if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+	                throw new TypeError('`input` must be a string, URL, or Request');
+	            }
+	            if (this._options.prefixUrl && typeof this._input === 'string') {
+	                if (this._input.startsWith('/')) {
+	                    throw new Error('`input` must not begin with a slash when using `prefixUrl`');
+	                }
+	                if (!this._options.prefixUrl.endsWith('/')) {
+	                    this._options.prefixUrl += '/';
+	                }
+	                this._input = this._options.prefixUrl + this._input;
+	            }
+	            if (supportsAbortController) {
+	                this.abortController = new globalThis.AbortController();
+	                if (this._options.signal) {
+	                    this._options.signal.addEventListener('abort', () => {
+	                        this.abortController.abort();
+	                    });
+	                }
+	                this._options.signal = this.abortController.signal;
+	            }
+	            this.request = new globalThis.Request(this._input, this._options);
+	            if (this._options.searchParams) {
+	                // eslint-disable-next-line unicorn/prevent-abbreviations
+	                const textSearchParams = typeof this._options.searchParams === 'string'
+	                    ? this._options.searchParams.replace(/^\?/, '')
+	                    : new URLSearchParams(this._options.searchParams).toString();
+	                // eslint-disable-next-line unicorn/prevent-abbreviations
+	                const searchParams = '?' + textSearchParams;
+	                const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+	                // To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one
+	                if (((supportsFormData && this._options.body instanceof globalThis.FormData)
+	                    || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
+	                    this.request.headers.delete('content-type');
+	                }
+	                this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
+	            }
+	            if (this._options.json !== undefined) {
+	                this._options.body = JSON.stringify(this._options.json);
+	                this.request.headers.set('content-type', 'application/json');
+	                this.request = new globalThis.Request(this.request, { body: this._options.body });
+	            }
+	        }
+	        // eslint-disable-next-line @typescript-eslint/promise-function-async
+	        static create(input, options) {
+	            const ky = new Ky(input, options);
+	            const fn = async () => {
+	                if (ky._options.timeout > maxSafeTimeout) {
+	                    throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+	                }
+	                // Delay the fetch so that body method shortcuts can set the Accept header
+	                await Promise.resolve();
+	                let response = await ky._fetch();
+	                for (const hook of ky._options.hooks.afterResponse) {
+	                    // eslint-disable-next-line no-await-in-loop
+	                    const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
+	                    if (modifiedResponse instanceof globalThis.Response) {
+	                        response = modifiedResponse;
+	                    }
+	                }
+	                ky._decorateResponse(response);
+	                if (!response.ok && ky._options.throwHttpErrors) {
+	                    throw new HTTPError(response, ky.request, ky._options);
+	                }
+	                // If `onDownloadProgress` is passed, it uses the stream API internally
+	                /* istanbul ignore next */
+	                if (ky._options.onDownloadProgress) {
+	                    if (typeof ky._options.onDownloadProgress !== 'function') {
+	                        throw new TypeError('The `onDownloadProgress` option must be a function');
+	                    }
+	                    if (!supportsStreams) {
+	                        throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
+	                    }
+	                    return ky._stream(response.clone(), ky._options.onDownloadProgress);
+	                }
+	                return response;
+	            };
+	            const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
+	            const result = (isRetriableMethod ? ky._retry(fn) : fn());
+	            for (const [type, mimeType] of Object.entries(responseTypes)) {
+	                result[type] = async () => {
+	                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+	                    ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
+	                    const response = (await result).clone();
+	                    if (type === 'json') {
+	                        if (response.status === 204) {
+	                            return '';
+	                        }
+	                        if (options.parseJson) {
+	                            return options.parseJson(await response.text());
+	                        }
+	                    }
+	                    return response[type]();
+	                };
+	            }
+	            return result;
+	        }
+	        _calculateRetryDelay(error) {
+	            this._retryCount++;
+	            if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
+	                if (error instanceof HTTPError) {
+	                    if (!this._options.retry.statusCodes.includes(error.response.status)) {
+	                        return 0;
+	                    }
+	                    const retryAfter = error.response.headers.get('Retry-After');
+	                    if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+	                        let after = Number(retryAfter);
+	                        if (Number.isNaN(after)) {
+	                            after = Date.parse(retryAfter) - Date.now();
+	                        }
+	                        else {
+	                            after *= 1000;
+	                        }
+	                        if (typeof this._options.retry.maxRetryAfter !== 'undefined' && after > this._options.retry.maxRetryAfter) {
+	                            return 0;
+	                        }
+	                        return after;
+	                    }
+	                    if (error.response.status === 413) {
+	                        return 0;
+	                    }
+	                }
+	                const BACKOFF_FACTOR = 0.3;
+	                return BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000;
+	            }
+	            return 0;
+	        }
+	        _decorateResponse(response) {
+	            if (this._options.parseJson) {
+	                response.json = async () => this._options.parseJson(await response.text());
+	            }
+	            return response;
+	        }
+	        async _retry(fn) {
+	            try {
+	                return await fn();
+	                // eslint-disable-next-line @typescript-eslint/no-implicit-any-catch
+	            }
+	            catch (error) {
+	                const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+	                if (ms !== 0 && this._retryCount > 0) {
+	                    await delay(ms);
+	                    for (const hook of this._options.hooks.beforeRetry) {
+	                        // eslint-disable-next-line no-await-in-loop
+	                        const hookResult = await hook({
+	                            request: this.request,
+	                            options: this._options,
+	                            error: error,
+	                            retryCount: this._retryCount,
+	                        });
+	                        // If `stop` is returned from the hook, the retry process is stopped
+	                        if (hookResult === stop) {
+	                            return;
+	                        }
+	                    }
+	                    return this._retry(fn);
+	                }
+	                throw error;
+	            }
+	        }
+	        async _fetch() {
+	            for (const hook of this._options.hooks.beforeRequest) {
+	                // eslint-disable-next-line no-await-in-loop
+	                const result = await hook(this.request, this._options);
+	                if (result instanceof Request) {
+	                    this.request = result;
+	                    break;
+	                }
+	                if (result instanceof Response) {
+	                    return result;
+	                }
+	            }
+	            if (this._options.timeout === false) {
+	                return this._options.fetch(this.request.clone());
+	            }
+	            return timeout(this.request.clone(), this.abortController, this._options);
+	        }
+	        /* istanbul ignore next */
+	        _stream(response, onDownloadProgress) {
+	            const totalBytes = Number(response.headers.get('content-length')) || 0;
+	            let transferredBytes = 0;
+	            return new globalThis.Response(new globalThis.ReadableStream({
+	                async start(controller) {
+	                    const reader = response.body.getReader();
+	                    if (onDownloadProgress) {
+	                        onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());
+	                    }
+	                    async function read() {
+	                        const { done, value } = await reader.read();
+	                        if (done) {
+	                            controller.close();
+	                            return;
+	                        }
+	                        if (onDownloadProgress) {
+	                            transferredBytes += value.byteLength;
+	                            const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+	                            onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
+	                        }
+	                        controller.enqueue(value);
+	                        await read();
+	                    }
+	                    await read();
+	                },
+	            }));
+	        }
+	    }
 
-	})));
-	}(ky$1));
+	    /*! MIT License © Sindre Sorhus */
+	    const createInstance = (defaults) => {
+	        // eslint-disable-next-line @typescript-eslint/promise-function-async
+	        const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+	        for (const method of requestMethods) {
+	            // eslint-disable-next-line @typescript-eslint/promise-function-async
+	            ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
+	        }
+	        ky.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+	        ky.extend = (newDefaults) => createInstance(validateAndMerge(defaults, newDefaults));
+	        ky.stop = stop;
+	        return ky;
+	    };
+	    const ky = createInstance();
+
+	    exports.HTTPError = HTTPError;
+	    exports.TimeoutError = TimeoutError;
+	    exports["default"] = ky;
+
+	    Object.defineProperty(exports, '__esModule', { value: true });
+
+	}));
+	}(ky$1, ky$1.exports));
 
 	const isUrlHttp = lightweight;
 	const { flattie: flatten } = dist;
@@ -936,7 +838,7 @@
 	const whoops = lib.exports;
 
 	const factory = factory_1;
-	const ky = ky$1.exports;
+	const { default: ky } = ky$1.exports;
 
 	const MicrolinkError = whoops('MicrolinkError');
 
@@ -952,8 +854,11 @@
 	      const { response } = err;
 	      err.response = {
 	        ...response,
-	        headers: [...response.headers.entries()].reduce(
-	          (acc, [key, value]) => ({ ...acc, [key]: value }),
+	        headers: Array.from(response.headers.entries()).reduce(
+	          (acc, [key, value]) => {
+	            acc[key] = value;
+	            return acc
+	          },
 	          {}
 	        ),
 	        statusCode: response.status,
@@ -970,7 +875,7 @@
 	  stringify,
 	  got,
 	  flatten,
-	  VERSION: '0.10.11'
+	  VERSION: '0.10.15'
 	});
 
 	return browser;