/* LicencedError
5123
function LicencedError(mangaSite, mangaName) {
    var instance = new Error(mangaSite + " has '" + mangaName + "' licenced.");
    instance.mangaSite = mangaSite;
    instance.mangaName = mangaName;
    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
    if (Error.captureStackTrace) {
        Error.captureStackTrace(instance, LicencedError);
    }
    return instance;
}
304801
function RemoteError(error) {
    /**
     * @member {string} message A message detailing the error.
     * @memberof module:rodosha/messages~RemoteError
     * @instance
     */
    var message = error.message || "Unknown error";
    var name = "RemoteError" + (error.name ? ("[" + error.name + "]") : "");
    Error.call(message);

    /* Inject properties */
    this.message = message;
    this.name = name;
    this.toString = function() {
      return name + ": " + message;
    }

    /**
     * @member {string} stack The stack trace associated with this instance,
     *                        combining both local and remote details.
     * @memberof module:rodosha/messages~RemoteError
     * @instance
     */
    var localStack = this.stack || new Error().stack;
    if (localStack) localStack = localStack.replace(/^(Remote)?Error\n/, '');

    if ((error.stack) || (localStack)) {
      var stack = this.toString();
      if (error.stack) stack += "\n- Remote stack:\n" + error.stack;
      if (localStack)  stack += "\n- Local stack:\n"  + localStack;
      this.stack = stack;
    }

  }
863947
function SigningError(cause) {
    this.code = 'SigningError';
    assert.optionalObject(cause);
    var msg = 'error signing request';
    var args = (cause ? [cause, msg] : [msg]);
    WError.apply(this, args);
}
469848
function SpotifyError (err) {
  this.domain = err[0] || 0;
  this.code = err[1] || 0;
  this.description = err[2] || '';
  this.data = err[3] || null;

  // Error impl
  this.name = domains[this.domain];
  var msg = codes[this.code];
  if (this.description) msg += ' (' + this.description + ')';
  this.message = msg;
  Error.captureStackTrace(this, SpotifyError);
}
602892
function error() {

                        this.httpRequest.upload.onerror = function onError() {

                            $scope.$apply(function apply() {

                                $scope.finishedUploading();
                                $scope.isError = true;

                                var response = $scope.options.parserFn(this.httpRequest.responseText);
                                $rootScope.$broadcast('$dropletError', response);
                                $scope.onError({ response: response });
                                this.deferred.reject(response);

                            }.bind(this));

                        }.bind(this);

                    }
51640
function licenses(data) {
    if ('string' === typeof data && data) return data;
    if ('type' in data && data.type) return data.type;

    //
    // Common typo's
    //
    if ('type:' in data && data['type:']) return data['type:'];

    return;
  }
1110399
function printError() {
  var _log = [new Date().toGMTString().concat(' jailed:sandbox')].concat([].slice.call(arguments))
  console.error.apply(null, _log)
}
721018
public void showLicenseFile(InputStream licenseFile) {
        Object e = SelfExtract.class;
        if (licenseFile != null) {
            e = SelfExtractUtils.showLicenseFile(licenseFile);
        }
        if (e != null) {
            SelfExtract.err("licenseNotFound");
            System.exit(ReturnCode.UNREADABLE);
        }
    }
810480
def create
      @script_licence = Script::Licence.new(script_licence_params)
      @script_licence.user_id = current_user.id
      @script_licence.org_id = current_user.org_id
      if @script_licence.save
        redirect_to script_licences_url, notice: 'Licence was successfully created.'
        else
        render :new
      end
    end
1252188
function isPermissible(dependency) {
        const licenses = dependency.licenses;

        if (Array.isArray(licenses)) {
            return licenses.some(license => isPermissible({
                name: dependency.name,
                licenses: license
            }));
        }

        return OPEN_SOURCE_LICENSES.some(license => license.test(licenses));
    }
350401
function () {
        var pkg = require(process.cwd() + '/package.json');
        var licenses = [];
        pkg.licenses.forEach(function (license) {
            licenses.push(license.type);
        });

        return '/*! ' + pkg.name + ' - v' + pkg.version + ' - ' + gutil.date("yyyy-mm-dd") + "\n" +
            (pkg.homepage ? "* " + pkg.homepage + "\n" : "") +
            '* Copyright (c) ' + gutil.date("yyyy") + ' ' + pkg.author.name +
            '; Licensed ' + licenses.join(', ') + ' */\n';
    }
1178983
def domain_error!(first, *args)
      first = [first]+args unless args.empty?
      raise TypeError, "Can't convert `#{first.inspect}` into #{self}", caller
    end
735452
function OAuth2Error(message, code, uri, status) {
  Error.call(this);
  this.message = message;
  this.code = code || 'server_error';
  this.uri = uri;
  this.status = status || 500;
}
444833
function createLicenseText( licenses ) {
   if( licenses.length === 0 ) {
      return [ {
         licenseLabel: 'private',
         licenses: true,
         licenseText: ''
      }, 'none' ];
   }
   else if( licenses.length === 1 ) {
      return [ {
         licenseLabel: 'license',
         licenses: '"' + licenses[ 0 ] + '"',
         licenseText: licenses[ 0 ] + ' license'
      }, licenses ];
   }
   else {
      return [ {
         licenseLabel: 'license',
         licenses: '[ \"' + licenses.join( '\", \"' ) + '\" ]',
         licenseText: licenses.join( ', ' ) + ' licenses'
      }, licenses ];
   }
}
971928
function FileMakerServerError(code, url) {
  this.url = url;
  this.error = code;
  this.message = getMessge(code);
  this.name = 'FileMakerServerError';
  console.log('FileMaker Error Code: ',error);
  const err = Error(this.message); // http://es5.github.io/#x15.11.1
  this.stack = err.stack;
  this.isTransient = isTransient(code);
}
942453
function errorBadCredentials(res) {
  var err = new Error('Invalid credentials');
  err.res = res;
  err.remote = 'github-content-api';
  throw err;
}
515767
function _buildErrorCode (cartoError, key) {
  var fragments = [];
  fragments.push(cartoError && cartoError.origin);
  fragments.push(cartoError && cartoError.type);
  fragments.push(key);
  fragments = _.compact(fragments);

  return fragments.join(':');
}