How to use the stream-throttle.Throttle function in stream-throttle

handle(req, res) {
			const image = fs.createReadStream(__dirname + "/test.png");
			image.pipe(new Throttle({rate: 100})).pipe(res);
		}
	}

function getFileStream(opts = {}) {
  return fs.createReadStream(`${__dirname}/static/test.wav`, opts)
    .pipe(new Throttle({ rate: opts.rate }));
}

let toSend = content;

      if (contentOffset) {
        toSend = toSend.slice(contentOffset % toSend.length);
        contentOffset = 0;
      }

      if (toSend.length > bytesToSend) {
        toSend = toSend.slice(0, bytesToSend);
      }

      bytesToSend -= toSend.length;

      this.push(toSend);
    }
  }).pipe(new Throttle({ rate })).pipe(res);
});

wss.on('connection', function(socket){


  console.log('New guy');

  var readStream = fs.createReadStream(source);

    //throttle for real time simulation
  readStream = readStream.pipe(new Throttle({rate: sourceThrottleRate}));

    var separator = new Buffer([0,0,0,1]);//NAL break
  readStream = readStream.pipe(new Splitter(separator));

  readStream.pause();


  socket.send(JSON.stringify({action : "init", width: width, height : height}));

  socket.on("message", function(data){
    var cmd = "" + data, action = data.split(' ')[0];
    if(action == "REQUESTSTREAM")
      readStream.resume();
    if(action == "STOPSTREAM")
      readStream.pause();
    console.log("Incomming data", data);

function tryGettingObject(cb) {
    if (isAborted) return;

    const fileStream = fs.createWriteStream(localFile, {
      flags: 'w+',
      autoClose: true
    });

    const params = {
      Bucket: s3params.Bucket,
      Key: s3params.Key,
    };

    s3downloader = self.s3.getObject(params).createReadStream();
    if (self.downloadSpeedLimit) {
      s3downloader = s3downloader.pipe(new Throttle({rate: self.downloadSpeedLimit * 1024}));
    }
    s3downloader.on('data', (chunk) => {
      if (isAborted) return;

      downloader.progressLoaded += chunk.length;
      downloader.emit('progress', downloader);
    });
    s3downloader.on('end', () => {
      if (isAborted) return;

      if (downloader.progressTotal != downloader.progressLoaded) {
        cb(new Error(`ContentLength mismatch, got ${downloader.progressLoaded}, expected ${downloader.progressTotal}`));
        return;
      }

      downloader.emit('progress', downloader);

function playVideo(info) {
  const video = info.formats.filter(format => format.resolution === '144p' && format.audioBitrate === null).sort((a, b) => a.container === 'webm' ? -1 : 1)[0];
  const m = video.size.match(/^(\d+)x(\d+)$/);
  const videoSize = { width: m[1], height: m[2] };
  const frameHeight = Math.round(canvas._height * 2);
  const frameWidth = Math.round(frameHeight * (videoSize.width / videoSize.height));
  const frameSize = frameWidth * frameHeight * 3;

  ffmpeg.rawImageStream(video.url, { fps: 30, width: frameWidth })
    .on('start', () => canvas.saveScreen().reset())
    .on('end', () => canvas.restoreScreen())
    .pipe(new Throttle({ rate: frameSize * 30 }))
    .pipe(new RawImageStream(frameSize))
    .on('data', function (frameData) {
      const ascii = imageToAscii(frameData, frameWidth, frameHeight);

      for (let y = 0; y < frameHeight; y++) {
        for (let x = 0; x < frameWidth; x++) {
          canvas
            .moveTo(x + (canvas._width / 2 - frameWidth / 2), y)
            .write(ascii[y * frameWidth + x] || '');
        }
      }

      canvas.flush();
    });
}

function throttleStream(stream, rate) {
    stream.pipe(new Throttle({ rate: rate }))
    return stream
}

function Throttle (maxRate) {
  var inputRate = maxRate || 1024 * 1024 * 100
  var chunkSize = inputRate / 10
  if (chunkSize < 1) {
    chunkSize = 1
  }
  return new StreamThrottle({
    chunksize: chunkSize,
    rate: inputRate || 1024 * 1024 * 100
  })
}