binary-parser-tests.ts

import { Parser } from "binary-parser";

// Build an IP packet header Parser
const ipHeader = new Parser()
    .endianness("big")
    .bit4("version")
    .bit4("headerLength")
    .uint8("tos")
    .uint16("packetLength")
    .uint16("id")
    .bit3("offset")
    .bit13("fragOffset")
    .uint8("ttl")
    .uint8("protocol")
    .uint16("checksum")
    .array("src", {
        type: "uint8",
        length: 4,
    })
    .array("dst", {
        type: "uint8",
        length: 4,
    });

// Prepare buffer to parse.
const buf = new Buffer("450002c5939900002c06ef98adc24f6c850186d1", "hex");

// Parse buffer and show result
ipHeader.parse(buf);

const parser2 = new Parser()
    // Signed 32-bit integer (little endian)
    .int32le("a")
    // Unsigned 8-bit integer
    .uint8("b")
    // Signed 16-bit integer (big endian)
    .int16be("c");

const parser3 = new Parser()
    // 32-bit floating value (big endian)
    .floatbe("a")
    // 64-bit floating value (little endian)
    .doublele("b");

const parser4 = new Parser()
    // Statically sized array
    .array("data", {
        type: "int32",
        length: 8,
    })
    // Dynamically sized array (references another variable)
    .uint8("dataLength")
    .array("data2", {
        type: "int32",
        length: "dataLength",
    })
    // Dynamically sized array (with some calculation)
    .array("data3", {
        type: "int32",
        length: () => 4, // other fields are available through this
    })
    // Statically sized array
    .array("data4", {
        type: "int32",
        lengthInBytes: 16,
    })
    // Dynamically sized array (references another variable)
    .uint8("dataLengthInBytes")
    .array("data5", {
        type: "int32",
        lengthInBytes: "dataLengthInBytes",
    })
    // Dynamically sized array (with some calculation)
    .array("data6", {
        type: "int32",
        lengthInBytes: () => 4, // other fields are available through this
    })
    // Dynamically sized array (with stop-check on parsed item)
    .array("data7", {
        type: "int32",
        readUntil: (item, buffer) => true, // stop when specific item is parsed. buffer can be used to perform a read-ahead.
    });

const parser5 = new Parser()
    .array("ipv4", {
        type: "uint8",
        length: "4",
        formatter: (arr) => {},
    });

const parser6 = new Parser()
    .nest("nested", {
        type: new Parser()
            .array("points", {
                type: new Parser()
                    .uint8("x")
                    .uint8("y"),
                length: 2,
            }),
    })
    .choice("optional", {
        tag: "nested.points[0].x",
        choices: {
            1: new Parser()
                .uint8("number"),
        },
    });

const result = parser6.parse(Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05]));

// See the inferred static types on the IntelliSense.
result.nested.points[0].x;
result.nested.points[1].y;
result.optional.number;

const parser7 = new Parser()
    // Signed 64-bit integer
    .int64("a")
    // Unsigned 64-bit integer
    .uint64("b")
    // Signed 64-bit integer (little endian)
    .int64le("c")
    // Signed 64-bit integer (big endian)
    .int64be("d")
    // Unsigned 64-bit integer (little endian)
    .uint64le("e")
    // Unsigned 64-bit integer (big endian)
    .uint64be("f");