@microlink/function 0.1.1 → 0.1.2

package/dist/microlink-function.js

@@ -177,945 +177,945 @@
 
   var require$$2 = /*@__PURE__*/ getAugmentedNamespace(qss_m)
 
-  var ky$1 = { exports: {} }
-
-  ;(function (module, exports) {
-    ;(function (global, factory) {
-      module.exports = factory()
-    })(commonjsGlobal, function () {
-      /*! MIT License © Sindre Sorhus */
+  var lib = { exports: {} }
 
-      const isObject = value => value !== null && typeof value === 'object'
-      const supportsAbortController =
-        typeof globalThis.AbortController === 'function'
-      const supportsStreams = typeof globalThis.ReadableStream === 'function'
-      const supportsFormData = typeof globalThis.FormData === 'function'
+  var _nodeResolve_empty = {}
 
-      const mergeHeaders = (source1, source2) => {
-        const result = new globalThis.Headers(source1 || {})
-        const isHeadersInstance = source2 instanceof globalThis.Headers
-        const source = new globalThis.Headers(source2 || {})
+  var _nodeResolve_empty$1 = /*#__PURE__*/ Object.freeze({
+    __proto__: null,
+    default: _nodeResolve_empty
+  })
 
-        for (const [key, value] of source) {
-          if (
-            (isHeadersInstance && value === 'undefined') ||
-            value === undefined
-          ) {
-            result.delete(key)
-          } else {
-            result.set(key, value)
-          }
-        }
+  var require$$0 = /*@__PURE__*/ getAugmentedNamespace(_nodeResolve_empty$1)
 
-        return result
-      }
+  const os = require$$0
 
-      const deepMerge = (...sources) => {
-        let returnValue = {}
-        let headers = {}
+  const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/
+  const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/
+  const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir()
 
-        for (const source of sources) {
-          if (Array.isArray(source)) {
-            if (!Array.isArray(returnValue)) {
-              returnValue = []
-            }
+  var cleanStack$1 = (stack, options) => {
+    options = Object.assign({ pretty: false }, options)
 
-            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)
-              }
+    return stack
+      .replace(/\\/g, '/')
+      .split('\n')
+      .filter(line => {
+        const pathMatches = line.match(extractPathRegex)
+        if (pathMatches === null || !pathMatches[1]) {
+          return true
+        }
 
-              returnValue = { ...returnValue, [key]: value }
-            }
+        const match = pathMatches[1]
 
-            if (isObject(source.headers)) {
-              headers = mergeHeaders(headers, source.headers)
-            }
-          }
+        // Electron
+        if (
+          match.includes('.app/Contents/Resources/electron.asar') ||
+          match.includes('.app/Contents/Resources/default_app.asar')
+        ) {
+          return false
+        }
 
-          returnValue.headers = headers
+        return !pathRegex.test(match)
+      })
+      .filter(line => line.trim() !== '')
+      .map(line => {
+        if (options.pretty) {
+          return line.replace(extractPathRegex, (m, p1) =>
+            m.replace(p1, p1.replace(homeDir, '~'))
+          )
         }
 
-        return returnValue
-      }
+        return line
+      })
+      .join('\n')
+  }
 
-      const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete']
+  const copyProperty = (to, from, property, ignoreNonConfigurable) => {
+    // `Function#length` should reflect the parameters of `to` not `from` since we keep its body.
+    // `Function#prototype` is non-writable and non-configurable so can never be modified.
+    if (property === 'length' || property === 'prototype') {
+      return
+    }
 
-      const responseTypes = {
-        json: 'application/json',
-        text: 'text/*',
-        formData: 'multipart/form-data',
-        arrayBuffer: '*/*',
-        blob: '*/*'
-      }
+    const toDescriptor = Object.getOwnPropertyDescriptor(to, property)
+    const fromDescriptor = Object.getOwnPropertyDescriptor(from, property)
 
-      const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace']
+    if (
+      !canCopyProperty(toDescriptor, fromDescriptor) &&
+      ignoreNonConfigurable
+    ) {
+      return
+    }
 
-      const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504]
+    Object.defineProperty(to, property, fromDescriptor)
+  }
 
-      const retryAfterStatusCodes = [413, 429, 503]
+  // `Object.defineProperty()` throws if the property exists, is not configurable and either:
+  //  - one its descriptors is changed
+  //  - it is non-writable and its value is changed
+  const canCopyProperty = function (toDescriptor, fromDescriptor) {
+    return (
+      toDescriptor === undefined ||
+      toDescriptor.configurable ||
+      (toDescriptor.writable === fromDescriptor.writable &&
+        toDescriptor.enumerable === fromDescriptor.enumerable &&
+        toDescriptor.configurable === fromDescriptor.configurable &&
+        (toDescriptor.writable || toDescriptor.value === fromDescriptor.value))
+    )
+  }
 
-      const stop = Symbol('stop')
+  const changePrototype = (to, from) => {
+    const fromPrototype = Object.getPrototypeOf(from)
+    if (fromPrototype === Object.getPrototypeOf(to)) {
+      return
+    }
 
-      class HTTPError extends Error {
-        constructor (response, request, options) {
-          // Set the message to the status text, such as Unauthorized,
-          // with some fallbacks. This message should never be undefined.
-          super(
-            response.statusText ||
-              String(
-                response.status === 0 || response.status
-                  ? response.status
-                  : 'Unknown response error'
-              )
-          )
-          this.name = 'HTTPError'
-          this.response = response
-          this.request = request
-          this.options = options
-        }
-      }
+    Object.setPrototypeOf(to, fromPrototype)
+  }
 
-      class TimeoutError extends Error {
-        constructor (request) {
-          super('Request timed out')
-          this.name = 'TimeoutError'
-          this.request = request
-        }
-      }
+  const wrappedToString = (withName, fromBody) =>
+    `/* Wrapped ${withName}*/\n${fromBody}`
 
-      const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+  const toStringDescriptor = Object.getOwnPropertyDescriptor(
+    Function.prototype,
+    'toString'
+  )
+  const toStringName = Object.getOwnPropertyDescriptor(
+    Function.prototype.toString,
+    'name'
+  )
 
-      // `Promise.race()` workaround (#91)
-      const timeout = (request, abortController, options) =>
-        new Promise((resolve, reject) => {
-          const timeoutID = setTimeout(() => {
-            if (abortController) {
-              abortController.abort()
-            }
+  // We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected.
+  // We use `bind()` instead of a closure for the same reason.
+  // Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times.
+  const changeToString = (to, from, name) => {
+    const withName = name === '' ? '' : `with ${name.trim()}() `
+    const newToString = wrappedToString.bind(null, withName, from.toString())
+    // Ensure `to.toString.toString` is non-enumerable and has the same `same`
+    Object.defineProperty(newToString, 'name', toStringName)
+    Object.defineProperty(to, 'toString', {
+      ...toStringDescriptor,
+      value: newToString
+    })
+  }
 
-            reject(new TimeoutError(request))
-          }, options.timeout)
+  const mimicFn$2 = (to, from, { ignoreNonConfigurable = false } = {}) => {
+    const { name } = to
 
-          /* eslint-disable promise/prefer-await-to-then */
-          options
-            .fetch(request)
-            .then(resolve)
-            .catch(reject)
-            .then(() => {
-              clearTimeout(timeoutID)
-            })
-          /* eslint-enable promise/prefer-await-to-then */
-        })
+    for (const property of Reflect.ownKeys(from)) {
+      copyProperty(to, from, property, ignoreNonConfigurable)
+    }
 
-      const normalizeRequestMethod = input =>
-        requestMethods.includes(input) ? input.toUpperCase() : input
+    changePrototype(to, from)
+    changeToString(to, from, name)
 
-      const defaultRetryOptions = {
-        limit: 2,
-        methods: retryMethods,
-        statusCodes: retryStatusCodes,
-        afterStatusCodes: retryAfterStatusCodes
-      }
+    return to
+  }
 
-      const normalizeRetryOptions = (retry = {}) => {
-        if (typeof retry === 'number') {
-          return {
-            ...defaultRetryOptions,
-            limit: retry
-          }
-        }
+  var mimicFn_1 = mimicFn$2
 
-        if (retry.methods && !Array.isArray(retry.methods)) {
-          throw new Error('retry.methods must be an array')
+  var helpers = {
+    isFunction: obj => typeof obj === 'function',
+    isString: obj => typeof obj === 'string',
+    composeErrorMessage: (code, description) => `${code}, ${description}`,
+    inherits: (ctor, superCtor) => {
+      ctor.super_ = superCtor
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
         }
+      })
+    }
+  }
 
