console.log(url); console.log(options);
777103
function access(cb, force){
						_this.login(function(login_result, login_accesskey){
							// console.log(login_result, login_accesskey);
							if( login_result === false && login_accesskey === false ){
								cb(null, false, 0, {});
								return;
							}
							_this.httpRequest(
								url,
								{
									'params': options ,
									'method': apiSettings.method
								},
								function(bin, status, responseHeaders){
									if( !status ){
										cb(false, false, 0, {});
										return;
									}
									try {
										bin = JSON.parse(bin);
									} catch (e) {
									}
									// console.log(bin);
									if( bin.return_code !== 0 ){
										if(force){
											cb(null, bin, status, responseHeaders);
											return;
										}
										setTimeout(function(){
											access(cb, true);
										}, 1000);
										return;
									}
									cb(bin.list, bin, status, responseHeaders);
									return;
								}
							);
						}, force);

					}
347031
function _log() {
  var args = Array.prototype.slice.call(arguments, 0),
    level = args.shift();

  if (!~['log', 'error', 'warn'].indexOf(level)) {
    args.unshift(level);
    level = 'log';
  }

  if (level == 'log') {
    args[0] = '----> ' + args[0];
  } else if (level == 'error') {
    args[0] = '....> ' + colors.red('ERROR: ') + args[0];
  } else if (level == 'warn') {
    args[0] = '....> ' + colors.yellow('WARNING: ') + args[0];
  }

  console[level].apply(console, args);
}
440549
function(msg, url, line){
		var message = "Error in (" + (url || window.location) + ") on line "+ line +" with message (" + msg + ")";
		this.log(Log4js.Level.FATAL, message, null);	
	}
210785
function log() {
  var _console;

  for (var _len = arguments.length, msgs = Array(_len), _key = 0; _key < _len; _key++) {
    msgs[_key] = arguments[_key];
  }

  (_console = console).log.apply(_console, _toConsumableArray(['' + _config2.default.name].concat(msgs)));
}
1075906
function showUsage() {
    console.log('\n  Usage: ' + argv.$0.cyan, '[command]', '[options]'.grey);

    showCommands();
    showTasks();
    showOptions();

    console.log('');
}
689920
function Errors(options) {
	var errors = [];

	/**
	 * Logs one or more errors (can be {Error}, {Object} or {String})
	 */
	this.log = function() {
		for (var i = 0; i < arguments.length; i++) {
			if (util.isArray(arguments[i])) {
				this.log(arguments[i]);
			} else {
				logError(arguments[i]);
			}
		}
	};

	/**
	 * @returns the number of errors logged
	 */
	this.count = function() {
		return errors.length;
	};

	/**
	 * Logs an error
	 * 
	 * @param e
	 *            the {Error} object or string
	 */
	function logError(e) {
		e = e instanceof Error ? e : e ? new Error(e) : null;
		if (e) {
			if (options && util.isRegExp(options.hideTokenRegExp)) {
				e.message = e.message.replace(options.hideTokenRegExp, function(match, prefix, token, suffix) {
					return prefix + '[SECURE]' + suffix;
				});
			}
			errors.unshift(e);
			rbot.log.error(e.stack || e.message);
		}
	}
}
1044816
function logReport(options) {
  const { outputDir, fontName } = options

  // Log font files output
  for (let ext of options.types) { logOutput(options, [ outputDir, `${ fontName }.${ ext }` ]) }

  // Log HTML file output
  if (options.html) {
    logOutput(options, [ getResolvedPath(options, 'html') ])
  }

  // Log CSS file output
  if (options.css) {
    logOutput(options, [ getResolvedPath(options, 'css') ])
  }

  // Log JSON map output
  if (options.json) {
    logOutput(options, [ getResolvedPath(options, 'json') ])
  }

  // Log final message
  log(options, 'Done'.green)
}
1023597
function() {
  var args = Array.from(arguments)
  var url = _.get(args, '[0]', '')
  var params = _.get(args, '[1]', {})

  // if we specify all of the options as a param object, we're basically done
  // and we can skip all of the parameterization checks below
  if (_.isPlainObject(_.get(args, '[0]', {})))
  {
    params = _.get(args, '[0]', {})
  }
   else
  {
    params = _.assign({}, { url }, params)
  }

  return _.assign({}, params, { op: 'request' })
}
126655
function () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];

      if (!settings$2.debug) {
        return;
      }
      args.unshift('DEBUG');
      settings$2.logger.output.apply(null, args);
    }
294764
function log(...args) {
		console.log('#output +=', ...args);
		output.textContent += args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ') +'\n';
	}
110540
function Debug() {
  function _debug() {};

  _debug.log = function(_) {

    return Action({

      enter: function() {
        console.log("STATE =>", _, arguments);
      },

      update: function() {
        console.log("STATE (.)", _, arguments);
      },

      exit: function() {
        console.log("STATE <=", _, arguments);
      }

    });

  };

  return _debug;
}
606333
function post(argv, callback) {
  if (!argv[2]) {
    console.error("url is required");
    console.error("Usage : post <url> <data>");
    process.exit(-1);
  }
  if (!argv[3]) {
    console.error("data is required");
    console.error("Usage : post <url> <data>");
    process.exit(-1);
  }
  util.post(argv[2], argv[3], function(err, val) {
    if (!err) {
      callback(null, argv[2]);
    } else {
      callback(err);
    }
  });
}
1066166
function() {
        if (
            Crafty.loggingEnabled &&
            (typeof window !== "undefined" ? window.console : console) &&
            console.log
        ) {
            console.log.apply(console, arguments);
        }
    }
566559
function log(message) {
  if (message instanceof Error) {
    console.log(message.stack);
  }

  if (CONFIG.debug) {
    if (typeof message === "object") {
      console.log(JSON.stringify(message, null, 2));
    } else {
      console.log(message);
    }
  }
}
957691
function log (message) {
  if (!global.testing && !global.isModuleUse) {
    console.log(message)
  } else {
    debug(message)
  }
}
558840
function xhr (url, options, callback) {
  if (typeof options === 'function') {
    callback = options
    options = null
  }
  const o = options || {}
  const req = new XMLHttpRequest()
  const method = o.method || 'get'
  const params = o.data || null

  req.queryString = params
  req.open(method, url, true)
  req.setRequestHeader('X-Requested-With', 'XMLHttpRequest')

  if (method.toLowerCase() === 'post') {
    req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
  }

  for (let key in o.headers) {
    if (o.headers.hasOwnProperty(key)) {
      req.setRequestHeader(key, o.headers[key])
    }
  }

  function stateChange () {
    if (req.readyState === 4) {
      if ((/^[20]/).test(req.status)) {
        callback(null, req.responseText)
      } else if ((/^[45]/).test(req.status)) {
        callback(new Error(req.status))
      }
    }
  }

  req.onreadystatechange = stateChange

  try {
    req.send(params)
  } catch (e) {
    // eslint-disable-next-line no-console
    console.log('Error: Resolving URL ' + url)
    callback(e)
  }
}
581701
function(serverUrl) {
  var parsedUrl = url.parse(serverUrl);
  if (!parsedUrl.hostname) {
    throw new Error('Invalid server URL: ' + serverUrl);
  }

  /**
   * Base options for each request.
   * @private {!Object}
   */
  this.options_ = {
    host: parsedUrl.hostname,
    path: parsedUrl.pathname,
    port: parsedUrl.port
  };
}