How to use typedarray-to-buffer - 10 common examples

transform: async (chunk, controller) => {
          try {
            chunk = toBuffer(chunk);
          } catch (err) {
            console.error(err);
          }

          // Decrypt chunk and send it out
          const decryptedChunk = decipher.update(chunk);
          controller.enqueue(decryptedChunk);

          // Emit a progress update
          totalBytesRead += chunk.length;
          emitProgress(totalBytesRead, contentLength, url);
        },
      })

transform: async (chunk, controller) => {
          try {
            chunk = toBuffer(chunk);
          } catch (err) {
            console.error(err);
          }

          // Decrypt chunk and send it out
          const decryptedChunk = decipher.update(chunk);
          controller.enqueue(decryptedChunk);

          // Emit a progress update
          totalBytesRead += chunk.length;
          emitProgress(totalBytesRead, contentLength, url);
        },
      })

reader.read().then(({ done, value }) => {
          if (done) {
            controller.close();
            return;
          }

          const chunk = toBuffer(value);

          // Decrypt chunk
          const decValue = decipher.update(chunk);

          // Emit a progress update
          totalBytesRead += chunk.length;
          emitProgress(totalBytesRead, contentLength, url);

          controller.enqueue(decValue);
          push();
        });
      }

reader.read().then(({ done, value }) => {
          if (done) {
            controller.close();
            return;
          }

          const chunk = toBuffer(value);

          // Decrypt chunk
          const decValue = decipher.update(chunk);

          // Emit a progress update
          totalBytesRead += chunk.length;
          emitProgress('decrypt', totalBytesRead, contentLength, id);

          controller.enqueue(decValue);
          push();
        });
      }

reader.read().then(({ done, value }) => {
          if (done) {
            controller.close();
            return;
          }

          const chunk = toBuffer(value);

          // Encrypt chunk
          const encryptedChunk = cipher.update(chunk);

          controller.enqueue(encryptedChunk);
          push();

          // Emit a progress update
          totalBytesRead += chunk.length;
          emitProgress(
            'encrypt',
            totalBytesRead,
            contentLength,
            '[encrypted file]',
          );

parser.buffer('byte', 1).tap(() => {
            const byte = parser.vars.byte;

            const ab = new Uint8Array(1);
            ab.fill(byte[0]);

            inflator.push(ab);

            if (inflator.ended) {
                if (inflator.err) {
                    parser.emit('error', new Error(inflator.msg));
                }

                parser.vars.content = uint8ToBuffer(inflator.result);

                end();
            }
        });
    });

RNEmitter.addListener(nativeBridge.eventName, (payload: string) => {
    if (printRPCBytes) {
      logger.debug('[RPC] Read', payload.length, 'chars:', payload)
    }

    const buffer = toBuffer(toByteArray(payload))
    const measureName = `packetize${packetizeCount++}:${buffer.length}`
    measureStart(measureName)
    const ret = client.transport.packetize_data(buffer)
    measureStop(measureName)
    return ret
  })

async secretKey(): Promise {
    await this.isInit;
    await sodium.ready;
    let key = this._key;
    const { privateKey } = sodium.crypto_sign_seed_keypair(
      new Uint8Array(key).slice(0, 32),
      'uint8array'
    );
    key = toBuffer(privateKey);

    return b58cencode(key, prefix[`edsk`]);
  }
}

async sign(bytes: string, bytesHash: Uint8Array) {
    const key = new elliptic.ec(this.curve).keyFromPrivate(this._key);
    const sig = key.sign(bytesHash, { canonical: true });
    const signature = new Uint8Array(sig.r.toArray().concat(sig.s.toArray()));
    const signatureBuffer = toBuffer(signature);
    const sbytes = bytes + buf2hex(signatureBuffer);

    return {
      bytes,
      sig: b58cencode(signature, prefix.sig),
      prefixSig: b58cencode(signature, pref[this.curve].sig),
      sbytes,
    };
  }

function unzip(buf: Buffer): Buffer {
    const input = bufferToUint8(buf);
    const output = pako.inflate(input);

    return uint8ToBuffer(output);
}