@microlink/mql 0.13.5 → 0.13.7

package/lightweight/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-	typeof define === 'function' && define.amd ? define(['exports'], factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.mql = {}));
-})(this, (function (exports) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.mql = factory());
+})(this, (function () { 'use strict';
 
 	function getDefaultExportFromCjs (x) {
 		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -33,75 +33,55 @@
 		return a;
 	}
 
-	var lightweight$2 = {exports: {}};
-
-	const REGEX_HTTP_PROTOCOL = /^https?:\/\//i;
-
-	var lightweight$1 = url => {
-	  try {
-	    const { href } = new URL(url);
-	    return REGEX_HTTP_PROTOCOL.test(href) && href
-	  } catch (err) {
-	    return false
-	  }
-	};
+	var lightweight$1 = {exports: {}};
 
 	var dist = {};
 
-	function iter(output, nullish, sep, val, key) {
-		var k, pfx = key ? (key + sep) : key;
-
-		if (val == null) {
-			if (nullish) output[key] = val;
-		} else if (typeof val != 'object') {
-			output[key] = val;
-		} else if (Array.isArray(val)) {
-			for (k=0; k < val.length; k++) {
-				iter(output, nullish, sep, val[k], pfx + k);
-			}
-		} else {
-			for (k in val) {
-				iter(output, nullish, sep, val[k], pfx + k);
+	var hasRequiredDist;
+
+	function requireDist () {
+		if (hasRequiredDist) return dist;
+		hasRequiredDist = 1;
+		function iter(output, nullish, sep, val, key) {
+			var k, pfx = key ? (key + sep) : key;
+
+			if (val == null) {
+				if (nullish) output[key] = val;
+			} else if (typeof val != 'object') {
+				output[key] = val;
+			} else if (Array.isArray(val)) {
+				for (k=0; k < val.length; k++) {
+					iter(output, nullish, sep, val[k], pfx + k);
+				}
+			} else {
+				for (k in val) {
+					iter(output, nullish, sep, val[k], pfx + k);
+				}
 			}
 		}
-	}
 
-	function flattie(input, glue, toNull) {
-		var output = {};
-		if (typeof input == 'object') {
-			iter(output, !!toNull, glue || '.', input, '');
+		function flattie(input, glue, toNull) {
+			var output = {};
+			if (typeof input == 'object') {
+				iter(output, !!toNull, glue || '.', input, '');
+			}
+			return output;
 		}
-		return output;
-	}
 
-	dist.flattie = flattie;
+		dist.flattie = flattie;
+		return dist;
+	}
 
-	// eslint-lint-disable-next-line @typescript-eslint/naming-convention
 	class HTTPError extends Error {
+	    response;
+	    request;
+	    options;
 	    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
-	        });
+	        super(`Request failed with ${reason}: ${request.method} ${request.url}`);
 	        this.name = 'HTTPError';
 	        this.response = response;
 	        this.request = request;
@@ -110,25 +90,20 @@
 	}
 
 	class TimeoutError extends Error {
+	    request;
 	    constructor(request) {
-	        super('Request timed out');
-	        Object.defineProperty(this, "request", {
-	            enumerable: true,
-	            configurable: true,
-	            writable: true,
-	            value: void 0
-	        });
+	        super(`Request timed out: ${request.method} ${request.url}`);
 	        this.name = 'TimeoutError';
 	        this.request = request;
 	    }
 	}
 
 	// eslint-disable-next-line @typescript-eslint/ban-types
-	const isObject$1 = (value) => value !== null && typeof value === 'object';
+	const isObject = (value) => value !== null && typeof value === 'object';
 
 	const validateAndMerge = (...sources) => {
 	    for (const source of sources) {
-	        if ((!isObject$1(source) || Array.isArray(source)) && source !== undefined) {
+	        if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
 	            throw new TypeError('The `options` argument must be an object');
 	        }
 	    }
@@ -148,10 +123,22 @@
 	    }
 	    return result;
 	};
+	function newHookValue(original, incoming, property) {
+	    return (Object.hasOwn(incoming, property) && incoming[property] === undefined)
+	        ? []
+	        : deepMerge(original[property] ?? [], incoming[property] ?? []);
+	}
+	const mergeHooks = (original = {}, incoming = {}) => ({
+	    beforeRequest: newHookValue(original, incoming, 'beforeRequest'),
+	    beforeRetry: newHookValue(original, incoming, 'beforeRetry'),
+	    afterResponse: newHookValue(original, incoming, 'afterResponse'),
+	    beforeError: newHookValue(original, incoming, 'beforeError'),
+	});
 	// TODO: Make this strongly-typed (no `any`).
 	const deepMerge = (...sources) => {
 	    let returnValue = {};
 	    let headers = {};
+	    let hooks = {};
 	    for (const source of sources) {
 	        if (Array.isArray(source)) {
 	            if (!Array.isArray(returnValue)) {
@@ -159,14 +146,18 @@
 	            }
 	            returnValue = [...returnValue, ...source];
 	        }
-	        else if (isObject$1(source)) {
+	        else if (isObject(source)) {
 	            for (let [key, value] of Object.entries(source)) {
-	                if (isObject$1(value) && key in returnValue) {
+	                if (isObject(value) && key in returnValue) {
 	                    value = deepMerge(returnValue[key], value);
 	                }
 	                returnValue = { ...returnValue, [key]: value };
 	            }
-	            if (isObject$1(source.headers)) {
+	            if (isObject(source.hooks)) {
+	                hooks = mergeHooks(hooks, source.hooks);
+	                returnValue.hooks = hooks;
+	            }
+	            if (isObject(source.headers)) {
 	                headers = mergeHeaders(headers, source.headers);
 	                returnValue.headers = headers;
 	            }
@@ -181,15 +172,24 @@
 	    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');
+	        try {
+	            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');
+	        }
+	        catch (error) {
+	            // QQBrowser on iOS throws "unsupported BodyInit type" error (see issue #581)
+	            if (error instanceof Error && error.message === 'unsupported BodyInit type') {
+	                return false;
+	            }
+	            throw error;
+	        }
 	    }
 	    return duplexAccessed && !hasContentType;
 	})();
@@ -205,11 +205,12 @@
 	    blob: '*/*',
 	};
 	// The maximum value of a 32bit int (see issue #117)
-	const maxSafeTimeout = 2147483647;
+	const maxSafeTimeout = 2_147_483_647;
 	const stop = Symbol('stop');
 	const kyOptionKeys = {
 	    json: true,
 	    parseJson: true,
+	    stringifyJson: true,
 	    searchParams: true,
 	    prefixUrl: true,
 	    retry: true,
@@ -235,6 +236,7 @@
 	    window: true,
 	    dispatcher: true,
 	    duplex: true,
+	    priority: true,
 	};
 
 	const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
@@ -266,7 +268,6 @@
 	    return {
 	        ...defaultRetryOptions,
 	        ...retry,
-	        afterStatusCodes: retryAfterStatusCodes,
 	    };
 	};
 
@@ -382,45 +383,18 @@
 	        }
 	        return result;
 	    }
+	    request;
+	    abortController;
+	    _retryCount = 0;
+	    _input;
+	    _options;
 	    // 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;
-	        const isCredentialsSupported = 'credentials' in Request.prototype;
 	        this._options = {
-	            credentials: isCredentialsSupported ? this._input.credentials : undefined,
 	            ...options,
 	            headers: mergeHeaders(this._input.headers, options.headers),
-	            hooks: deepMerge({
+	            hooks: mergeHooks({
 	                beforeRequest: [],
 	                beforeRetry: [],
 	                beforeError: [],
@@ -431,7 +405,7 @@
 	            prefixUrl: String(options.prefixUrl || ''),
 	            retry: normalizeRetryOptions(options.retry),
 	            throwHttpErrors: options.throwHttpErrors !== false,
-	            timeout: options.timeout ?? 10000,
+	            timeout: options.timeout ?? 10_000,
 	            fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
 	        };
 	        if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
@@ -448,18 +422,20 @@
 	        }
 	        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);
-	                });
-	            }
+	            const originalSignal = this._options.signal ?? this._input.signal;
+	            originalSignal?.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';
 	        }
