binary-parser

  • Version 2.3.1
  • Published
  • 277 kB
  • No dependencies
  • MIT license

Install

npm i binary-parser
yarn add binary-parser
pnpm add binary-parser

Overview

Blazing-fast binary parser builder

Index

Classes

class Parser

class Parser {}

    constructor

    constructor();

      property alias

      alias?: string;

        property compiled

        compiled?: Function;

          property constructorFn

          constructorFn?: Function;

            property endian

            endian: Endianness;

              property head

              head?: Parser;

                property next

                next?: Parser;

                  property options

                  options: ParserOptions;

                    property type

                    type: Types;

                      property useContextVariables

                      useContextVariables: boolean;

                        property varName

                        varName: string;

                          method array

                          array: (varName: string, options: ParserOptions) => this;

                            method bit1

                            bit1: (varName: string, options?: ParserOptions) => this;

                              method bit10

                              bit10: (varName: string, options?: ParserOptions) => this;

                                method bit11

                                bit11: (varName: string, options?: ParserOptions) => this;

                                  method bit12

                                  bit12: (varName: string, options?: ParserOptions) => this;

                                    method bit13

                                    bit13: (varName: string, options?: ParserOptions) => this;

                                      method bit14

                                      bit14: (varName: string, options?: ParserOptions) => this;

                                        method bit15

                                        bit15: (varName: string, options?: ParserOptions) => this;

                                          method bit16

                                          bit16: (varName: string, options?: ParserOptions) => this;

                                            method bit17

                                            bit17: (varName: string, options?: ParserOptions) => this;

                                              method bit18

                                              bit18: (varName: string, options?: ParserOptions) => this;

                                                method bit19

                                                bit19: (varName: string, options?: ParserOptions) => this;

                                                  method bit2

                                                  bit2: (varName: string, options?: ParserOptions) => this;

                                                    method bit20

                                                    bit20: (varName: string, options?: ParserOptions) => this;

                                                      method bit21

                                                      bit21: (varName: string, options?: ParserOptions) => this;

                                                        method bit22

                                                        bit22: (varName: string, options?: ParserOptions) => this;

                                                          method bit23

                                                          bit23: (varName: string, options?: ParserOptions) => this;

                                                            method bit24

                                                            bit24: (varName: string, options?: ParserOptions) => this;

                                                              method bit25

                                                              bit25: (varName: string, options?: ParserOptions) => this;

                                                                method bit26

                                                                bit26: (varName: string, options?: ParserOptions) => this;

                                                                  method bit27

                                                                  bit27: (varName: string, options?: ParserOptions) => this;

                                                                    method bit28

                                                                    bit28: (varName: string, options?: ParserOptions) => this;

                                                                      method bit29

                                                                      bit29: (varName: string, options?: ParserOptions) => this;

                                                                        method bit3

                                                                        bit3: (varName: string, options?: ParserOptions) => this;

                                                                          method bit30

                                                                          bit30: (varName: string, options?: ParserOptions) => this;

                                                                            method bit31

                                                                            bit31: (varName: string, options?: ParserOptions) => this;

                                                                              method bit32

                                                                              bit32: (varName: string, options?: ParserOptions) => this;

                                                                                method bit4

                                                                                bit4: (varName: string, options?: ParserOptions) => this;

                                                                                  method bit5

                                                                                  bit5: (varName: string, options?: ParserOptions) => this;

                                                                                    method bit6

                                                                                    bit6: (varName: string, options?: ParserOptions) => this;

                                                                                      method bit7

                                                                                      bit7: (varName: string, options?: ParserOptions) => this;

                                                                                        method bit8

                                                                                        bit8: (varName: string, options?: ParserOptions) => this;

                                                                                          method bit9

                                                                                          bit9: (varName: string, options?: ParserOptions) => this;

                                                                                            method buffer

                                                                                            buffer: (varName: string, options: ParserOptions) => this;

                                                                                              method choice

                                                                                              choice: (varName: string | ParserOptions, options?: ParserOptions) => this;

                                                                                                method compile

                                                                                                compile: () => void;

                                                                                                  method create

                                                                                                  create: (constructorFn: Function) => this;

                                                                                                    method doublebe

                                                                                                    doublebe: (varName: string, options?: ParserOptions) => this;

                                                                                                      method doublele

                                                                                                      doublele: (varName: string, options?: ParserOptions) => this;

                                                                                                        method endianess

                                                                                                        endianess: (endianess: 'little' | 'big') => this;

                                                                                                          method endianness

                                                                                                          endianness: (endianness: 'little' | 'big') => this;

                                                                                                            method floatbe

                                                                                                            floatbe: (varName: string, options?: ParserOptions) => this;

                                                                                                              method floatle

                                                                                                              floatle: (varName: string, options?: ParserOptions) => this;

                                                                                                                method getCode

                                                                                                                getCode: () => string;

                                                                                                                  method int16

                                                                                                                  int16: (varName: string, options?: ParserOptions) => this;

                                                                                                                    method int16be

                                                                                                                    int16be: (varName: string, options?: ParserOptions) => this;

                                                                                                                      method int16le

                                                                                                                      int16le: (varName: string, options?: ParserOptions) => this;

                                                                                                                        method int32

                                                                                                                        int32: (varName: string, options?: ParserOptions) => this;

                                                                                                                          method int32be

                                                                                                                          int32be: (varName: string, options?: ParserOptions) => this;

                                                                                                                            method int32le

                                                                                                                            int32le: (varName: string, options?: ParserOptions) => this;

                                                                                                                              method int64

                                                                                                                              int64: (varName: string, options?: ParserOptions) => this;

                                                                                                                                method int64be

                                                                                                                                int64be: (varName: string, options?: ParserOptions) => this;

                                                                                                                                  method int64le

                                                                                                                                  int64le: (varName: string, options?: ParserOptions) => this;

                                                                                                                                    method int8

                                                                                                                                    int8: (varName: string, options?: ParserOptions) => this;

                                                                                                                                      method namely

                                                                                                                                      namely: (alias: string) => this;

                                                                                                                                        method nest

                                                                                                                                        nest: (varName: string | ParserOptions, options?: ParserOptions) => this;

                                                                                                                                          method parse

                                                                                                                                          parse: (buffer: Buffer | Uint8Array) => any;

                                                                                                                                            method pointer

                                                                                                                                            pointer: (varName: string, options: ParserOptions) => this;

                                                                                                                                              method saveOffset

                                                                                                                                              saveOffset: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                method seek

                                                                                                                                                seek: (relOffset: ParserOptions['length'], options?: ParserOptions) => this;

                                                                                                                                                  method sizeOf

                                                                                                                                                  sizeOf: () => number;

                                                                                                                                                    method skip

                                                                                                                                                    skip: (length: ParserOptions['length'], options?: ParserOptions) => this;

                                                                                                                                                      method start

                                                                                                                                                      static start: () => Parser;

                                                                                                                                                        method string

                                                                                                                                                        string: (varName: string, options: ParserOptions) => this;

                                                                                                                                                          method uint16

                                                                                                                                                          uint16: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                            method uint16be

                                                                                                                                                            uint16be: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                              method uint16le

                                                                                                                                                              uint16le: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                method uint32

                                                                                                                                                                uint32: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                  method uint32be

                                                                                                                                                                  uint32be: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                    method uint32le

                                                                                                                                                                    uint32le: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                      method uint64

                                                                                                                                                                      uint64: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                        method uint64be

                                                                                                                                                                        uint64be: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                          method uint64le

                                                                                                                                                                          uint64le: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                            method uint8

                                                                                                                                                                            uint8: (varName: string, options?: ParserOptions) => this;

                                                                                                                                                                              method useContextVars

                                                                                                                                                                              useContextVars: (useContextVariables?: boolean) => this;

                                                                                                                                                                                method wrapped

                                                                                                                                                                                wrapped: (varName: string | ParserOptions, options?: ParserOptions) => this;

                                                                                                                                                                                  Package Files (1)

                                                                                                                                                                                  Dependencies (0)

                                                                                                                                                                                  No dependencies.

                                                                                                                                                                                  Dev Dependencies (10)

                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                  No peer dependencies.

                                                                                                                                                                                  Badge

                                                                                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/binary-parser.

                                                                                                                                                                                  • Markdown
                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/binary-parser)
                                                                                                                                                                                  • HTML
                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/binary-parser"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>