resolveRelatives() 
Outputs error messages using the specified output function.

@param {Array.<string>} errors the buffer for error messages
@param {function} fnOut the output function
767224
function outputErrors( errors, fnOut ) {
	if ( Array.isArray( errors ) && typeof fnOut === 'function' ) {
		errors.forEach( function( error ){
			fnOut( error );
		});
	} // if
}
668027
function(err) {
            Dialogs.alert("Error:", err.message || err);
            console.error(err.stack || err.message || err);
            return Q.reject(err);
        }
923560
function onError( error ) {
        logger.error( error.stack || error );
        process.exit( EXIT_FAILURE );
    }
242649
function noOp (error) {
    if (error == null) return
    error = pruneErrorStack(error)
    nextTick(function () {
      if (isFunction(thunks.onerror)) thunks.onerror(error)
      else throw error
    })
  }
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);

}
469579
private void printErrors(final List<String> filteredDoc,
      final List<String> filteredRefs, final List<String> filteredPreds) {
    this.printStream.println("Errors: {");
    this.printStream.println("Tok: Ref | Pred");
    this.printStream.println("---------------");
    for (int i = 0; i < filteredDoc.size(); i++) {
      this.printStream.println(filteredDoc.get(i) + ": " + filteredRefs.get(i)
          + " | " + filteredPreds.get(i));
    }
    this.printStream.println("}\n");
  }
638381
function(error) {
		if (this.resolved) {
			throw new Error('Future resolved more than once');
		} else if (!error) {
			throw new Error('Must throw non-empty error');
		}
		this.error = error;
		this.resolved = true;

		var callbacks = this.callbacks;
		if (callbacks) {
			delete this.callbacks;
			for (var ii = 0; ii < callbacks.length; ++ii) {
				try {
					var ref = callbacks[ii];
					if (ref[1]) {
						ref[0].throw(error);
					} else {
						ref[0](error);
					}
				} catch(ex) {
					// console.log('Resolve cb threw', String(ex.stack || ex.message || ex));
					process.nextTick(function() {
						throw(ex);
					});
				}
			}
		}
	}
494097
function onOutError(err) {
    errNodecat = combineErrors(errNodecat, err);
    errStream.write(`nodecat: ${err}\n`);
    if (inCleanup) {
      inCleanup();
    }
    allDone();
  }