+	        if (this._options.json !== undefined) {
+	            this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
+	            this._options.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
+	        }
 	        this.request = new globalThis.Request(this._input, this._options);
 	        if (this._options.searchParams) {
 	            // eslint-disable-next-line unicorn/prevent-abbreviations
@@ -477,41 +453,38 @@
 	            // 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 (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+	            throw error;
+	        }
+	        if (error instanceof HTTPError) {
+	            if (!this._options.retry.statusCodes.includes(error.response.status)) {
+	                throw error;
+	            }
+	            const retryAfter = error.response.headers.get('Retry-After')
+	                ?? error.response.headers.get('RateLimit-Reset')
+	                ?? error.response.headers.get('X-RateLimit-Reset') // GitHub
+	                ?? error.response.headers.get('X-Rate-Limit-Reset'); // Twitter
+	            if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+	                let after = Number(retryAfter) * 1000;
+	                if (Number.isNaN(after)) {
+	                    after = Date.parse(retryAfter) - Date.now();
 	                }
-	                if (error.response.status === 413) {
-	                    return 0;
+	                else if (after >= Date.parse('2024-01-01')) {
+	                    // A large number is treated as a timestamp (fixed threshold protects against clock skew)
+	                    after -= Date.now();
 	                }
+	                const max = this._options.retry.maxRetryAfter ?? after;
+	                return after < max ? after : max;
+	            }
+	            if (error.response.status === 413) {
+	                throw error;
 	            }
-	            const retryDelay = this._options.retry.delay(this._retryCount);
-	            return Math.min(this._options.retry.backoffLimit, retryDelay);
 	        }
