Function releaseWritingBuf

lib/internal/streams/fast-utf8-stream.js:878–904

* Release the writingBuf after fs.write n bytes data * @param {string | Buffer} writingBuf - currently writing buffer, usually be instance._writingBuf. * @param {number} len - currently buffer length, usually be instance._len. * @param {number} n - number of bytes fs already written * @returns {

(writingBuf, len, n)

 * @returns {{writingBuf: string | Buffer, len: number}} released writingBuf and length
 */
function releaseWritingBuf(writingBuf, len, n) {
  if (typeof writingBuf === 'string') {
    const byteLength = Buffer.byteLength(writingBuf);
    // `fs.write` returns the number of bytes written, but `len` is tracked in
    // characters and `writingBuf` is sliced by character index below, so `n`
    // must be converted from bytes to characters in both cases.
    if (byteLength === n) {
      // The whole string was written: advance past every character.
      n = writingBuf.length;
    } else {
      // A partial write may split a multi-byte UTF-8 character, so we must back
      // up to the start of that character to avoid data corruption.
      const buf = Buffer.from(writingBuf);
      // Back up from position n to find a valid UTF-8 character boundary.
      // UTF-8 continuation bytes have the pattern 10xxxxxx (0x80-0xBF).
      // We need to find the start of the character that was split.
      while (n > 0 && (buf[n] & 0xC0) === 0x80) {
        n--;
      }
      // Decode the properly-aligned bytes to get the character count.
      n = buf.subarray(0, n).toString().length;
    }
  }
  len = MathMax(len - n, 0);
  writingBuf = writingBuf.slice(n);
  return { writingBuf, len };
}

function mergeBuf(bufs, len) {
  if (bufs.length === 0) {