-        if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-          throw new Error('retry.statusCodes must be an array')
-        }
+  const { isFunction, composeErrorMessage } = helpers
 
-        return {
-          ...defaultRetryOptions,
-          ...retry,
-          afterStatusCodes: retryAfterStatusCodes
-        }
-      }
+  function interfaceObject (error, ...props) {
+    Object.assign(error, ...props)
 
-      // The maximum value of a 32bit int (see issue #117)
-      const maxSafeTimeout = 2147483647
+    error.description = isFunction(error.message)
+      ? error.message(error)
+      : error.message
 
-      class Ky {
-        constructor (input, options = {}) {
-          this._retryCount = 0
-          this._input = input
-          this._options = {
-            // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
-            credentials: this._input.credentials || 'same-origin',
-            ...options,
-            headers: mergeHeaders(this._input.headers, options.headers),
-            hooks: deepMerge(
-              {
-                beforeRequest: [],
-                beforeRetry: [],
-                afterResponse: []
-              },
-              options.hooks
-            ),
-            method: normalizeRequestMethod(
-              options.method || this._input.method
-            ),
-            prefixUrl: String(options.prefixUrl || ''),
-            retry: normalizeRetryOptions(options.retry),
-            throwHttpErrors: options.throwHttpErrors !== false,
-            timeout:
-              typeof options.timeout === 'undefined' ? 10000 : options.timeout,
-            fetch: options.fetch || globalThis.fetch.bind(globalThis)
-          }
+    error.message = error.code
+      ? composeErrorMessage(error.code, error.description)
+      : error.description
+  }
 
-          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')
-          }
+  var addErrorProps$1 = interfaceObject
 
-          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`'
-              )
-            }
+  const cleanStack = cleanStack$1
+  const mimicFn$1 = mimicFn_1
 
-            if (!this._options.prefixUrl.endsWith('/')) {
-              this._options.prefixUrl += '/'
-            }
+  const addErrorProps = addErrorProps$1
+  const { isString } = helpers
 
-            this._input = this._options.prefixUrl + this._input
-          }
+  function createExtendError$1 (ErrorClass, classProps) {
+    function ExtendError (props) {
+      const error = new ErrorClass()
+      const errorProps = isString(props) ? { message: props } : props
+      addErrorProps(error, classProps, errorProps)
 
-          if (supportsAbortController) {
-            this.abortController = new globalThis.AbortController()
-            if (this._options.signal) {
-              this._options.signal.addEventListener('abort', () => {
-                this.abortController.abort()
-              })
-            }
+      error.stack = cleanStack(error.stack)
+      return error
+    }
 
-            this._options.signal = this.abortController.signal
-          }
+    ExtendError.prototype = ErrorClass.prototype
+    mimicFn$1(ExtendError, ErrorClass)
 
-          this.request = new globalThis.Request(this._input, this._options)
+    return ExtendError
+  }
 
-          if (this._options.searchParams) {
-            const textSearchParams =
-              typeof this._options.searchParams === 'string'
-                ? this._options.searchParams.replace(/^\?/, '')
-                : new URLSearchParams(this._options.searchParams).toString()
-            const searchParams = '?' + textSearchParams
-            const url = this.request.url.replace(
-              /(?:\?.*?)?(?=#|$)/,
-              searchParams
-            )
+  var createExtendError_1 = createExtendError$1
 
-            // 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')
-            }
+  const { inherits } = helpers
+  const mimicFn = mimicFn_1
 
-            this.request = new globalThis.Request(
-              new globalThis.Request(url, this.request),
-              this._options
-            )
-          }
+  const REGEX_CLASS_NAME = /[^0-9a-zA-Z_$]/
 
-          if (this._options.json !== undefined) {
-            this._options.body = JSON.stringify(this._options.json)
-            this.request.headers.set('content-type', 'application/json')
-            this.request = new globalThis.Request(this.request, {
-              body: this._options.body
-            })
-          }
+  function createError$1 (className) {
+    if (typeof className !== 'string') {
+      throw new TypeError('Expected className to be a string')
+    }
 
-          const fn = async () => {
-            if (this._options.timeout > maxSafeTimeout) {
-              throw new RangeError(
-                `The \`timeout\` option cannot be greater than ${maxSafeTimeout}`
-              )
-            }
+    if (REGEX_CLASS_NAME.test(className)) {
+      throw new Error('className contains invalid characters')
+    }
 
