docs: function doHumanization (ms, options) {
      var i, len, piece
  
      // Make sure we have a positive number.
      // Has the nice sideffect of turning Number objects into primitives.
      ms = Math.abs(ms)
  
      var dictionary = options.languages[options.language] || languages[options.language]
      if (!dictionary) {
        throw new Error('No language ' + dictionary + '.')
      }
  
      var pieces = []
  
      // Start at the top and keep removing units, bit by bit.
      var unitName, unitMS, unitCount
      for (i = 0, len = options.units.length; i < len; i++) {
        unitName = options.units[i]
        unitMS = options.unitMeasures[unitName]
  
        // What's the number of full units we can fit?
        if (i + 1 === len) {
          unitCount = ms / unitMS
        } else {
          unitCount = Math.floor(ms / unitMS)
        }
  
        // Add the string.
        pieces.push({
          unitCount: unitCount,
          unitName: unitName
        })
  
        // Remove what we just figured out.
        ms -= unitCount * unitMS
      }
  
      var firstOccupiedUnitIndex = 0
      for (i = 0; i < pieces.length; i++) {
        if (pieces[i].unitCount) {
          firstOccupiedUnitIndex = i
          break
        }
      }
  
      if (options.round) {
        var ratioToLargerUnit, previousPiece
        for (i = pieces.length - 1; i >= 0; i--) {
          piece = pieces[i]
          piece.unitCount = Math.round(piece.unitCount)
  
          if (i === 0) { break }
  
          previousPiece = pieces[i - 1]
  
          ratioToLargerUnit = options.unitMeasures[previousPiece.unitName] / options.unitMeasures[piece.unitName]
          if ((piece.unitCount % ratioToLargerUnit) === 0 || (options.largest && ((options.largest - 1) < (i - firstOccupiedUnitIndex)))) {
            previousPiece.unitCount += piece.unitCount / ratioToLargerUnit
            piece.unitCount = 0
          }
        }
      }
  
      var result = []
      for (i = 0, pieces.length; i < len; i++) {
        piece = pieces[i]
        if (piece.unitCount) {
          result.push(render(piece.unitCount, piece.unitName, dictionary, options))
        }
  
        if (result.length === options.largest) { break }
      }
  
      if (result.length) {
        if (!options.conjunction || result.length === 1) {
          return result.join(options.delimiter)
        } else if (result.length === 2) {
          return result.join(options.conjunction)
        } else if (result.length > 2) {
          return result.slice(0, -1).join(options.delimiter) + (options.serialComma ? ',' : '') + options.conjunction + result.slice(-1)
        }
      } else {
        return render(0, options.units[options.units.length - 1], dictionary, options)
      }
    }