How to use hexy - 10 common examples

function setSLIPPacket(data) {
		console.log("setSLIPPacket:\n%s", hexy.hexy(data));
		assert(data);                          // Assert if we have been presented no data.
		assert(data.length > 0);               // Assert that the data length is not 0.
		assert(data[0] == 0xc0);               // Assert if the first bytes isn't a SLIP marker.
         
		var end = getSLIPTrailer(data);        // Get the end marker for the SLIP packet.
		if (end == -1) {
			throw "No SLIP trailer in data we are to process.";
		}
		assert(end > 0);

		dataPacket = Buffer.allocUnsafe(data.length);                     // Our data will be no MORE (but likely less) than data.length bytes in size.
		for (var i=1, j=0; i 0xc0
				dataPacket[j] = 0xc0;
				i++
			} else if (data[i] == 0xdb && data[i+1] == 0xdd) {            // 0xdb 0xdd -> 0xdb

function processPacket(inputData) {
		assert(inputData);
		assert(inputData.length > 0);
		console.log("Received a packet, length %d:\n%s", inputData.length, hexy.hexy(inputData));
		// 0 - direction
		// 1 - command
		// [2-3] - size
		// [4-7] - value
		// [8-(length-3)] - data
		// [length-2] - status
		// [length-1] - error code
		if (inputData.readUInt8(0) != 0x01) {
			throw "Expected direction to be 0x01 for a response.";
		}
		command  = inputData.readUInt8(1);
		dataSize = inputData.readUInt16LE(2);
		value    = inputData.readUInt32LE(4);
		data     = Buffer.allocUnsafe(inputData.length - 8 - 2);
		inputData.copy(data, 0, 8, inputData.length - 2);
		status   = inputData.readUInt8(inputData.length - 2);

logHex: function(data) {
    console.log(hexy(data));

    // console.log("\n");
    // var testSplit = data.toString("hex");
    // testSplit = testSplit.match(/../g);

    // var lineVal = "";
    // var hexCounter = 0;
    // for(var i = 0; i < testSplit.length; i++) {
    //   lineVal += testSplit[i] + " ";
    //   hexCounter++;
    //   if(hexCounter == 15) {
    //     console.log(lineVal);
    //     lineVal = "";
    //     hexCounter = 0;
    //   }
    // }

} catch(ex) {
                                // For testing only...
                                this.bufferLength = 0;
                                dumpError(ex)
                            }
                            position += packet.Restruct.size;
                            this.badCount = 0;
                        } else {
                            packet = null;
                        }
                    } else {
                        // unreconized packet id
                        if(this.onUnrecognizedPacket) this.onUnrecognizedPacket(packetID);
                        console.log('Unreconized PacketID: 0x' + _util.padLeft(packetID.toString(16).toUpperCase(),'0',2) + ' Size: ' + (this.bufferLength - position));
                        //logHex(this.data.slice(position,this.bufferLength));
                        console.log(hexy(this.data.slice(position, this.bufferLength)));
                        // For testing only this will reset buffer to empty.
                        // Which may have packet data loss but meh
                        this.bufferLength = 0;
                        // Output to log file or something?
                        // Throw away buffer data
                        //this.bufferLength = 0;
                        //position = 0;
                        this.badCount++;
                    }
                    if(packet === null) {
                        position = PositionBeforePacketID;
                        this.badCount++;
                    }
                    if(this.badLimit && this.badCount >= this.badLimit) {
                        if(this.onBadfunction) this.onBadfunction();
                    }

function nextPacketPos(b) {
  console.log(hexy(b, { prefix: 'SEARCHING : ' }));
  if (b.length < 10) {
    console.log('TOO SHORT');
    return -1;
  }
  for (var i = 1; i < b.length; ++i) {
    if (b.get(i) === 0x6c) {
      console.log(
        `possible match at ${i}`,
        b.get(i + 3),
        b.get(i + 1),
        b.get(i + 2),
        b.get(i + 8)
      );
      if (
        b.get(i + 3) === 1 &&
        b.get(i + 1) < 5 &&

var pos = nextPacketPos(b);
        console.log('NEXT PACKET POS:', pos);
        if (pos !== -1) {
          var packet = b.splice(0, pos).toBuffer();
          console.error(
            ' ====== PACKET START ====== ',
            pos,
            packet.length,
            packet[0]
          );
          console.error(hexy(packet, { prefix: 'packet: ' }));
          console.error(' ====== PACKET END ====== ');
          if (packet[0] === 0x6c) {
            var len = Buffer.alloc(4);
            len.writeUInt32LE(packet.length, 0);
            console.error(hexy(len, { prefix: 'packet header: ' }));
            packetfile.write(len);
            packetfile.write(packet);
          }
          extractPacket();
        }
      }
      extractPacket();

function hexdump(buffer) {
	verboseOutput(hexy.hexy(buffer)+ '(' + buffer.length + ' bytes)');
}

tcpRelay.listen(tcpServerInfo, function (data, telemetry) {
    var t = util.format('%s:%d -> %s:%d',
                        telemetry.src.address, telemetry.src.port,
                        telemetry.dst.address, telemetry.dst.port);

    var dataChunk = data.slice(0, Math.min(data.length, maxShowLength));
    var dots = '';
    if (dataChunk.length < data.length) {
      dots = '...';
    }

    console.log('[TCP Relay] ', t);
    console.log(hexy.hexy(dataChunk) + dots);
  });
  console.log('UDP and TCP Relay created for: ', server.info);

s.on('data', function(b) {
      console.log(hexy(b, { prefix: 'from server ' }));
    });
  })

function HexDumpPreview(props: { body: string; isBase64Encoded: boolean; paneResizeToken: number }) {
  function convertBase64StringToUint8Array(data: string) {
    const binary = atob(data);
    const array = new Array(binary.length);
    for (let i = 0; i < binary.length; i++) {
      array[i] = binary.charCodeAt(i);
    }
    return array;
  }

  const body = props.isBase64Encoded ? convertBase64StringToUint8Array(props.body) : props.body;
  const hexed = hexy(body, { format: 'twos', caps: 'upper' }).trimEnd();

  return (
    
  );
}