@microlink/mql 0.10.39-5 → 0.11.0-0

package/dist/mql.js

@@ -4,12 +4,35 @@
 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.mql = factory());
 })(this, (function () { 'use strict';
 
-	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 	function getDefaultExportFromCjs (x) {
 		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 	}
 
+	function getAugmentedNamespace(n) {
+	  if (n.__esModule) return n;
+	  var f = n.default;
+		if (typeof f == "function") {
+			var a = function a () {
+				if (this instanceof a) {
+	        return Reflect.construct(f, arguments, this.constructor);
+				}
+				return f.apply(this, arguments);
+			};
+			a.prototype = f.prototype;
+	  } else a = {};
+	  Object.defineProperty(a, '__esModule', {value: true});
+		Object.keys(n).forEach(function (k) {
+			var d = Object.getOwnPropertyDescriptor(n, k);
+			Object.defineProperty(a, k, d.get ? d : {
+				enumerable: true,
+				get: function () {
+					return n[k];
+				}
+			});
+		});
+		return a;
+	}
+
 	const REGEX_HTTP_PROTOCOL = /^https?:\/\//i;
 
 	var lightweight$2 = url => {
@@ -56,7 +79,7 @@
 	  PRO: 'https://pro.microlink.io/'
 	};
 
-	const isObject = input => input !== null && typeof input === 'object';
+	const isObject$1 = input => input !== null && typeof input === 'object';
 
 	const isBuffer = input =>
 	  input != null &&
@@ -97,7 +120,7 @@
 	  };
 
 	  const mapRules = rules => {
-	    if (!isObject(rules)) return
+	    if (!isObject$1(rules)) return
 	    const flatRules = flatten(rules);
 	    return Object.keys(flatRules).reduce((acc, key) => {
 	      acc[`data.${key}`] = flatRules[key].toString();
@@ -122,7 +145,7 @@
 	      const isBodyBuffer = isBuffer(rawBody);
 
 	      const body =
-	        isObject(rawBody) && !isBodyBuffer
+	        isObject$1(rawBody) && !isBodyBuffer
 	          ? rawBody
 	          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, err, uri);
 
@@ -179,533 +202,525 @@
 
 	var factory_1 = factory$1;
 
-	var ky$1 = {exports: {}};
-
-	(function (module, exports) {
-		(function (global, factory) {
-		    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}`);
-		            Object.defineProperty(this, "response", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            Object.defineProperty(this, "request", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            Object.defineProperty(this, "options", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            this.name = 'HTTPError';
-		            this.response = response;
-		            this.request = request;
-		            this.options = options;
-		        }
-		    }
-
-		    class TimeoutError extends Error {
-		        constructor(request) {
-		            super('Request timed out');
-		            Object.defineProperty(this, "request", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            this.name = 'TimeoutError';
-		            this.request = request;
-		        }
-		    }
-
-		    // 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)) && 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 supportsRequestStreams = (() => {
-		        let duplexAccessed = false;
-		        let hasContentType = false;
-		        const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
-		        const supportsRequest = typeof globalThis.Request === 'function';
-		        if (supportsReadableStream && supportsRequest) {
-		            hasContentType = new globalThis.Request('https://empty.invalid', {
-		                body: new globalThis.ReadableStream(),
-		                method: 'POST',
-		                // @ts-expect-error - Types are outdated.
-		                get duplex() {
-		                    duplexAccessed = true;
-		                    return 'half';
-		                },
-		            }).headers.has('Content-Type');
-		        }
-		        return duplexAccessed && !hasContentType;
-		    })();
-		    const supportsAbortController = typeof globalThis.AbortController === 'function';
-		    const supportsResponseStreams = 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,
-		        backoffLimit: 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)
-		    async function timeout(request, abortController, options) {
-		        return new Promise((resolve, reject) => {
-		            const timeoutId = setTimeout(() => {
-		                if (abortController) {
-		                    abortController.abort();
-		                }
-		                reject(new TimeoutError(request));
-		            }, options.timeout);
-		            void options
-		                .fetch(request)
-		                .then(resolve)
-		                .catch(reject)
-		                .then(() => {
-		                clearTimeout(timeoutId);
-		            });
-		        });
-		    }
-
-		    // https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
-		    async function delay(ms, { signal }) {
-		        return new Promise((resolve, reject) => {
-		            if (signal) {
-		                signal.throwIfAborted();
-		                signal.addEventListener('abort', abortHandler, { once: true });
-		            }
-		            function abortHandler() {
-		                clearTimeout(timeoutId);
-		                reject(signal.reason);
-		            }
-		            const timeoutId = setTimeout(() => {
-		                signal?.removeEventListener('abort', abortHandler);
-		                resolve();
-		            }, ms);
-		        });
-		    }
-
-		    class Ky {
-		        static create(input, options) {
-		            const ky = new Ky(input, options);
-		            const fn = async () => {
-		                if (typeof ky._options.timeout === 'number' && 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) {
-		                    let error = new HTTPError(response, ky.request, ky._options);
-		                    for (const hook of ky._options.hooks.beforeError) {
-		                        // eslint-disable-next-line no-await-in-loop
-		                        error = await hook(error);
-		                    }
-		                    throw error;
-		                }
-		                // 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 (!supportsResponseStreams) {
-		                        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 awaitedResult = await result;
-		                    const response = awaitedResult.clone();
-		                    if (type === 'json') {
-		                        if (response.status === 204) {
-		                            return '';
-		                        }
-		                        const arrayBuffer = await response.clone().arrayBuffer();
-		                        const responseSize = arrayBuffer.byteLength;
-		                        if (responseSize === 0) {
-		                            return '';
-		                        }
-		                        if (options.parseJson) {
-		                            return options.parseJson(await response.text());
-		                        }
-		                    }
-		                    return response[type]();
-		                };
-		            }
-		            return result;
-		        }
-		        // eslint-disable-next-line complexity
-		        constructor(input, options = {}) {
-		            Object.defineProperty(this, "request", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            Object.defineProperty(this, "abortController", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            Object.defineProperty(this, "_retryCount", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: 0
-		            });
-		            Object.defineProperty(this, "_input", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 0
-		            });
-		            Object.defineProperty(this, "_options", {
-		                enumerable: true,
-		                configurable: true,
-		                writable: true,
-		                value: void 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: [],
-		                    beforeError: [],
-		                    afterResponse: [],
-		                }, options.hooks),
-		                method: normalizeRequestMethod(options.method ?? 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: options.timeout ?? 10000,
-		                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) {
-		                    const originalSignal = this._options.signal;
-		                    this._options.signal.addEventListener('abort', () => {
-		                        this.abortController.abort(originalSignal.reason);
-		                    });
-		                }
-		                this._options.signal = this.abortController.signal;
-		            }
-		            if (supportsRequestStreams) {
-		                // @ts-expect-error - Types are outdated.
-		                this._options.duplex = 'half';
-		            }
-		            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');
-		                }
-		                // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
-		                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', this._options.headers.get('content-type') ?? 'application/json');
-		                this.request = new globalThis.Request(this.request, { body: this._options.body });
-		            }
-		        }
-		        _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 (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 Math.min(this._options.retry.backoffLimit, 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();
-		            }
-		            catch (error) {
-		                const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-		                if (ms !== 0 && this._retryCount > 0) {
-		                    await delay(ms, { signal: this._options.signal });
-		                    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;
-		            if (response.status === 204) {
-		                if (onDownloadProgress) {
-		                    onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
-		                }
-		                return new globalThis.Response(null, {
-		                    status: response.status,
-		                    statusText: response.statusText,
-		                    headers: response.headers,
-		                });
-		            }
-		            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();
-		                },
-		            }), {
-		                status: response.status,
-		                statusText: response.statusText,
-		                headers: response.headers,
-		            });
-		        }
-		    }
-
-		    /*! 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));
-
-	var kyExports = ky$1.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}`);
+	        Object.defineProperty(this, "response", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        Object.defineProperty(this, "request", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        Object.defineProperty(this, "options", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        this.name = 'HTTPError';
+	        this.response = response;
+	        this.request = request;
+	        this.options = options;
+	    }
+	}
+
+	class TimeoutError extends Error {
+	    constructor(request) {
+	        super('Request timed out');
+	        Object.defineProperty(this, "request", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        this.name = 'TimeoutError';
+	        this.request = request;
+	    }
+	}
+
+	// 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)) && 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 supportsRequestStreams = (() => {
+	    let duplexAccessed = false;
+	    let hasContentType = false;
+	    const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
+	    const supportsRequest = typeof globalThis.Request === 'function';
+	    if (supportsReadableStream && supportsRequest) {
+	        hasContentType = new globalThis.Request('https://empty.invalid', {
+	            body: new globalThis.ReadableStream(),
+	            method: 'POST',
+	            // @ts-expect-error - Types are outdated.
+	            get duplex() {
+	                duplexAccessed = true;
+	                return 'half';
+	            },
+	        }).headers.has('Content-Type');
+	    }
+	    return duplexAccessed && !hasContentType;
+	})();
+	const supportsAbortController = typeof globalThis.AbortController === 'function';
+	const supportsResponseStreams = 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,
+	    backoffLimit: 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)
+	async function timeout(request, abortController, options) {
+	    return new Promise((resolve, reject) => {
+	        const timeoutId = setTimeout(() => {
+	            if (abortController) {
+	                abortController.abort();
+	            }
+	            reject(new TimeoutError(request));
+	        }, options.timeout);
+	        void options
+	            .fetch(request)
+	            .then(resolve)
+	            .catch(reject)
+	            .then(() => {
+	            clearTimeout(timeoutId);
+	        });
+	    });
+	}
+
+	// https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
+	async function delay(ms, { signal }) {
+	    return new Promise((resolve, reject) => {
+	        if (signal) {
+	            signal.throwIfAborted();
+	            signal.addEventListener('abort', abortHandler, { once: true });
+	        }
+	        function abortHandler() {
+	            clearTimeout(timeoutId);
+	            reject(signal.reason);
+	        }
+	        const timeoutId = setTimeout(() => {
+	            signal?.removeEventListener('abort', abortHandler);
+	            resolve();
+	        }, ms);
+	    });
+	}
+
+	class Ky {
+	    static create(input, options) {
+	        const ky = new Ky(input, options);
+	        const fn = async () => {
+	            if (typeof ky._options.timeout === 'number' && 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) {
+	                let error = new HTTPError(response, ky.request, ky._options);
+	                for (const hook of ky._options.hooks.beforeError) {
+	                    // eslint-disable-next-line no-await-in-loop
+	                    error = await hook(error);
+	                }
+	                throw error;
+	            }
+	            // 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 (!supportsResponseStreams) {
+	                    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 awaitedResult = await result;
+	                const response = awaitedResult.clone();
+	                if (type === 'json') {
+	                    if (response.status === 204) {
+	                        return '';
+	                    }
+	                    const arrayBuffer = await response.clone().arrayBuffer();
+	                    const responseSize = arrayBuffer.byteLength;
+	                    if (responseSize === 0) {
+	                        return '';
+	                    }
+	                    if (options.parseJson) {
+	                        return options.parseJson(await response.text());
+	                    }
+	                }
+	                return response[type]();
+	            };
+	        }
+	        return result;
+	    }
+	    // eslint-disable-next-line complexity
+	    constructor(input, options = {}) {
+	        Object.defineProperty(this, "request", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        Object.defineProperty(this, "abortController", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        Object.defineProperty(this, "_retryCount", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: 0
+	        });
+	        Object.defineProperty(this, "_input", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 0
+	        });
+	        Object.defineProperty(this, "_options", {
+	            enumerable: true,
+	            configurable: true,
+	            writable: true,
+	            value: void 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: [],
+	                beforeError: [],
+	                afterResponse: [],
+	            }, options.hooks),
+	            method: normalizeRequestMethod(options.method ?? 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: options.timeout ?? 10000,
+	            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) {
+	                const originalSignal = this._options.signal;
+	                this._options.signal.addEventListener('abort', () => {
+	                    this.abortController.abort(originalSignal.reason);
+	                });
+	            }
+	            this._options.signal = this.abortController.signal;
+	        }
+	        if (supportsRequestStreams) {
+	            // @ts-expect-error - Types are outdated.
+	            this._options.duplex = 'half';
+	        }
+	        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');
+	            }
+	            // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
+	            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', this._options.headers.get('content-type') ?? 'application/json');
+	            this.request = new globalThis.Request(this.request, { body: this._options.body });
+	        }
+	    }
+	    _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 (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 Math.min(this._options.retry.backoffLimit, 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();
+	        }
+	        catch (error) {
+	            const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+	            if (ms !== 0 && this._retryCount > 0) {
+	                await delay(ms, { signal: this._options.signal });
+	                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;
+	        if (response.status === 204) {
+	            if (onDownloadProgress) {
+	                onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+	            }
+	            return new globalThis.Response(null, {
+	                status: response.status,
+	                statusText: response.statusText,
+	                headers: response.headers,
+	            });
+	        }
+	        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();
+	            },
+	        }), {
+	            status: response.status,
+	            statusText: response.statusText,
+	            headers: response.headers,
+	        });
+	    }
+	}
+
+	/*! 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$1 = createInstance();
+
+	var distribution = /*#__PURE__*/Object.freeze({
+		__proto__: null,
+		HTTPError: HTTPError,
+		TimeoutError: TimeoutError,
+		default: ky$1
+	});
+
+	var require$$3 = /*@__PURE__*/getAugmentedNamespace(distribution);
 
 	const urlHttp = lightweight$2;
 	const { flattie: flatten } = dist;
 
 	const factory = factory_1;
-	const { default: ky } = kyExports;
+	const { default: ky } = require$$3;
 
 	class MicrolinkError extends Error {
 	  constructor (props) {
@@ -752,7 +767,7 @@
 	  urlHttp,
 	  got,
 	  flatten,
-	  VERSION: '0.10.39-4'
+	  VERSION: '0.10.39'
 	});
 
 	var lightweight$1 = /*@__PURE__*/getDefaultExportFromCjs(lightweight);
@@ -760,4 +775,3 @@
 	return lightweight$1;
 
 }));
-//# sourceMappingURL=mql.js.map