@microlink/mql 0.13.5 → 0.13.7

package/lightweight/index.js

@@ -27,75 +27,55 @@ function getAugmentedNamespace(n) {
 	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;
@@ -104,25 +84,20 @@ class HTTPError extends Error {
 }
 
 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');
         }
     }
@@ -142,10 +117,22 @@ const mergeHeaders = (source1 = {}, source2 = {}) => {
     }
     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)) {
@@ -153,14 +140,18 @@ const deepMerge = (...sources) => {
             }
             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;
             }
@@ -175,15 +166,24 @@ const supportsRequestStreams = (() => {
     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;
 })();
@@ -199,11 +199,12 @@ const responseTypes = {
     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,
@@ -229,6 +230,7 @@ const requestOptionsRegistry = {
     window: true,
     dispatcher: true,
     duplex: true,
+    priority: true,
 };
 
 const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
@@ -260,7 +262,6 @@ const normalizeRetryOptions = (retry = {}) => {
     return {
         ...defaultRetryOptions,
         ...retry,
-        afterStatusCodes: retryAfterStatusCodes,
     };
 };
 
@@ -376,45 +377,18 @@ class Ky {
         }
         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: [],
@@ -425,7 +399,7 @@ class Ky {
             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)) {
@@ -442,18 +416,20 @@ class Ky {
         }
         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
@@ -471,41 +447,38 @@ class Ky {
             // 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) {
@@ -519,24 +492,24 @@ class Ky {
         }
         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() {
@@ -552,10 +525,13 @@ class Ky {
             }
         }
         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) {
@@ -610,224 +586,250 @@ const createInstance = (defaults) => {
         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);
 
-export { MicrolinkError_1 as MicrolinkError, arrayBuffer, lightweight as default, extend, fetchFromApi, getApiUrl, mapRules, version };
+export { lightweight as default };