-            await delay(1)
-            let response = await this._fetch()
+    function ErrorClass () {
+      Object.defineProperty(this, 'name', {
+        configurable: true,
+        value: className,
+        writable: true
+      })
 
-            for (const hook of this._options.hooks.afterResponse) {
-              // eslint-disable-next-line no-await-in-loop
-              const modifiedResponse = await hook(
-                this.request,
-                this._options,
-                this._decorateResponse(response.clone())
-              )
+      Error.captureStackTrace(this, this.constructor)
+    }
 
-              if (modifiedResponse instanceof globalThis.Response) {
-                response = modifiedResponse
-              }
-            }
+    inherits(ErrorClass, Error)
+    mimicFn(ErrorClass, Error)
+    return ErrorClass
+  }
 
-            this._decorateResponse(response)
+  var createError_1 = createError$1
 
-            if (!response.ok && this._options.throwHttpErrors) {
-              throw new HTTPError(response, this.request, this._options)
-            }
+  const createExtendError = createExtendError_1
+  const createError = createError_1
 
-            // If `onDownloadProgress` is passed, it uses the stream API internally
-            /* istanbul ignore next */
-            if (this._options.onDownloadProgress) {
-              if (typeof this._options.onDownloadProgress !== 'function') {
-                throw new TypeError(
-                  'The `onDownloadProgress` option must be a function'
-                )
-              }
+  const createErrorClass = ErrorClass => (className, props) => {
+    const errorClass = createError(className || ErrorClass.name)
+    return createExtendError(errorClass, props)
+  }
 
-              if (!supportsStreams) {
-                throw new Error(
-                  'Streams are not supported in your environment. `ReadableStream` is missing.'
-                )
-              }
+  lib.exports = createErrorClass(Error)
+  lib.exports.type = createErrorClass(TypeError)
+  lib.exports.range = createErrorClass(RangeError)
+  lib.exports.eval = createErrorClass(EvalError)
+  lib.exports.syntax = createErrorClass(SyntaxError)
+  lib.exports.reference = createErrorClass(ReferenceError)
+  lib.exports.uri = createErrorClass(URIError)
 
-              return this._stream(
-                response.clone(),
-                this._options.onDownloadProgress
-              )
-            }
+  const ENDPOINT = {
+    FREE: 'https://api.microlink.io',
+    PRO: 'https://pro.microlink.io'
+  }
 
-            return response
-          }
+  const isObject = input => input !== null && typeof input === 'object'
 
-          const isRetriableMethod = this._options.retry.methods.includes(
-            this.request.method.toLowerCase()
-          )
-          const result = isRetriableMethod ? this._retry(fn) : fn()
+  const parseBody = (input, error, url) => {
+    try {
+      return JSON.parse(input)
+    } catch (_) {
+      const message = input || error.message
 
-          for (const [type, mimeType] of Object.entries(responseTypes)) {
-            result[type] = async () => {
-              this.request.headers.set(
-                'accept',
-                this.request.headers.get('accept') || mimeType
-              )
+      return {
+        status: 'error',
+        data: { url: message },
+        more: 'https://microlink.io/efatalclient',
+        code: 'EFATALCLIENT',
+        message,
+        url
+      }
+    }
+  }
 
-              const response = (await result).clone()
+  const factory$1 = ({
+    VERSION,
+    MicrolinkError,
+    isUrlHttp,
+    stringify,
+    got,
+    flatten
+  }) => {
+    const assertUrl = (url = '') => {
+      if (!isUrlHttp(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/docs/api/api-parameters/url',
+          code: 'EINVALURLCLIENT',
+          message,
+          url
+        })
+      }
+    }
 
-              if (type === 'json') {
-                if (response.status === 204) {
-                  return ''
-                }
+    const mapRules = rules => {
+      if (!isObject(rules)) return
+      const flatRules = flatten(rules)
+      return Object.keys(flatRules).reduce(
+        (acc, key) => ({ ...acc, [`data.${key}`]: flatRules[key].toString() }),
+        {}
+      )
+    }
 
-                if (options.parseJson) {
-                  return options.parseJson(await response.text())
-                }
-              }
+    const fetchFromApi = async (apiUrl, opts = {}, retryCount = 0) => {
+      try {
+        const response = await got(apiUrl, opts)
+        return opts.responseType === 'buffer'
+          ? { body: response.body, response }
+          : { ...response.body, response }
+      } catch (err) {
+        const { response = {} } = err
+        const {
+          statusCode,
+          body: rawBody,
+          headers,
+          url: uri = apiUrl
+        } = response
+        const isBuffer = Buffer.isBuffer(rawBody)
 
-              return response[type]()
-            }
-          }
+        const body =
+          isObject(rawBody) && !isBuffer
+            ? rawBody
+            : parseBody(isBuffer ? rawBody.toString() : rawBody, err, uri)
 
-          return result
+        if (body.code === 'EFATALCLIENT' && retryCount++ < 2) {
+          return fetchFromApi(apiUrl, opts, retryCount)
         }
 
-        _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
-                }
+        throw MicrolinkError({
+          ...body,
+          message: body.message,
+          url: uri,
+          statusCode,
+          headers
+        })
+      }
+    }
 