808255
function errorEnhancement(inputMessage) {
  var message = inputMessage; // eslint-disable-line
  var outputMessage = null; // eslint-disable-line

  // if the input message is an array or object
  if (inputMessage !== null
    && !isNaN(inputMessage)
    && typeof inputMessage !== 'string') {
    message = JSON.stringify(inputMessage);
  }

  // gauentee string convertion, null and other..
  message = String(message);

  // if message includes
  if (message.includes('Compiled contract not found')) {
    outputMessage = 'This could be due to a contract with the same name being compiled. Wafr doesnt allow two contracts with the same name. Look to see if any of your contracts have the same name.';
  }

  // if message includes
  if (message.includes('invalid JUMP')) {
    outputMessage = `This can be caused by many things. One main cause is a 'throw' flag being used somewhere in execution.

    This can be caused by:

    1. A 'throw' flag being used somewhere in execution (a function your calling)
    2. Sending ether to a contract which does not have the 'payable' modifier on the fallback:
        function () payable {}
    3. A send or transaction was out of gas
    `;
  }

  // if message includes
  if (message.includes('invalid opcode') || message.includes('invalid op code')) {
    outputMessage = 'This can be caused by a contract which compiles fine, but doesnt execute properly in the Ethereum Virtual Machine. Such as using a `0x0` as an address.';
  }

  // if message includes
  if (message.includes('out of gas')) {
    outputMessage = `This error can be due to various scenarios:

    1. A error caused somewhere in your contract
    2. An error with the EVM module (npm: 'ethereumjs-vm')
    3. An error caused by the wafr module
    4. An error with the node simulation module (npm: 'ethereumjs-testrpc')
    5. A wafr account actually being out of gas
    6. The 'payable' flag not being used on a contract your sending ether too (common)

    If you cannot resolve this issue with reasonable investigation,
    report the error at:

    http://github.com/SilentCicero/wafr/issues

    If you believe the error is caused by the test node infrastructure,
    report the error at:

    http://github.com/ethereumjs/testrpc

    If you believe the error is caused by the EVM module, report the error
    at:

    http://github.com/ethereumjs/ethereumjs-vm
    `;
  }

  // return output message
  return outputMessage;
}
195178
function ErrorStackParser$$parseOpera11(error) {
	            var filtered = _filter(error.stack.split('\n'), function (line) {
	                return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) &&
	                    !line.match(/^Error created at/);
	            }, this);
	
	            return _map(filtered, function (line) {
	                var tokens = line.split('@');
	                var locationParts = this.extractLocation(tokens.pop());
	                var functionCall = (tokens.shift() || '');
	                var functionName = functionCall
	                        .replace(/<anonymous function(: (\w+))?>/, '$2')
	                        .replace(/\([^\)]*\)/g, '') || undefined;
	                var argsRaw;
	                if (functionCall.match(/\(([^\)]*)\)/)) {
	                    argsRaw = functionCall.replace(/^[^\(]+\(([^\)]*)\)$/, '$1');
	                }
	                var args = (argsRaw === undefined || argsRaw === '[arguments not available]') ? undefined : argsRaw.split(',');
	                return new StackFrame(functionName, args, locationParts[0], locationParts[1], locationParts[2], line);
	            }, this);
	        }
32061
function (error) {
        if (!this.started) {
            return;
        }

        var errorHandlers = this.errorHandlers,
            length = errorHandlers.length,
            errorHandler,
            errorHandled = false,
            errorString,
            i;

        //Exit handling
        if (error instanceof SystemExit) {
            this._exit(error.code);
            return;
        }

        try {
            for (i = 0; i < length; i += 1) {
                errorHandler = errorHandlers[i];
                errorHandled = !!errorHandler(error);

                if (errorHandled) {
                    return;
                }
            }
        } catch (e) {
            this._printError(e);
            this._exit(1);
        }

        //Default error handling
        errorString = '' + (error.stack || error);
        this._printError(errorString);
        this._exit(1);
    }
433436
function resolve(projections, projection) {
  if (_.isArray(projection)) {
    const net = {};

    for (const proj of projection) {
      _.merge(net, resolve(projections, proj));
    }

    return net;
  } else if (_.isObject(projection)) {
    return projection;
  } else if (_.isString(projection)) {
    const rslt = projections[projection];

    if (!rslt) {
      throw new Error(`No project named "${projection}"`);
    }

    return rslt;
  } else {
    throw new Error('invalid projection');
  }
}
753672
function () {
        var prefix = 'ERROR';
        this.output(prefix, prefix.red, Array.prototype.slice.call(arguments));
    }
637045
function AddError(message,nopush) {
  if (displayErrors) console.error(message);
  if (!nopush) errors.push(message);
}
807764
function onError(err) {
    const ctx = err.client.$ctx;
    npm.events.error(ctx.options, err, {
        cn: npm.utils.getSafeConnection(ctx.cn),
        dc: ctx.dc
    });
}
678158
function onError (err) {
      if (!responded) {
        errState = true;
        responded = true;
        callback(err);

        //
        // Remove listeners to related events.
        //
        drone.removeListener('exit', onExit);
        drone.removeListener('message', onCarapacePort);
        clearTimeout(timeout);
      }
    }
887001
function (msg, errors, scope) {
            scope.$logError.apply(scope, [msg + ":"]);
            for (var i = 0, len = errors.length; i < len; i++) {
                scope.$logError.apply(scope, [(i + 1) + " - " + errors[i].msgId, errors[i].msgArgs]);
            }
        }