-	        return 0;
+	        const retryDelay = this._options.retry.delay(this._retryCount);
+	        return Math.min(this._options.retry.backoffLimit, retryDelay);
 	    }
 	    _decorateResponse(response) {
 	        if (this._options.parseJson) {
@@ -525,24 +498,24 @@
 	        }
 	        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;
-	                    }
+	            if (this._retryCount < 1) {
+	                throw error;
+	            }
+	            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(function_);
 	            }
-	            throw error;
+	            return this._retry(function_);
 	        }
 	    }
 	    async _fetch() {
@@ -558,10 +531,13 @@
 	            }
 	        }
 	        const nonRequestOptions = findUnknownOptions(this.request, this._options);
+	        // Cloning is done here to prepare in advance for retries
+	        const mainRequest = this.request;
+	        this.request = mainRequest.clone();
 	        if (this._options.timeout === false) {
-	            return this._options.fetch(this.request.clone(), nonRequestOptions);
+	            return this._options.fetch(mainRequest, nonRequestOptions);
 	        }
-	        return timeout(this.request.clone(), nonRequestOptions, this.abortController, this._options);
+	        return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
 	    }
 	    /* istanbul ignore next */
 	    _stream(response, onDownloadProgress) {
@@ -616,235 +592,252 @@
 	        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.extend = (newDefaults) => {
+	        if (typeof newDefaults === 'function') {
+	            newDefaults = newDefaults(defaults ?? {});
+	        }
+	        return createInstance(validateAndMerge(defaults, newDefaults));
+	    };
 	    ky.stop = stop;
 	    return ky;
 	};
-	const ky$1 = createInstance();
+	const ky = createInstance();
 
 	var distribution = /*#__PURE__*/Object.freeze({
 		__proto__: null,
 		HTTPError: HTTPError,
 		TimeoutError: TimeoutError,
-		default: ky$1
+		default: ky
 	});
 