-                if (
-                  typeof this._options.retry.maxRetryAfter !== 'undefined' &&
-                  after > this._options.retry.maxRetryAfter
-                ) {
-                  return 0
-                }
+    const getApiUrl = (
+      url,
+      { data, apiKey, endpoint, retry, cache, ...opts } = {},
+      { responseType = 'json', headers: gotHeaders, ...gotOpts } = {}
+    ) => {
+      const isPro = !!apiKey
+      const apiEndpoint = endpoint || ENDPOINT[isPro ? 'PRO' : 'FREE']
 
-                return after
-              }
+      const apiUrl = `${apiEndpoint}?${stringify({
+        url,
+        ...mapRules(data),
+        ...flatten(opts)
+      })}`
 
-              if (error.response.status === 413) {
-                return 0
-              }
-            }
+      const headers = isPro
+        ? { ...gotHeaders, 'x-api-key': apiKey }
+        : { ...gotHeaders }
+      return [apiUrl, { ...gotOpts, responseType, cache, retry, headers }]
+    }
 
-            const BACKOFF_FACTOR = 0.3
-            return BACKOFF_FACTOR * 2 ** (this._retryCount - 1) * 1000
-          }
+    const createMql = defaultOpts => async (url, opts, gotOpts) => {
+      assertUrl(url)
+      const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
+        ...defaultOpts,
+        ...gotOpts
+      })
+      return fetchFromApi(apiUrl, fetchOpts)
+    }
 
-          return 0
-        }
+    const mql = createMql()
+    mql.MicrolinkError = MicrolinkError
+    mql.getApiUrl = getApiUrl
+    mql.fetchFromApi = fetchFromApi
+    mql.mapRules = mapRules
+    mql.version = VERSION
+    mql.stream = got.stream
+    mql.buffer = createMql({ responseType: 'buffer' })
 
-        _decorateResponse (response) {
-          if (this._options.parseJson) {
-            response.json = async () => {
-              return this._options.parseJson(await response.text())
-            }
-          }
+    return mql
+  }
 
-          return response
-        }
+  var factory_1 = factory$1
 
-        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)
+  var ky$1 = { exports: {} }
 
