### function solenoidError(display) Displays a "solenoid" error.
963746
function solenoidError(display) {
    jitsu.log.error('Error starting application. This could be a user error.');
    display.solenoid.split('\n').forEach(function (line) {
      jitsu.log.error(line);
    });
  }
922597
function ErroneousError(e, additional) {
    additional = additional || {};
    this.line = e.lineno || e.lineNumber || additional.lineno;
    this.file = e.filename || e.fileName || additional.filename;
    this.msg = e.message || additional.message;
    this.time = e.timestamp || additional.timestamp || Date.now();
    this.type = (this.parseMessage(this.msg) || e.type || e.name).toLowerCase();

    // If it's a DOM node, let's figure out which
    if (e.target) {
      this.target = this.getTargetIdentifier(e.target);

      if (e.target.nodeName) {
        this.type = 'resource';
        if (e.target.href) {
          this.file = e.target.href;
        } else if (e.target.src) {
          this.file = e.target.src;
        }
      }
    }

    // Parse the stack if any
    this.stack = e.stack;
    this.parseStack(e.stack);
  }
480761
function formatError(error) {
        function localize(key) {
            if (Strings[key]) {
                return Strings[key];
            }
            console.log("Unknown installation error", key);
            return Strings.UNKNOWN_ERROR;
        }

        if (Array.isArray(error)) {
            error[0] = localize(error[0]);
            return StringUtils.format.apply(window, error);
        } else {
            return localize(error);
        }
    }
1338866
public function errorf()
    {
        $args = func_get_args();
        $format = array_shift($args);
        $this->error(vsprintf($format, $args));
    }
923560
function onError( error ) {
        logger.error( error.stack || error );
        process.exit( EXIT_FAILURE );
    }
996223
function DriverOperationError(code,description) {
    this.code = code;
    this.description = description;
    console.log('in DriverOperationError',code,description);
}
1248544
function _onError (err) {
  if (err.status === 404 || err.statusCode === 404 || err.expose) return

  let msg = err.stack || err.toString()

  console.error(`\n${msg.replace(/^/gm, '   ')}\n`)
}
1354709
function printLintSummary(
  label: string,
  errors: number,
  warnings: number,
): void {
  const text = ` ${label}: ${errors} errors, ${warnings} warnings `

  let coloredText

  if (errors) {
    coloredText = chalk.white(chalk.bgRed(text))
  } else if (warnings) {
    coloredText = chalk.bgYellow(text)
  } else {
    coloredText = chalk.bgGreen(text)
  }

  const boldColoredText = chalk.bold(coloredText)

  console.log(`${boldColoredText}\n`)
}
558737
function _gpfErrorDeclare (source, dictionary) {
    _gpfIgnore(source);
    _gpfObjectForEach(dictionary, function (message, name) {
        var code = ++_gpfLastErrorCode;
        gpf.Error["CODE_" + name.toUpperCase()] = code;
        gpf.Error[name] = _gpfGenenerateErrorFunction(code, name, message);
    });
}
645606
function error () {
  if (mocking) {
    cli.stderr += stripAnsi(concatArguments(arguments) + '\n')
  } else {
    console.error.apply(null, arguments)
  }
}
1217212
function( el, error ) {
        // We want display errors ?
        if ( !this.options.showErrorMessages ) {
          // because of form not valid, set handler true for break submit
          this.handler = true;
          return;
        }
        var elParent = this.parents( el );
        // If the parent element undefined, that means el is an object. So we need to transform to the element
        if( typeof elParent === 'undefined' ) elParent = el[0].parentNode;
        // if there is an error window which previously opened for el, return
        if ( elParent.querySelectorAll( '.'+ this.options.errorTemplateClass ).length ) return;
        // Create the error window object which will be appear
        var errorObject = document.createElement('span');
        errorObject.className = this.options.errorTemplateClass + ' '+this.options.errorTemplateClass + '--' + this.options.bubblePosition;
        // if error display is bubble, calculate to positions
        if( this.options.display === 'bubble' ) {
          var pos, W = 0, H = 0;
          // !! Here, JQuery functions are using to support the IE8
          pos = $( el ).position();

          if ( this.options.bubblePosition === 'bottom' ){
            H = el.offsetHeight;
          }
          else {
            W = el.offsetWidth;
          }
          errorObject.innerHTML = '';
          errorObject.style.top = pos.top + H + this.options.bubbleGapTop +'px';
          errorObject.style.left = pos.left + W + this.options.bubbleGapLeft +'px'
        }
        elParent.appendChild( errorObject );
        errorObject.innerHTML = error ;

        // we have an error so we need to break submit
        // set to handler true
        this.handler = true;
      }