-	var require$$2 = /*@__PURE__*/getAugmentedNamespace(distribution);
-
-	const ENDPOINT = {
-	  FREE: 'https://api.microlink.io/',
-	  PRO: 'https://pro.microlink.io/'
-	};
-
-	const isObject = input => input !== null && typeof input === 'object';
-
-	const isBuffer = input =>
-	  input != null &&
-	  input.constructor != null &&
-	  typeof input.constructor.isBuffer === 'function' &&
-	  input.constructor.isBuffer(input);
+	var require$$1 = /*@__PURE__*/getAugmentedNamespace(distribution);
+
+	var factory_1;
+	var hasRequiredFactory;
+
+	function requireFactory () {
+		if (hasRequiredFactory) return factory_1;
+		hasRequiredFactory = 1;
+		const ENDPOINT = {
+		  FREE: 'https://api.microlink.io/',
+		  PRO: 'https://pro.microlink.io/'
+		};
+
+		const isObject = input => input !== null && typeof input === 'object';
+
+		const isBuffer = input =>
+		  input != null &&
+		  input.constructor != null &&
+		  typeof input.constructor.isBuffer === 'function' &&
+		  input.constructor.isBuffer(input);
+
+		const parseBody = (input, error, url) => {
+		  try {
+		    return JSON.parse(input)
+		  } catch (_) {
+		    const message = input || error.message;
+
+		    return {
+		      status: 'error',
+		      data: { url: message },
+		      more: 'https://microlink.io/efatalclient',
+		      code: 'EFATALCLIENT',
+		      message,
+		      url
+		    }
+		  }
+		};
+
+		const isURL = url => {
+		  try {
+		    return /^https?:\/\//i.test(new URL(url).href)
+		  } catch (_) {
+		    return false
+		  }
+		};
+
+		const factory = streamResponseType => ({
+		  VERSION,
+		  MicrolinkError,
+		  got,
+		  flatten
+		}) => {
+		  const assertUrl = (url = '') => {
+		    if (!isURL(url)) {
+		      const message = `The \`url\` as \`${url}\` is not valid. Ensure it has protocol (http or https) and hostname.`;
+		      throw new MicrolinkError({
+		        status: 'fail',
+		        data: { url: message },
+		        more: 'https://microlink.io/einvalurlclient',
+		        code: 'EINVALURLCLIENT',
+		        message,
+		        url
+		      })
+		    }
+		  };
+
+		  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 acc
+		    }, {})
+		  };
+
+		  const fetchFromApi = async (apiUrl, opts = {}) => {
+		    try {
+		      const response = await got(apiUrl, opts);
+		      return opts.responseType === streamResponseType
+		        ? response
+		        : { ...response.body, response }
+		    } catch (error) {
+		      const { response = {} } = error;
+		      const {
+		        statusCode,
+		        body: rawBody,
+		        headers = {},
+		        url: uri = apiUrl
+		      } = response;
+		      const isBodyBuffer = isBuffer(rawBody);
+
+		      const body =
+		        isObject(rawBody) && !isBodyBuffer
+		          ? rawBody
+		          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, error, uri);
+
+		      throw new MicrolinkError({
+		        ...body,
+		        message: body.message,
+		        url: uri,
+		        statusCode,
+		        headers
+		      })
+		    }
+		  };
+
+		  const getApiUrl = (
+		    url,
+		    { data, apiKey, endpoint, retry, cache, ...opts } = {},
+		    { responseType = 'json', headers: gotHeaders, ...gotOpts } = {}
+		  ) => {
+		    const isPro = !!apiKey;
+		    const apiEndpoint = endpoint || ENDPOINT[isPro ? 'PRO' : 'FREE'];
+
+		    const apiUrl = `${apiEndpoint}?${new URLSearchParams({
+	      url,
+	      ...mapRules(data),
+	      ...flatten(opts)
+	    }).toString()}`;
+
+		    const headers = isPro
+		      ? { ...gotHeaders, 'x-api-key': apiKey }
+		      : { ...gotHeaders };
+
+		    if (opts.stream) {
+		      responseType = streamResponseType;
+		    }
+		    return [apiUrl, { ...gotOpts, responseType, cache, retry, headers }]
+		  };
+
+		  const createMql = defaultOpts => async (url, opts, gotOpts) => {
+		    assertUrl(url);
+		    const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
+		      ...defaultOpts,
+		      ...gotOpts
+		    });
+		    return fetchFromApi(apiUrl, fetchOpts)
+		  };
+
+		  const mql = createMql();
+		  mql.extend = createMql;
+		  mql.MicrolinkError = MicrolinkError;
+		  mql.getApiUrl = getApiUrl;
+		  mql.fetchFromApi = fetchFromApi;
+		  mql.mapRules = mapRules;
+		  mql.version = VERSION;
+		  mql.stream = got.stream;
+
+		  return mql
+		};
+
+		factory_1 = factory;
+		return factory_1;
+	}
 