-              for (const hook of this._options.hooks.beforeRetry) {
-                // eslint-disable-next-line no-await-in-loop
-                const hookResult = await hook({
-                  request: this.request,
-                  options: this._options,
-                  error,
-                  retryCount: this._retryCount
-                })
+  ;(function (module, exports) {
+    ;(function (global, factory) {
+      module.exports = factory()
+    })(commonjsGlobal, function () {
+      /*! MIT License © Sindre Sorhus */
 
-                // If `stop` is returned from the hook, the retry process is stopped
-                if (hookResult === stop) {
-                  return
-                }
-              }
+      const isObject = value => value !== null && typeof value === 'object'
+      const supportsAbortController =
+        typeof globalThis.AbortController === 'function'
+      const supportsStreams = typeof globalThis.ReadableStream === 'function'
+      const supportsFormData = typeof globalThis.FormData === 'function'
 
-              return this._retry(fn)
-            }
+      const mergeHeaders = (source1, source2) => {
+        const result = new globalThis.Headers(source1 || {})
+        const isHeadersInstance = source2 instanceof globalThis.Headers
+        const source = new globalThis.Headers(source2 || {})
 
-            if (this._options.throwHttpErrors) {
-              throw error
-            }
+        for (const [key, value] of source) {
+          if (
+            (isHeadersInstance && value === 'undefined') ||
+            value === undefined
+          ) {
+            result.delete(key)
+          } else {
+            result.set(key, value)
           }
         }
 
-        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)
+        return result
+      }
 
-            if (result instanceof Request) {
-              this.request = result
-              break
+      const deepMerge = (...sources) => {
+        let returnValue = {}
+        let headers = {}
+
+        for (const source of sources) {
+          if (Array.isArray(source)) {
+            if (!Array.isArray(returnValue)) {
+              returnValue = []
             }
 
-            if (result instanceof Response) {
-              return result
+            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 (this._options.timeout === false) {
-            return this._options.fetch(this.request.clone())
+            if (isObject(source.headers)) {
+              headers = mergeHeaders(headers, source.headers)
+            }
           }
 
-          return timeout(
-            this.request.clone(),
-            this.abortController,
-            this._options
-          )
+          returnValue.headers = headers
         }
 
-        /* istanbul ignore next */
-        _stream (response, onDownloadProgress) {
-          const totalBytes = Number(response.headers.get('content-length')) || 0
-          let transferredBytes = 0
+        return returnValue
+      }
+
+      const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete']
 
-          return new globalThis.Response(
-            new globalThis.ReadableStream({
-              async start (controller) {
-                const reader = response.body.getReader()
+      const responseTypes = {
+        json: 'application/json',
+        text: 'text/*',
+        formData: 'multipart/form-data',
+        arrayBuffer: '*/*',
+        blob: '*/*'
+      }
 
-                if (onDownloadProgress) {
-                  onDownloadProgress(
-                    { percent: 0, transferredBytes: 0, totalBytes },
-                    new Uint8Array()
-                  )
-                }
+      const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace']
 
-                async function read () {
-                  const { done, value } = await reader.read()
-                  if (done) {
-                    controller.close()
-                    return
-                  }
+      const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504]
 
-                  if (onDownloadProgress) {
-                    transferredBytes += value.byteLength
-                    const percent =
-                      totalBytes === 0 ? 0 : transferredBytes / totalBytes
-                    onDownloadProgress(
-                      { percent, transferredBytes, totalBytes },
-                      value
-                    )
-                  }
+      const retryAfterStatusCodes = [413, 429, 503]
 
-                  controller.enqueue(value)
-                  await read()
-                }
+      const stop = Symbol('stop')
 
-                await read()
-              }
-            })
+      class HTTPError extends Error {
+        constructor (response, request, options) {
+          // Set the message to the status text, such as Unauthorized,
+          // with some fallbacks. This message should never be undefined.
+          super(
+            response.statusText ||
+              String(
+                response.status === 0 || response.status
+                  ? response.status
+                  : 'Unknown response error'
+              )
           )
+          this.name = 'HTTPError'
+          this.response = response
+          this.request = request
+          this.options = options
         }
       }
 
-      const validateAndMerge = (...sources) => {
-        for (const source of sources) {
-          if (
-            (!isObject(source) || Array.isArray(source)) &&
-            typeof source !== 'undefined'
-          ) {
-            throw new TypeError('The `options` argument must be an object')
-          }
+      class TimeoutError extends Error {
+        constructor (request) {
+          super('Request timed out')
+          this.name = 'TimeoutError'
+          this.request = request
         }
-
-        return deepMerge({}, ...sources)
       }
 
-      const createInstance = defaults => {
-        const ky = (input, options) =>
-          new Ky(input, validateAndMerge(defaults, options))
+      const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
 
-        for (const method of requestMethods) {
-          ky[method] = (input, options) =>
-            new Ky(input, validateAndMerge(defaults, options, { method }))
-        }
+      // `Promise.race()` workaround (#91)
+      const timeout = (request, abortController, options) =>
+        new Promise((resolve, reject) => {
+          const timeoutID = setTimeout(() => {
+            if (abortController) {
+              abortController.abort()
+            }
 
-        ky.HTTPError = HTTPError
-        ky.TimeoutError = TimeoutError
-        ky.create = newDefaults => createInstance(validateAndMerge(newDefaults))
-        ky.extend = newDefaults =>
-          createInstance(validateAndMerge(defaults, newDefaults))
-        ky.stop = stop
+            reject(new TimeoutError(request))
+          }, options.timeout)
 
-        return ky
-      }
+          /* eslint-disable promise/prefer-await-to-then */
+          options
+            .fetch(request)
+            .then(resolve)
+            .catch(reject)
+            .then(() => {
+              clearTimeout(timeoutID)
+            })
+          /* eslint-enable promise/prefer-await-to-then */
+        })
 
-      const ky = createInstance()
+      const normalizeRequestMethod = input =>
+        requestMethods.includes(input) ? input.toUpperCase() : input
 
-      return ky
-    })
-  })(ky$1)
+      const defaultRetryOptions = {
+        limit: 2,
+        methods: retryMethods,
+        statusCodes: retryStatusCodes,
+        afterStatusCodes: retryAfterStatusCodes
+      }
 
-  var lib = { exports: {} }
+      const normalizeRetryOptions = (retry = {}) => {
+        if (typeof retry === 'number') {
+          return {
+            ...defaultRetryOptions,
+            limit: retry
+          }
+        }
 
-  var _nodeResolve_empty = {}
+        if (retry.methods && !Array.isArray(retry.methods)) {
+          throw new Error('retry.methods must be an array')
+        }
 
-  var _nodeResolve_empty$1 = /*#__PURE__*/ Object.freeze({
-    __proto__: null,
-    default: _nodeResolve_empty
-  })
+        if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+          throw new Error('retry.statusCodes must be an array')
+        }
 
-  var require$$0 = /*@__PURE__*/ getAugmentedNamespace(_nodeResolve_empty$1)
+        return {
+          ...defaultRetryOptions,
+          ...retry,
+          afterStatusCodes: retryAfterStatusCodes
+        }
+      }
 
-  const os = require$$0
+      // The maximum value of a 32bit int (see issue #117)
+      const maxSafeTimeout = 2147483647
 
-  const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/
-  const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/
-  const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir()
+      class Ky {
+        constructor (input, options = {}) {
+          this._retryCount = 0
+          this._input = input
+          this._options = {
+            // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
+            credentials: this._input.credentials || 'same-origin',
+            ...options,
+            headers: mergeHeaders(this._input.headers, options.headers),
+            hooks: deepMerge(
+              {
+                beforeRequest: [],
+                beforeRetry: [],
+                afterResponse: []
+              },
+              options.hooks
+            ),
+            method: normalizeRequestMethod(
+              options.method || this._input.method
+            ),
+            prefixUrl: String(options.prefixUrl || ''),
+            retry: normalizeRetryOptions(options.retry),
+            throwHttpErrors: options.throwHttpErrors !== false,
+            timeout:
+              typeof options.timeout === 'undefined' ? 10000 : options.timeout,
+            fetch: options.fetch || globalThis.fetch.bind(globalThis)
+          }
 
-  var cleanStack$1 = (stack, options) => {
-    options = Object.assign({ pretty: false }, options)
+          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')
+          }
 
-    return stack
-      .replace(/\\/g, '/')
-      .split('\n')
-      .filter(line => {
-        const pathMatches = line.match(extractPathRegex)
-        if (pathMatches === null || !pathMatches[1]) {
-          return true
-        }
+          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`'
+              )
+            }
 
-        const match = pathMatches[1]
+            if (!this._options.prefixUrl.endsWith('/')) {
+              this._options.prefixUrl += '/'
+            }
 
-        // Electron
-        if (
-          match.includes('.app/Contents/Resources/electron.asar') ||
-          match.includes('.app/Contents/Resources/default_app.asar')
-        ) {
-          return false
-        }
+            this._input = this._options.prefixUrl + this._input
+          }
 
-        return !pathRegex.test(match)
-      })
-      .filter(line => line.trim() !== '')
-      .map(line => {
-        if (options.pretty) {
-          return line.replace(extractPathRegex, (m, p1) =>
-            m.replace(p1, p1.replace(homeDir, '~'))
-          )
-        }
+          if (supportsAbortController) {
+            this.abortController = new globalThis.AbortController()
+            if (this._options.signal) {
+              this._options.signal.addEventListener('abort', () => {
+                this.abortController.abort()
+              })
+            }
 
-        return line
-      })
-      .join('\n')
-  }
+            this._options.signal = this.abortController.signal
+          }
 
-  const copyProperty = (to, from, property, ignoreNonConfigurable) => {
-    // `Function#length` should reflect the parameters of `to` not `from` since we keep its body.
-    // `Function#prototype` is non-writable and non-configurable so can never be modified.
-    if (property === 'length' || property === 'prototype') {
-      return
-    }
+          this.request = new globalThis.Request(this._input, this._options)
 
-    const toDescriptor = Object.getOwnPropertyDescriptor(to, property)
-    const fromDescriptor = Object.getOwnPropertyDescriptor(from, property)
+          if (this._options.searchParams) {
+            const textSearchParams =
+              typeof this._options.searchParams === 'string'
+                ? this._options.searchParams.replace(/^\?/, '')
+                : new URLSearchParams(this._options.searchParams).toString()
+            const searchParams = '?' + textSearchParams
+            const url = this.request.url.replace(
+              /(?:\?.*?)?(?=#|$)/,
+              searchParams
+            )
 
-    if (
-      !canCopyProperty(toDescriptor, fromDescriptor) &&
-      ignoreNonConfigurable
-    ) {
-      return
-    }
+            // 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')
+            }
 
-    Object.defineProperty(to, property, fromDescriptor)
-  }
+            this.request = new globalThis.Request(
+              new globalThis.Request(url, this.request),
+              this._options
+            )
+          }
 
-  // `Object.defineProperty()` throws if the property exists, is not configurable and either:
-  //  - one its descriptors is changed
-  //  - it is non-writable and its value is changed
-  const canCopyProperty = function (toDescriptor, fromDescriptor) {
-    return (
-      toDescriptor === undefined ||
-      toDescriptor.configurable ||
-      (toDescriptor.writable === fromDescriptor.writable &&
-        toDescriptor.enumerable === fromDescriptor.enumerable &&
-        toDescriptor.configurable === fromDescriptor.configurable &&
-        (toDescriptor.writable || toDescriptor.value === fromDescriptor.value))
-    )
-  }
+          if (this._options.json !== undefined) {
+            this._options.body = JSON.stringify(this._options.json)
+            this.request.headers.set('content-type', 'application/json')
+            this.request = new globalThis.Request(this.request, {
+              body: this._options.body
+            })
+          }
 
-  const changePrototype = (to, from) => {
-    const fromPrototype = Object.getPrototypeOf(from)
-    if (fromPrototype === Object.getPrototypeOf(to)) {
-      return
-    }
+          const fn = async () => {
+            if (this._options.timeout > maxSafeTimeout) {
+              throw new RangeError(
+                `The \`timeout\` option cannot be greater than ${maxSafeTimeout}`
+              )
+            }
 
-    Object.setPrototypeOf(to, fromPrototype)
-  }
+            await delay(1)
+            let response = await this._fetch()
 
-  const wrappedToString = (withName, fromBody) =>
-    `/* Wrapped ${withName}*/\n${fromBody}`
+            for (const hook of this._options.hooks.afterResponse) {
+              // eslint-disable-next-line no-await-in-loop
+              const modifiedResponse = await hook(
+                this.request,
+                this._options,
+                this._decorateResponse(response.clone())
+              )
 
-  const toStringDescriptor = Object.getOwnPropertyDescriptor(
-    Function.prototype,
-    'toString'
-  )
-  const toStringName = Object.getOwnPropertyDescriptor(
-    Function.prototype.toString,
-    'name'
-  )
+              if (modifiedResponse instanceof globalThis.Response) {
+                response = modifiedResponse
+              }
+            }
 
-  // We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected.
-  // We use `bind()` instead of a closure for the same reason.
-  // Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times.
-  const changeToString = (to, from, name) => {
-    const withName = name === '' ? '' : `with ${name.trim()}() `
-    const newToString = wrappedToString.bind(null, withName, from.toString())
-    // Ensure `to.toString.toString` is non-enumerable and has the same `same`
-    Object.defineProperty(newToString, 'name', toStringName)
-    Object.defineProperty(to, 'toString', {
-      ...toStringDescriptor,
-      value: newToString
-    })
-  }
+            this._decorateResponse(response)
 
-  const mimicFn$2 = (to, from, { ignoreNonConfigurable = false } = {}) => {
-    const { name } = to
+            if (!response.ok && this._options.throwHttpErrors) {
+              throw new HTTPError(response, this.request, this._options)
+            }
 
-    for (const property of Reflect.ownKeys(from)) {
-      copyProperty(to, from, property, ignoreNonConfigurable)
-    }
+            // If `onDownloadProgress` is passed, it uses the stream API internally
+            /* istanbul ignore next */
+            if (this._options.onDownloadProgress) {
+              if (typeof this._options.onDownloadProgress !== 'function') {
+                throw new TypeError(
+                  'The `onDownloadProgress` option must be a function'
+                )
+              }
 
-    changePrototype(to, from)
-    changeToString(to, from, name)
+              if (!supportsStreams) {
+                throw new Error(
+                  'Streams are not supported in your environment. `ReadableStream` is missing.'
+                )
+              }
 
-    return to
-  }
+              return this._stream(
+                response.clone(),
+                this._options.onDownloadProgress
+              )
+            }
 
-  var mimicFn_1 = mimicFn$2
+            return response
+          }
 
-  var helpers = {
-    isFunction: obj => typeof obj === 'function',
-    isString: obj => typeof obj === 'string',
-    composeErrorMessage: (code, description) => `${code}, ${description}`,
-    inherits: (ctor, superCtor) => {
-      ctor.super_ = superCtor
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      })
-    }
-  }
+          const isRetriableMethod = this._options.retry.methods.includes(
+            this.request.method.toLowerCase()
+          )
+          const result = isRetriableMethod ? this._retry(fn) : fn()
 
-  const { isFunction, composeErrorMessage } = helpers
+          for (const [type, mimeType] of Object.entries(responseTypes)) {
+            result[type] = async () => {
+              this.request.headers.set(
+                'accept',
+                this.request.headers.get('accept') || mimeType
+              )
 
-  function interfaceObject (error, ...props) {
-    Object.assign(error, ...props)
+              const response = (await result).clone()
 
-    error.description = isFunction(error.message)
-      ? error.message(error)
-      : error.message
+              if (type === 'json') {
+                if (response.status === 204) {
+                  return ''
+                }
 
-    error.message = error.code
-      ? composeErrorMessage(error.code, error.description)
-      : error.description
-  }
+                if (options.parseJson) {
+                  return options.parseJson(await response.text())
+                }
+              }
 
-  var addErrorProps$1 = interfaceObject
+              return response[type]()
+            }
+          }
 
-  const cleanStack = cleanStack$1
-  const mimicFn$1 = mimicFn_1
+          return result
+        }
 
-  const addErrorProps = addErrorProps$1
-  const { isString } = helpers
+        _calculateRetryDelay (error) {
+          this._retryCount++
 
-  function createExtendError$1 (ErrorClass, classProps) {
-    function ExtendError (props) {
-      const error = new ErrorClass()
-      const errorProps = isString(props) ? { message: props } : props
-      addErrorProps(error, classProps, errorProps)
+          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
+              }
 
-      error.stack = cleanStack(error.stack)
-      return error
-    }
+              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
+                }
 
-    ExtendError.prototype = ErrorClass.prototype
-    mimicFn$1(ExtendError, ErrorClass)
+                if (
+                  typeof this._options.retry.maxRetryAfter !== 'undefined' &&
+                  after > this._options.retry.maxRetryAfter
+                ) {
+                  return 0
+                }
 
-    return ExtendError
-  }
+                return after
+              }
 
-  var createExtendError_1 = createExtendError$1
+              if (error.response.status === 413) {
+                return 0
+              }
+            }
 
