How to use the buffer.Buffer.prototype function in buffer

function zlibBuffer(engine, buffer, callback) {
  // Streams do not support non-Buffer ArrayBufferViews yet. Convert it to a
  // Buffer without copying.
  if (ArrayBuffer.isView(buffer) &&
      Object.getPrototypeOf(buffer) !== Buffer.prototype) {
    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
  }

  var buffers = [];
  var nread = 0;

  engine.on('error', onError);
  engine.on('end', onEnd);

  engine.end(buffer);
  flow();

  function flow() {
    var chunk;
    while (null !== (chunk = engine.read())) {
      buffers.push(chunk);

function zlibBuffer(engine, buffer, callback) {
  if (typeof callback !== 'function')
    throw new ERR_INVALID_ARG_TYPE('callback', 'function', callback);
  // Streams do not support non-Buffer ArrayBufferViews yet. Convert it to a
  // Buffer without copying.
  if (isArrayBufferView(buffer) &&
      Object.getPrototypeOf(buffer) !== Buffer.prototype) {
    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
  } else if (isAnyArrayBuffer(buffer)) {
    buffer = Buffer.from(buffer);
  }
  engine.buffers = null;
  engine.nread = 0;
  engine.cb = callback;
  engine.on('data', zlibBufferOnData);
  engine.on('error', zlibBufferOnError);
  engine.on('end', zlibBufferOnEnd);
  engine.end(buffer);
}

*/

var Buffer = require('buffer').Buffer,
    enums = require('../spdy').enums;

/**
 * Compatibility with older versions of node
 */
if (!Buffer.prototype.writeUInt32BE) {
  Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'big');
  };
  Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'little');
  };
  Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
    this.writeUInt16(value, offset, 'big');
  };
}

/**
 * Create and return dataframe buffer
 */
exports.createDataFrame = function(zlib, headers, data) {
  if (headers.flags & enums.DATA_FLAG_COMPRESSED) {
    data = zlib.deflate(data);
  }

  var result = insertCommonData(headers, data, result);

  // Insert stream id
  result.writeUInt32BE(headers.streamID & 0x7fffffff, 0);

function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
  debug('readableAddChunk', chunk);
  var state = stream._readableState;

  if (chunk === null) {
    state.reading = false;
    onEofChunk(stream, state);
  } else {
    var er;
    if (!skipChunkCheck) er = chunkInvalid(state, chunk);

    if (er) {
      stream.emit('error', er);
    } else if (state.objectMode || chunk && chunk.length > 0) {
      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
        chunk = _uint8ArrayToBuffer(chunk);
      }

      if (addToFront) {
        if (state.endEmitted) stream.emit('error', new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
      } else if (state.ended) {
        stream.emit('error', new ERR_STREAM_PUSH_AFTER_EOF());
      } else if (state.destroyed) {
        return false;
      } else {
        state.reading = false;

        if (state.decoder && !encoding) {
          chunk = state.decoder.write(chunk);
          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
        } else {

/**
 * Protocol classes
 */

var Buffer = require('buffer').Buffer,
    enums = require('../spdy').enums;

/**
 * Compatibility with older versions of node
 */
if (!Buffer.prototype.writeUInt32BE) {
  Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'big');
  };
  Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'little');
  };
  Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
    this.writeUInt16(value, offset, 'big');
  };
}

/**
 * Create and return dataframe buffer
 */
exports.createDataFrame = function(zlib, headers, data) {
  if (headers.flags & enums.DATA_FLAG_COMPRESSED) {

/**
 * Protocol classes
 */

var Buffer = require('buffer').Buffer,
    enums = require('../spdy').enums;

/**
 * Compatibility with older versions of node
 */
if (!Buffer.prototype.writeUInt32BE) {
  Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'big');
  };
  Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'little');
  };
  Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
    this.writeUInt16(value, offset, 'big');
  };
}

/**
 * Create and return dataframe buffer
 */
exports.createDataFrame = function(zlib, headers, data) {
  if (headers.flags & enums.DATA_FLAG_COMPRESSED) {
    data = zlib.deflate(data);
  }

  var result = insertCommonData(headers, data, result);

import { Buffer } from "buffer"

import binding from "../binding.js"

const bufferToString = Buffer.prototype.toString
const utilBinding = binding.util

const _String = String
const _safeToString = utilBinding.safeToString

const useSafeToString = typeof safeToString === "function"

function safeToString(value) {
  if (useSafeToString) {
    try {
      return _safeToString.call(utilBinding, value)
    } catch (e) {}
  }

  return _String(value)
}

Stream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {
      return Buffer.prototype.slice.call(chunk);
    };
  }

/**
 * Protocol classes
 */

var Buffer = require('buffer').Buffer,
    enums = require('../spdy').enums;

/**
 * Compatibility with older versions of node
 */
if (!Buffer.prototype.writeUInt32BE) {
  Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'big');
  };
  Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
    this.writeUInt32(value, offset, 'little');
  };
  Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
    this.writeUInt16(value, offset, 'big');
  };
}

/**
 * Create and return dataframe buffer
 */
exports.createDataFrame = function(zlib, headers, data) {
  if (headers.flags & enums.DATA_FLAG_COMPRESSED) {
    data = zlib.deflate(data);

static MockBuffer() {
    const noop = function() {};
    const res = Buffer.alloc(0);
    for (const op in NativeBuffer.prototype) {
      if (typeof res[op] === 'function') {
        res[op] = noop;
      }
    }
    return res;
  }
}