-	const parseBody = (input, error, url) => {
-	  try {
-	    return JSON.parse(input)
-	  } catch (_) {
-	    const message = input || error.message;
+	var hasRequiredLightweight;
 
-	    return {
-	      status: 'error',
-	      data: { url: message },
-	      more: 'https://microlink.io/efatalclient',
-	      code: 'EFATALCLIENT',
-	      message,
-	      url
-	    }
-	  }
-	};
+	function requireLightweight () {
+		if (hasRequiredLightweight) return lightweight$1.exports;
+		hasRequiredLightweight = 1;
 
-	const factory$1 = streamResponseType => ({
-	  VERSION,
-	  MicrolinkError,
-	  urlHttp,
-	  got,
-	  flatten
-	}) => {
-	  const assertUrl = (url = '') => {
-	    if (!urlHttp(url)) {
-	      const message = `The \`url\` as \`${url}\` is not valid. Ensure it has protocol (http or https) and hostname.`;
-	      throw new MicrolinkError({
-	        status: 'fail',
-	        data: { url: message },
-	        more: 'https://microlink.io/einvalurlclient',
-	        code: 'EINVALURLCLIENT',
-	        message,
-	        url
-	      })
-	    }
-	  };
-
-	  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 acc
-	    }, {})
-	  };
-
-	  const fetchFromApi = async (apiUrl, opts = {}) => {
-	    try {
-	      const response = await got(apiUrl, opts);
-	      return opts.responseType === streamResponseType
-	        ? response
-	        : { ...response.body, response }
-	    } catch (error) {
-	      const { response = {} } = error;
-	      const {
-	        statusCode,
-	        body: rawBody,
-	        headers = {},
-	        url: uri = apiUrl
-	      } = response;
-	      const isBodyBuffer = isBuffer(rawBody);
-
-	      const body =
-	        isObject(rawBody) && !isBodyBuffer
-	          ? rawBody
-	          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, error, uri);
-
-	      throw new MicrolinkError({
-	        ...body,
-	        message: body.message,
-	        url: uri,
-	        statusCode,
-	        headers
-	      })
-	    }
-	  };
-
-	  const getApiUrl = (
-	    url,
-	    { data, apiKey, endpoint, retry, cache, ...opts } = {},
-	    { responseType = 'json', headers: gotHeaders, ...gotOpts } = {}
-	  ) => {
-	    const isPro = !!apiKey;
-	    const apiEndpoint = endpoint || ENDPOINT[isPro ? 'PRO' : 'FREE'];
-
-	    const apiUrl = `${apiEndpoint}?${new URLSearchParams({
-      url,
-      ...mapRules(data),
-      ...flatten(opts)
-    }).toString()}`;
-
-	    const headers = isPro
-	      ? { ...gotHeaders, 'x-api-key': apiKey }
-	      : { ...gotHeaders };
-
-	    if (opts.stream) {
-	      responseType = streamResponseType;
-	    }
-	    return [apiUrl, { ...gotOpts, responseType, cache, retry, headers }]
-	  };
-
-	  const createMql = defaultOpts => async (url, opts, gotOpts) => {
-	    assertUrl(url);
-	    const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
-	      ...defaultOpts,
-	      ...gotOpts
-	    });
-	    return fetchFromApi(apiUrl, fetchOpts)
-	  };
-
-	  const mql = createMql();
-	  mql.extend = createMql;
-	  mql.MicrolinkError = MicrolinkError;
-	  mql.getApiUrl = getApiUrl;
-	  mql.fetchFromApi = fetchFromApi;
-	  mql.mapRules = mapRules;
-	  mql.version = VERSION;
-	  mql.stream = got.stream;
-
-	  return mql
-	};
+		const { flattie: flatten } = requireDist();
+		const { default: ky } = require$$1;
 
-	var factory_1 = factory$1;
+		const factory = requireFactory()('arrayBuffer');
 
-	const urlHttp = lightweight$1;
-	const { flattie: flatten } = dist;
-	const { default: ky } = require$$2;
+		class MicrolinkError extends Error {
+		  constructor (props) {
+		    super();
+		    this.name = 'MicrolinkError';
+		    Object.assign(this, props);
+		    this.description = this.message;
+		    this.message = this.code
+		      ? `${this.code}, ${this.description}`
+		      : this.description;
+		  }
+		}
 