-  const { inherits } = helpers
-  const mimicFn = mimicFn_1
+            const BACKOFF_FACTOR = 0.3
+            return BACKOFF_FACTOR * 2 ** (this._retryCount - 1) * 1000
+          }
 
-  const REGEX_CLASS_NAME = /[^0-9a-zA-Z_$]/
+          return 0
+        }
 
-  function createError$1 (className) {
-    if (typeof className !== 'string') {
-      throw new TypeError('Expected className to be a string')
-    }
+        _decorateResponse (response) {
+          if (this._options.parseJson) {
+            response.json = async () => {
+              return this._options.parseJson(await response.text())
+            }
+          }
 
-    if (REGEX_CLASS_NAME.test(className)) {
-      throw new Error('className contains invalid characters')
-    }
+          return response
+        }
 
-    function ErrorClass () {
-      Object.defineProperty(this, 'name', {
-        configurable: true,
-        value: className,
-        writable: true
-      })
+        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)
 
-      Error.captureStackTrace(this, this.constructor)
-    }
+              for (const hook of this._options.hooks.beforeRetry) {
+                // eslint-disable-next-line no-await-in-loop
+                const hookResult = await hook({
+                  request: this.request,
+                  options: this._options,
+                  error,
+                  retryCount: this._retryCount
+                })
 
-    inherits(ErrorClass, Error)
-    mimicFn(ErrorClass, Error)
-    return ErrorClass
-  }
+                // If `stop` is returned from the hook, the retry process is stopped
+                if (hookResult === stop) {
+                  return
+                }
+              }
 
