docs: function Blind(options) {
    options = options || {};
  
    if (!(this instanceof Blind)) {
      return new Blind(options);
    }
  
    // set and check binaryEncoding
  
    this.binaryEncoding = options.binaryEncoding || binaryEncodingDefault;
  
    if (validBinaryEncodings.indexOf(this.binaryEncoding) < 0) {
      throw new RangeError(binaryEncodingMessage);
    }
  
    // set and check encryptAlgorithm
  
    this.encryptAlgorithm = options.encryptAlgorithm || encryptAlgorithmDefault;
  
    if (validEncryptAlgorithms.indexOf(this.encryptAlgorithm) < 0) {
      throw new RangeError(encryptAlgorithmMessage);
    }
  
    // set and check encryptKey
  
    if (options.encryptKey) {
      if (!is.string(options.encryptKey) || !options.encryptKey.length) {
        throw new TypeError(encryptKeyMessage);
      }
  
      if (!is[this.binaryEncoding](options.encryptKey)) {
        throw new TypeError('Property \'encryptKey\' must be a ' + this.binaryEncoding + ' encoded binary value');
      }
  
      this.encryptKey = options.encryptKey;
    }
  
    // set and check hashAlgorithm
  
    this.hashAlgorithm = options.hashAlgorithm || hashAlgorithmDefault;
  
    if (validHashAlgorithms.indexOf(this.hashAlgorithm) < 0) {
      throw new RangeError(hashAlgorithmMessage);
    }
  
    // set and check hashRounds
  
    this.hashRounds = options.hashRounds || hashRoundsDefault;
  
    if (!is.number(this.hashRounds)) {
      throw new TypeError(hashRoundsMessage);
    }
  
    if (!is.int(this.hashRounds) || this.hashRounds < 1) {
      throw new RangeError(hashRoundsRangeMessage);
    }
  
    // set and check maxDataLength
  
    this.maxDataLength = options.maxDataLength || maxDataLengthDefault;
  
    if (!is.number(this.maxDataLength)) {
      throw new TypeError(maxDataLengthMessage);
    }
  
    if (!is.int(this.maxDataLength) || this.maxDataLength < 1) {
      throw new RangeError(maxDataLengthRangeMessage);
    }
  
    // set and check maxRandomLength
  
    this.maxRandomLength = options.maxRandomLength || maxRandomLengthDefault;
  
    if (!is.number(this.maxRandomLength)) {
      throw new TypeError(maxRandomLengthMessage);
    }
  
    if (!is.int(this.maxRandomLength) || this.maxRandomLength < minRandomLength + 1) {
      throw new RangeError(maxRandomLengthRangeMessage);
    }
  
    // set and check randomLength
  
    this.randomLength = options.randomLength || randomLengthDefault;
  
    if (!is.number(this.randomLength)) {
      throw new TypeError(randomLengthMessage);
    }
  
    if (!is.int(this.randomLength) || !is.within(this.randomLength, minRandomLength, this.maxRandomLength)) {
      throw new RangeError('Property \'randomLength\' must be an integer between ' + minRandomLength + ' and ' + this.maxRandomLength);
    }
  
    // set skipChecks
  
    this.skipChecks = options.skipChecks || skipChecksDefault;
  }