text: // FIXME: Kind of a weird way to throw exceptions, consider removing
  var assert = require('assert')
  var BigInteger = require('./bigi')
  
  /**
   * Turns a byte array into a big integer.
   *
   * This function will interpret a byte array as a big integer in big
   * endian notation.
   */
  BigInteger.fromByteArrayUnsigned = function(byteArray) {
    // BigInteger expects a DER integer conformant byte array
    if (byteArray[0] & 0x80) {
      return new BigInteger([0].concat(byteArray))
    }
  
    return new BigInteger(byteArray)
  }
  
  /**
   * Returns a byte array representation of the big integer.
   *
   * This returns the absolute of the contained value in big endian
   * form. A value of zero results in an empty array.
   */
  BigInteger.prototype.toByteArrayUnsigned = function() {
    var byteArray = this.toByteArray()
    return byteArray[0] === 0 ? byteArray.slice(1) : byteArray
  }
  
  BigInteger.fromDERInteger = function(byteArray) {
    return new BigInteger(byteArray)
  }
  
  /*
   * Converts BigInteger to a DER integer representation.
   *
   * The format for this value uses the most significant bit as a sign
   * bit.  If the most significant bit is already set and the integer is
   * positive, a 0x00 is prepended.
   *
   * Examples:
   *
   *      0 =>     0x00
   *      1 =>     0x01
   *     -1 =>     0xff
   *    127 =>     0x7f
   *   -127 =>     0x81
   *    128 =>   0x0080
   *   -128 =>     0x80
   *    255 =>   0x00ff
   *   -255 =>   0xff01
   *  16300 =>   0x3fac
   * -16300 =>   0xc054
   *  62300 => 0x00f35c
   * -62300 => 0xff0ca4
  */
  BigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray
  
  BigInteger.fromBuffer = function(buffer) {
    // BigInteger expects a DER integer conformant byte array
    if (buffer[0] & 0x80) {
      var byteArray = Array.prototype.slice.call(buffer)
  
      return new BigInteger([0].concat(byteArray))
    }
  
    return new BigInteger(buffer)
  }
  
  BigInteger.fromHex = function(hex) {
    if (hex === '') return BigInteger.ZERO
  
    assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')
    assert.equal(hex.length % 2, 0, 'Incomplete hex')
    return new BigInteger(hex, 16)
  }
  
  BigInteger.prototype.toBuffer = function(size) {
    var byteArray = this.toByteArrayUnsigned()
    var zeros = []
  
    var padding = size - byteArray.length
    while (zeros.length < padding) zeros.push(0)
  
    return new Buffer(zeros.concat(byteArray))
  }
  
  BigInteger.prototype.toHex = function(size) {
    return this.toBuffer(size).toString('hex')
  }
  