-  var createError_1 = createError$1
+              return this._retry(fn)
+            }
 
-  const createExtendError = createExtendError_1
-  const createError = createError_1
+            if (this._options.throwHttpErrors) {
+              throw error
+            }
+          }
+        }
 
-  const createErrorClass = ErrorClass => (className, props) => {
-    const errorClass = createError(className || ErrorClass.name)
-    return createExtendError(errorClass, props)
-  }
+        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)
 
-  lib.exports = createErrorClass(Error)
-  lib.exports.type = createErrorClass(TypeError)
-  lib.exports.range = createErrorClass(RangeError)
-  lib.exports.eval = createErrorClass(EvalError)
-  lib.exports.syntax = createErrorClass(SyntaxError)
-  lib.exports.reference = createErrorClass(ReferenceError)
-  lib.exports.uri = createErrorClass(URIError)
+            if (result instanceof Request) {
+              this.request = result
+              break
+            }
 
-  const ENDPOINT = {
-    FREE: 'https://api.microlink.io',
-    PRO: 'https://pro.microlink.io'
-  }
+            if (result instanceof Response) {
+              return result
+            }
+          }
 
-  const isObject = input => typeof input === 'object'
+          if (this._options.timeout === false) {
+            return this._options.fetch(this.request.clone())
+          }
 
