Constructs an EOFError.

@class Represents an error caused by reaching the end-of-file (or, more
generally, end-of-input).
@constructor
@param {string=} message Human-readable description of the error.
503675
function EOFError(message) {
  // Like http://www.ecma-international.org/ecma-262/6.0/#sec-error-message
  if (!(this instanceof EOFError)) { return new EOFError(message); }
  Error.captureStackTrace(this, EOFError);
  if (message !== undefined) {
    Object.defineProperty(this, 'message', {
      value: String(message),
      configurable: true,
      writable: true
    });
  }
}
1301320
function(err) {
    notify.onError({
        title: "Error: " + err.plugin,
        subtitle: "<%= file.relative %>",
        message: "<%= error.message %>",
        sound: "Beep",
    })(err);
    console.log(err.toString())
    this.emit('end');
}
497972
function JFP_Error(message) {
    Error.call(this, message);

    Object.defineProperty(this, "name", {
        value: this.constructor.name
    });

    Object.defineProperty(this, "message", {
        value: message
    });

    if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
    } else {
        Object.defineProperty(this, "stack", {
            value: (new Error()).stack
        });
    }
}
795522
function error (err, file, name, options) {
  var message = err.message
  var column = err.column
  var line = err.line
  var type = err.name
  var method = 'message'

  if (options.throws) {
    method = 'fail'
  }

  file[method](
    message,
    { line: line, column: column },
    'parseFrontMatter:' + name + ':' + type
  )
}
1260815
function NotFoundError(message) {
  Error.call(this);
  Error.captureStackTrace(this, this.constructor);

  this.status = 404;
  this.message = 'Not Found: ' + message;
  this.name = this.constructor.name;
}
127742
function BaseError(message, context) {
        this.message = message;
        this.name = this.constructor.name;
        this.context = context || {};

        Error.captureStackTrace(this, BaseError);
    }
1033276
public static void reportError(String message)
    {
        int[] linep = { 0 };
        String filename = getSourcePositionFromStack(linep);
        Context.reportError(message, filename, linep[0], null, 0);
    }
950011
function(message, index) {
			var error = new Error(message + ' at character ' + index);
			error.index = index;
			error.description = message;
			throw error;
		}
1277980
function(message, originalError) {
  var stack;
  this.message = message;
  this.originalError = originalError;

  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, this.constructor);
    stack = this.stack;
  } else {
    stack = new Error(message).stack;
  }

  if (Object.defineProperty) {
    Object.defineProperty(this, "stack", {
      configurable: true, // required for Bluebird long stack traces
      get: function() {
        if (this.originalError) {
          return stack + "\nCaused by:  " + this.originalError.stack;
        }

        return stack;
      },
      set: function(value) {
        stack = value;
      }
    });
  }
}
1335272
function (message) {
    var objs = [], collector = '', chr, msglen, data;

    this.data += message;
    data = new Buffer(this.data, 'utf8');

    for (var i = 0; i < data.length; i += 1) {
        chr = data[i];
        if (chr > 47 && chr < 58) {
            collector += String.fromCharCode(chr);
        } else if (chr !== 10 && chr !== 13) {
            msglen = parseInt(collector, 10);

            if (msglen + i <= data.length) {
              objs.push(JSON.parse(data.toString('utf8', i, msglen + i)));
              data = data.slice(i + msglen);
              collector = '';
              i = 0;
            } else {
              break;
            }
        }
    }
    this.data = data.toString('utf8');
    return objs;
}
1113172
function setMessage (msg) {
  if (msg && typeof msg === 'string') {
    this.message = msg
  } else if (this.constructor.name !== 'CustomError') {
    this.message = this.constructor.DEFAULT_ERROR_MESSAGE
  } else {
    this.message = undefined
  }
}
1072848
function parseSafeMessage(message, status) {
  if (typeof message === 'object') {
    return {status: message.errorCode, message: message.description};
  } else {
    return {status: status, message: message};
  }
}
1092072
function(message) {
    if (!_.isObject(message)) {
      message = {
        message: message
      };
    }

    try {
      message = JSON.stringify(_.defaultsDeep({}, message, this.config.defaultProps));
    } catch (e) {
      return this.logger.error('Logmatic - error while parsing log message. Not sending', e);
    }

    if (this.isConnected) {
      this.sendMessage(message);
    } else {
      this.messageBuffer.push(message);
    }
  }
838563
function PersistentError(message, cause) {
  if (Object.prototype.hasOwnProperty.call(Error, 'captureStackTrace')) {
    Error.captureStackTrace(this, this.constructor);
  } else {
    /**
     * The error stack trace
     * @type {string}
     */
    this.stack = (new Error()).stack;
  }

  /**
   * The error message
   * @type {string}
   */
  this.message = (message || 'An unexpected persistent error occured.');

  /**
   * The name of the error
   * @type {string}
   */
  this.name = this.constructor.name;

  if (cause) {
    /**
     * The error cause
     * @type {Error}
     */
    this.cause = cause;
    if (cause.stack) {
      this.stack += '\nCaused By: ' + cause.stack;
    }
  }
}
424326
function ComponentCreateError(message) {
  Error.call(this);
  Error.captureStackTrace(this, arguments.callee);
  this.message = message;
  this.code = 'COMPONENT_CREATE_ERROR';
}
1344163
function error (message) {
  console.log(chalk.bgRed.white('[Error]' + message))
  throw new Error(message)
}
113221
function createError(message, optInterval) {
  var e;
  if (optInterval) {
    e = new Error(optInterval.getLineAndColumnMessage() + message);
    e.shortMessage = message;
    e.interval = optInterval;
  } else {
    e = new Error(message);
  }
  return e;
}