-	const factory = factory_1('arrayBuffer');
+		const got = async (url, { responseType, ...opts }) => {
+		  try {
+		    if (opts.timeout === undefined) opts.timeout = false;
+		    const response = await ky(url, opts);
+		    const body = await response[responseType]();
+		    const { headers, status: statusCode } = response;
+		    return { url: response.url, body, headers, statusCode }
+		  } catch (error) {
+		    if (error.response) {
+		      const { response } = error;
+		      error.response = {
+		        ...response,
+		        headers: Array.from(response.headers.entries()).reduce(
+		          (acc, [key, value]) => {
+		            acc[key] = value;
+		            return acc
+		          },
+		          {}
+		        ),
+		        statusCode: response.status,
+		        body: await response.text()
+		      };
+		    }
+		    throw error
+		  }
+		};
+
+		got.stream = (...args) => ky(...args).then(res => res.body);
+
+		const mql = factory({
+		  MicrolinkError,
+		  got,
+		  flatten,
+		  VERSION: '0.13.7'
+		});
 
-	class MicrolinkError extends Error {
-	  constructor (props) {
-	    super();
-	    this.name = 'MicrolinkError';
-	    Object.assign(this, props);
-	    this.description = this.message;
-	    this.message = this.code
-	      ? `${this.code}, ${this.description}`
-	      : this.description;
-	  }
+		lightweight$1.exports = mql;
+		lightweight$1.exports.arrayBuffer = mql.extend({ responseType: 'arrayBuffer' });
+		lightweight$1.exports.extend = mql.extend;
+		lightweight$1.exports.fetchFromApi = mql.fetchFromApi;
+		lightweight$1.exports.getApiUrl = mql.getApiUrl;
+		lightweight$1.exports.mapRules = mql.mapRules;
+		lightweight$1.exports.MicrolinkError = mql.MicrolinkError;
+		lightweight$1.exports.version = mql.version;
+		return lightweight$1.exports;
 	}
 
-	const got = async (url, { responseType, ...opts }) => {
-	  try {
-	    if (opts.timeout === undefined) opts.timeout = false;
-	    const response = await ky(url, opts);
-	    const body = await response[responseType]();
-	    const { headers, status: statusCode } = response;
-	    return { url: response.url, body, headers, statusCode }
-	  } catch (error) {
-	    if (error.response) {
-	      const { response } = error;
-	      error.response = {
-	        ...response,
-	        headers: Array.from(response.headers.entries()).reduce(
-	          (acc, [key, value]) => {
-	            acc[key] = value;
-	            return acc
-	          },
-	          {}
-	        ),
-	        statusCode: response.status,
-	        body: await response.text()
-	      };
-	    }
-	    throw error
-	  }
-	};
-
-	got.stream = (...args) => ky(...args).then(res => res.body);
-
-	const mql = factory({
-	  MicrolinkError,
-	  urlHttp,
-	  got,
-	  flatten,
-	  VERSION: '0.13.5'
-	});
-
-	lightweight$2.exports = mql;
-	var arrayBuffer = lightweight$2.exports.arrayBuffer = mql.extend({ responseType: 'arrayBuffer' });
-	var extend = lightweight$2.exports.extend = mql.extend;
-	var fetchFromApi = lightweight$2.exports.fetchFromApi = mql.fetchFromApi;
-	var getApiUrl = lightweight$2.exports.getApiUrl = mql.getApiUrl;
-	var mapRules = lightweight$2.exports.mapRules = mql.mapRules;
-	var MicrolinkError_1 = lightweight$2.exports.MicrolinkError = mql.MicrolinkError;
-	var version = lightweight$2.exports.version = mql.version;
-
-	var lightweightExports = lightweight$2.exports;
+	var lightweightExports = requireLightweight();
 	var lightweight = /*@__PURE__*/getDefaultExportFromCjs(lightweightExports);
 
-	exports.MicrolinkError = MicrolinkError_1;
-	exports.arrayBuffer = arrayBuffer;
-	exports.default = lightweight;
-	exports.extend = extend;
-	exports.fetchFromApi = fetchFromApi;
-	exports.getApiUrl = getApiUrl;
-	exports.mapRules = mapRules;
-	exports.version = version;
-
-	Object.defineProperty(exports, '__esModule', { value: true });
+	return lightweight;
 
 }));