-  const pickBy = obj => {
-    Object.keys(obj).forEach(key => obj[key] == null && delete obj[key])
-    return obj
-  }
+          return timeout(
+            this.request.clone(),
+            this.abortController,
+            this._options
+          )
+        }
 
-  const parseBody = (input, error, url) => {
-    try {
-      return JSON.parse(input)
-    } catch (_) {
-      const message = input || error.message
+        /* istanbul ignore next */
+        _stream (response, onDownloadProgress) {
+          const totalBytes = Number(response.headers.get('content-length')) || 0
+          let transferredBytes = 0
 
-      return {
-        status: 'error',
-        data: { url: message },
-        more: 'https://microlink.io/efatal',
-        code: 'EFATAL',
-        message,
-        url
-      }
-    }
-  }
+          return new globalThis.Response(
+            new globalThis.ReadableStream({
+              async start (controller) {
+                const reader = response.body.getReader()
 
-  const factory$1 = ({
-    VERSION,
-    MicrolinkError,
-    isUrlHttp,
-    stringify,
-    got,
-    flatten
-  }) => {
-    const assertUrl = (url = '') => {
-      if (!isUrlHttp(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/docs/api/api-parameters/url',
-          code: 'EINVALURLCLIENT',
-          message,
-          url
-        })
-      }
-    }
+                if (onDownloadProgress) {
+                  onDownloadProgress(
+                    { percent: 0, transferredBytes: 0, totalBytes },
+                    new Uint8Array()
+                  )
+                }
 
-    const mapRules = rules => {
-      if (!isObject(rules)) return
-      const flatRules = flatten(rules)
-      return Object.keys(flatRules).reduce(
-        (acc, key) => ({ ...acc, [`data.${key}`]: flatRules[key] }),
-        {}
-      )
-    }
+                async function read () {
+                  const { done, value } = await reader.read()
+                  if (done) {
+                    controller.close()
+                    return
+                  }
 
-    const fetchFromApi = async (apiUrl, opts = {}) => {
-      try {
-        const response = await got(apiUrl, opts)
-        return opts.responseType === 'buffer'
-          ? { body: response.body, response }
-          : { ...response.body, response }
-      } catch (err) {
-        const { response = {} } = err
-        const {
-          statusCode,
-          body: rawBody,
-          headers,
-          url: uri = apiUrl
-        } = response
+                  if (onDownloadProgress) {
+                    transferredBytes += value.byteLength
+                    const percent =
+                      totalBytes === 0 ? 0 : transferredBytes / totalBytes
+                    onDownloadProgress(
+                      { percent, transferredBytes, totalBytes },
+                      value
+                    )
+                  }
 
-        const body =
-          isObject(rawBody) && !Buffer.isBuffer(rawBody)
-            ? rawBody
-            : parseBody(rawBody, err, uri)
+                  controller.enqueue(value)
+                  await read()
+                }
 
-        throw MicrolinkError({
-          ...body,
-          message: body.message,
-          url: uri,
-          statusCode,
-          headers
-        })
+                await read()
+              }
+            })
+          )
+        }
       }
-    }
 
-    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 validateAndMerge = (...sources) => {
+        for (const source of sources) {
+          if (
+            (!isObject(source) || Array.isArray(source)) &&
+            typeof source !== 'undefined'
+          ) {
+            throw new TypeError('The `options` argument must be an object')
+          }
+        }
 
-      const apiUrl = `${apiEndpoint}?${stringify({
-        url,
-        ...mapRules(data),
-        ...flatten(pickBy(opts))
-      })}`
+        return deepMerge({}, ...sources)
+      }
 
-      const headers = isPro
-        ? { ...gotHeaders, 'x-api-key': apiKey }
-        : { ...gotHeaders }
-      return [apiUrl, { ...gotOpts, responseType, cache, retry, headers }]
-    }
+      const createInstance = defaults => {
+        const ky = (input, options) =>
+          new Ky(input, validateAndMerge(defaults, options))
 
-    const createMql = defaultOpts => async (url, opts, gotOpts) => {
-      assertUrl(url)
-      const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
-        ...defaultOpts,
-        ...gotOpts
-      })
-      return fetchFromApi(apiUrl, fetchOpts)
-    }
+        for (const method of requestMethods) {
+          ky[method] = (input, options) =>
+            new Ky(input, validateAndMerge(defaults, options, { method }))
+        }
 
-    const mql = createMql()
-    mql.MicrolinkError = MicrolinkError
-    mql.getApiUrl = getApiUrl
-    mql.fetchFromApi = fetchFromApi
-    mql.mapRules = mapRules
-    mql.version = VERSION
-    mql.stream = got.stream
-    mql.buffer = createMql({ responseType: 'buffer' })
+        ky.HTTPError = HTTPError
+        ky.TimeoutError = TimeoutError
+        ky.create = newDefaults => createInstance(validateAndMerge(newDefaults))
+        ky.extend = newDefaults =>
+          createInstance(validateAndMerge(defaults, newDefaults))
+        ky.stop = stop
 
-    return mql
-  }
+        return ky
+      }
 
-  var factory_1 = factory$1
+      const ky = createInstance()
+
+      return ky
+    })
+  })(ky$1)
 
   const isUrlHttp = lightweight
   const { flattie: flatten } = dist
   const { encode: stringify } = require$$2
-  const ky = ky$1.exports
   const whoops = lib.exports
 
   const factory = factory_1
+  const ky = ky$1.exports
 
   const MicrolinkError = whoops('MicrolinkError')
 
@@ -1153,13 +1153,13 @@
     stringify,
     got,
     flatten,
-    VERSION: '0.9.3'
+    VERSION: '0.10.13'
   })
 
   var browser = factory_1$1({
     mql: browser$1,
     toCompress: code => code.toString(),
-    VERSION: '0.1.1'
+    VERSION: '0.1.2'
   })
 
   return browser