docs: async function main () {
  
      const requirements = exchangeId && methodName
      if (!requirements) {
  
          printUsage ()
  
      } else {
  
          let args = params
              .map (s => s.match (/^[0-9]{4}[-]?[0-9]{2}[-]?[0-9]{2}[T\s]?[0-9]{2}[:]?[0-9]{2}[:]?[0-9]{2}/g) ? exchange.parse8601 (s) : s)
              .map (s => (() => { try { return eval ('(() => (' + s + ')) ()') } catch (e) { return s } }) ())
  
          const www = Array.isArray (exchange.urls.www) ? exchange.urls.www[0] : exchange.urls.www
  
          if (cloudscrape)
              exchange.headers = await scrapeCloudflareHttpHeaderCookie (www)
  
          if (cfscrape)
              exchange.headers = cfscrapeCookies (www)
  
          if (cors) {
              exchange.proxy =  'https://cors-anywhere.herokuapp.com/';
              exchange.origin = exchange.uuid ()
          }
  
          no_load_markets = no_send ? true : no_load_markets
  
          if (debug) {
              exchange.verbose = verbose
          }
  
          if (!no_load_markets) {
              await exchange.loadMarkets ()
          }
  
          exchange.verbose = verbose
  
          if (no_send) {
  
              exchange.verbose = no_send
              exchange.fetch = function fetch (url, method = 'GET', headers = undefined, body = undefined) {
                  log.dim.noLocate ('-------------------------------------------')
                  log.dim.noLocate (exchange.iso8601 (exchange.milliseconds ()))
                  log.green.unlimited ({
                      url,
                      method,
                      headers,
                      body,
                  })
                  process.exit ()
              }
          }
  
          if (typeof exchange[methodName] === 'function') {
  
              log (exchange.id + '.' + methodName, '(' + args.join (', ') + ')')
  
              while (true) {
  
                  try {
  
                      const result = await exchange[methodName] (... args)
                      printHumanReadable (exchange, result)
  
                  } catch (e) {
  
                      if (e instanceof ExchangeError) {
  
                          log.red (e.constructor.name, e.message)
  
                      } else if (e instanceof NetworkError) {
  
                          log.yellow (e.constructor.name, e.message)
  
                      }
  
                      log.dim ('---------------------------------------------------')
  
                      // rethrow for call-stack // other errors
                      throw e
  
                  }
  
                  if (!poll)
                      break;
              }
  
          } else if (exchange[methodName] === undefined) {
  
              log.red (exchange.id + '.' + methodName + ': no such property')
  
          } else {
  
              printHumanReadable (exchange, exchange[methodName])
          }
      }
  }