232575
function VError(options)
{
	var args, causedBy, ctor, tailmsg;

	if (options instanceof Error || typeof (options) === 'object') {
		args = Array.prototype.slice.call(arguments, 1);
	} else {
		args = Array.prototype.slice.call(arguments, 0);
		options = undefined;
	}

	tailmsg = args.length > 0 ?
	    mod_extsprintf.sprintf.apply(null, args) : '';
	this.jse_shortmsg = tailmsg;
	this.jse_summary = tailmsg;

	if (options) {
		causedBy = options.cause;

		if (!causedBy || !(options.cause instanceof Error))
			causedBy = options;

		if (causedBy && (causedBy instanceof Error)) {
			this.jse_cause = causedBy;
			this.jse_summary += ': ' + causedBy.message;
		}
	}

	this.message = this.jse_summary;
	Error.call(this, this.jse_summary);

	if (Error.captureStackTrace) {
		ctor = options ? options.constructorOpt : undefined;
		ctor = ctor || arguments.callee;
		Error.captureStackTrace(this, ctor);
	}
}
148306
function fatal (e, text) {
  console.error('ERROR processing input. Use --verbose flag to see output.')
  console.error(e.message)

  if (cli.flags.verbose) {
    console.error(text)
  }

  process.exit(1)
}
473333
function (force) {

/*Line 30 - 'AtomErrors.js' */                if (this.refreshing)
/*Line 31 - 'AtomErrors.js' */                    return this.errors;

/*Line 33 - 'AtomErrors.js' */                if (!force && this.errors)
/*Line 34 - 'AtomErrors.js' */                    return this.errors;

/*Line 36 - 'AtomErrors.js' */                var e = [];

/*Line 38 - 'AtomErrors.js' */                var v ;

/*Line 40 - 'AtomErrors.js' */                var ve = this.list.invalid;
/*Line 41 - 'AtomErrors.js' */                if (ve !== undefined) {
/*Line 42 - 'AtomErrors.js' */                    if (!ve) {
/*Line 43 - 'AtomErrors.js' */                        this.errors = e;
/*Line 44 - 'AtomErrors.js' */                        return e;
/*Line 45 - 'AtomErrors.js' */                    }
/*Line 46 - 'AtomErrors.js' */                    v = ve();
/*Line 47 - 'AtomErrors.js' */                    if (v) {
/*Line 48 - 'AtomErrors.js' */                        if ($.isArray(v)) {
/*Line 49 - 'AtomErrors.js' */                            e = e.concat(v);
/*Line 50 - 'AtomErrors.js' */                        } else {
/*Line 51 - 'AtomErrors.js' */                            e.push(v);
/*Line 52 - 'AtomErrors.js' */                        }
/*Line 53 - 'AtomErrors.js' */                    }
/*Line 54 - 'AtomErrors.js' */                    this.errors = e;
/*Line 55 - 'AtomErrors.js' */                    return e;
/*Line 56 - 'AtomErrors.js' */                }
/*Line 57 - 'AtomErrors.js' */                else {
/*Line 58 - 'AtomErrors.js' */                    for (var i in this.list) {
/*Line 59 - 'AtomErrors.js' */                        v = this.list[i];
/*Line 60 - 'AtomErrors.js' */                        if (!v) continue;
/*Line 61 - 'AtomErrors.js' */                        v = v();
/*Line 62 - 'AtomErrors.js' */                        if (v) {
/*Line 63 - 'AtomErrors.js' */                            if ($.isArray(v)) {
/*Line 64 - 'AtomErrors.js' */                                e = e.concat(v);
/*Line 65 - 'AtomErrors.js' */                            } else {
/*Line 66 - 'AtomErrors.js' */                                e.push(v);
/*Line 67 - 'AtomErrors.js' */                            }
/*Line 68 - 'AtomErrors.js' */                        }
/*Line 69 - 'AtomErrors.js' */                    }
/*Line 70 - 'AtomErrors.js' */                }
/*Line 71 - 'AtomErrors.js' */                if (e.length) {
/*Line 72 - 'AtomErrors.js' */                    this.errors = e;
/*Line 73 - 'AtomErrors.js' */                    return e;
/*Line 74 - 'AtomErrors.js' */                }
/*Line 75 - 'AtomErrors.js' */                return null;
/*Line 76 - 'AtomErrors.js' */            }
518424
public void displayError(String strError, int iWarningLevel)
    {
        if ((strError == null) || (strError.length() == 0))
            return;     // No error
        Task task = this.getTask();
        if (task != null)
            task.setStatusText(strError, iWarningLevel);
    }
912908
function WError(options)
{
	Error.call(this);

	var args, cause, ctor;
	if (typeof (options) === 'object') {
		args = Array.prototype.slice.call(arguments, 1);
	} else {
		args = Array.prototype.slice.call(arguments, 0);
		options = undefined;
	}

	if (args.length > 0) {
		this.message = mod_extsprintf.sprintf.apply(null, args);
	} else {
		this.message = '';
	}

	if (options) {
		if (options instanceof Error) {
			cause = options;
		} else {
			cause = options.cause;
			ctor = options.constructorOpt;
		}
	}

	Error.captureStackTrace(this, ctor || this.constructor);
	if (cause)
		this.cause(cause);

}
594363
function InvalidDerefInputError() {
    var instance = new Error("Deref can only be used with a non-primitive object from get, set, or call.");

    instance.name = "InvalidDerefInputError";

    if (Object.setPrototypeOf) {
        Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
    }

    if (Error.captureStackTrace) {
        Error.captureStackTrace(instance, InvalidDerefInputError);
    }

    return instance;
}