bireader 3.0.1 → 3.1.1

package/README.md

@@ -16,16 +16,19 @@ Supported data types:
 
 ## What's New?
 
-### v3.0
- * Added better option for extending array buffer when writing data with ``extendBufferSize``.
+### v3
+ * Added Browser, Node CommonJS and Node ESM modules.
+ * Added new ``BiReaderStream`` and ``BiWriterStream`` for use in Node with large file size (4 gig+). See [documention](#bistreams) for how to use.
+ * Added setter ``.strSettings`` for use with ``.str`` for easier coding.
+ * Added better options for extending array buffer when writing data with ``extendBufferSize``.
  * Consolidated all options argument into single object when creating class.
  * Removed deprecated ``bireader`` and ``biwriter`` classes.
- * Fixed standalone hexdump function. 
+ * Fixed standalone ``hexdump`` function. 
 
-### v2.0
- * Created new ``BiReader`` and ``BiWriter`` classes with easier *get* and *set* functions for faster coding.
+### v2
+ * Created new ``BiReader`` and ``BiWriter`` classes with *get* and *set* functions for easier coding.
 
-### v1.0
+### v1
  * Included math functions and value searches.
  * Many bug fixes.
 
@@ -33,7 +36,7 @@ Supported data types:
 
 ```npm install bireader```
 
-Provides both CommonJS and ES modules.
+Provides both CommonJS and ES modules for Browser and Node.
 
 ### Example
 
@@ -47,6 +50,7 @@ import {BiReader, BiWriter} from 'bireader';
 // read example - parse a webp file
 function parse_webp(data){
   const br = new BiReader(data);
+  br.strSettings = {length: 4};
   br.hexdump({supressUnicode:true}); // console.log data as hex
 
   //         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  0123456789ABCDEF
@@ -64,11 +68,11 @@ function parse_webp(data){
   // 000b0  77 44 40 94 6d 25 6c 74 91 a8 88 86 58 9b da 6e  wD@.m%lt....X..n
 
   const header = {};
-  header.magic = br.string({length:4});    // RIFF
+  header.magic = br.str;    // RIFF
   header.size = br.uint32le;               // 15000
   header.fileSize = header.size + 8;       // 15008
-  header.payload = br.string({length:4});  // WEBP
-  header.format = br.string({length:4});   // VP8X
+  header.payload = br.str;  // WEBP
+  header.format = br.str;   // VP8X
   header.formatChunkSize = br.uint32le;    // 10
   switch (header.format){
     case "VP8 ":
@@ -122,19 +126,19 @@ function parse_webp(data){
         header.height = header.heightMinus1 + 1
         if(header.I)
         {
-          header.ICCP = br.string({length:4});  // Should be ICCP
+          header.ICCP = br.str;  // Should be ICCP
           header.ICCPChunkSize = br.uint32;
           header.ICCPData = br.extract(header.ICCPChunkSize, true);
         }
         if(header.L)
         {
-          header.ALPH = br.string({length:4});  // Should be ALPH
+          header.ALPH = br.str;  // Should be ALPH
           header.ALPHChunkSize = br.uint32;     // 4134
           header.ALPHData = br.extract(header.ALPHChunkSize, true);
         }
         if(header.A)
         {
-          header.ANI = br.string({length:4});  // Should be ANIM or ANIF
+          header.ANI = br.str;  // Should be ANIM or ANIF
           header.ANIChunkSize = br.uint32;
           if(header.ANI == "ANIM")
           {
@@ -158,18 +162,18 @@ function parse_webp(data){
             header.ANIFData = br.extract(header.ANIChunkSize, true);
           }
         }
-        header.extFormatStr = br.string({length:4});
+        header.extFormatStr = br.str;
         header.extChunkSize = br.uint32;
         header.extData = br.extract(header.extChunkSize, true);
         if(header.E)
         {
-          header.EXIF = br.string({length:4});  // Should be EXIF
+          header.EXIF = br.str;  // Should be EXIF
           header.EXIFChunkSize = br.uint32;
           header.EXIFData = br.extract(header.EXIFChunkSize, true);
         }
         if(header.X)
         {
-          header.XMP = br.string({length:4});  // Should be XMP
+          header.XMP = br.str;  // Should be XMP
           header.XMPChunkSize = br.uint32;
           header.XMPMetaData = br.extract(header.XMPChunkSize, true);
         }
@@ -184,13 +188,15 @@ function parse_webp(data){
 
 // write example - write a webp file from read data
 function write_webp(data){
-  const bw = new BiWriter(new Uint8Arry(0x100000)); // Will extends array as we write if needed by default
-  bw.string("RIFF",{length:4});
+  const bw = new BiWriter(new Uint8Arry(0x100000)); // Will extends array as we 
+  // write if needed by default
+  bw.strSettings = {length: 4};
+  bw.str = "RIFF";
   bw.uint32le = 0; // dummy for now, will be final size - 8
-  bw.string("WEBP",{length:4});
+  bw.str = "WEBP";
   switch(data.format){
     case "VP8 ":
-      bw.string("VP8 ",{length:4});
+      bw.str = "VP8 ";
       bw.uint32le = data.VP8data.length;
       bw.ubit24 = data.key_frame;
       bw.ubit24 = data.start_code;
@@ -199,7 +205,7 @@ function write_webp(data){
       bw.overwrite(data.VP8data ,true);
       break;
     case "VP8L":
-      bw.string("VP8L",{length:4});
+      bw.str = "VP8L";
       bw.uint32le = data.VP8Ldata.length - 4;
       bw.ubyte = 47;
       bw.ubit14 = data.width - 1;
@@ -209,7 +215,7 @@ function write_webp(data){
       bw.overwrite(data.VP8Ldata,true);
       break;
     case "VP8X":
-      bw.string("VP8X",{length:4});
+      bw.str = "VP8X";
       bw.uint32le = 10;
       bw.big();
       bw.bit2 = 0;
@@ -225,19 +231,19 @@ function write_webp(data){
       bw.ubit24 = data.height - 1;
       if(data.I)
       {
-        bw.string(data.ICCP, {length:4});
+        bw.str = data.ICCP;
         bw.uint32 = data.ICCPData.length;;
         bw.replace(data.ICCPData, true);
       }
       if(data.L)
       {
-        bw.string(data.ALPH, {length:4});
+        bw.str = data.ALPH;
         bw.uint32 = data.ALPHData.length;
         bw.replace(data.ALPHData);
       }
       if(data.A)
       {
-        bw.string(data.ANI, {length:4});
+        bw.str = data.ANI;
         bw.uint32 = data.ANIChunkSize;
         if(data.ANI == "ANIM")
         {
@@ -259,18 +265,18 @@ function write_webp(data){
           bw.replace(data.ANIFData, true);
         }
       }
-      bw.string(data.extFormatStr, {length:4});
+      bw.str = data.extFormatStr;
       bw.uint32 = data.extData.length;
       bw.replace(data.extData, true);
       if(data.E)
       {
-        bw.string(data.EXIF, {length:4});
+        bw.str = data.EXIF;
         bw.uint32 = data.EXIFData.length;
         bw.replace( data.EXIFData, true);
       }
       if(data.X)
       {
-        bw.string(data.XMP, {length:4});
+        bw.str = data.XMP;
         bw.uint32 = data.XMPMetaData.length;
         bw.replace(data.XMPMetaData, true);
       }
@@ -306,7 +312,7 @@ Common functions for setup, movement, manipulation and math shared by both.
     <td>new BiReader(<b>data</b>, {byteOffset, bitOffset, endianess, strict, extendBufferSize})</td>
     <td align="center" rowspan="2"><b>Buffer or Uint8Array</b>, byte offset (default 0), bit offset (default 0), endian big or little (default little), strict mode true to restrict extending initially supplied data (default true for reader, false for writer), extended Buffer size amount.
     </td>
-    <td rowspan="2">Start with new Constructor.<br><br><b>Note:</b> Supplied data can always be found with .data.<br><br><b>Writing data note:</b> while BiWriter can be created with a 0 length Uint8Array or Buffer, each new value write will create a new array and concat the two. For large data writes this will lead to a degraded performance. It's best to supply a larger than needed buffer when creating the Writer and use .trim() after you're finished. You can also set the extendBufferSize value to always extend by a fixed amount when reaching the end. This will also change the logic for .return and .get to trim the remining data from the current position for you. Use .data instead if you want to get the whole padded buffer array.</td>
+    <td rowspan="2">Start with new Constructor.<br><br><b>Note:</b> Supplied data can always be found with <b>.data</b>.<br><br><b>Writing data note:</b> while BiWriter can be created with a 0 length Uint8Array or Buffer, each new value write will create a new array and concat the two. For large data writes this will lead to a degraded performance. It's best to supply a larger than needed buffer when creating the Writer and use <b>.trim()</b> after you're finished. You can also set the <b>extendBufferSize</b> value to always extend by a fixed amount when reaching the end. This will also change the logic for <b>.return</b> and <b>.get</b> to trim the remining data from the current position for you. Use <b>.data</b> instead if you want to get the whole padded buffer array.</td>
   </tr>
   <tr>
     <td>Name</td>
@@ -735,6 +741,62 @@ Common functions for setup, movement, manipulation and math shared by both.
 </tbody>
 </table>
 
+## BiStreams
+
+With 3.1 you can now use ``BiReaderStream`` and ``BiWriterStream`` in Node for larger files (or if you don't want or need the whole file loaded to memory all at once).
+
+<table>
+<thead>
+  <tr>
+    <th align="center" colspan="2">Function</th>
+    <th align="center">Params (bold requires)</th>
+    <th align="left">Desc</th>
+  </tr>
+</thead>
+<tbody>
+  <tr>
+  <th align="center" colspan="4"><i>Streaming</i></th>
+  <tr>
+  <tr>
+    <td>Name</td>
+    <td>new BiReaderStream(<b>filePath</b>, {byteOffset, bitOffset, endianess, strict, extendBufferSize})</td>
+    <td align="center" rowspan="2"><b>Path to file</b>, byte offset (default 0), bit offset (default 0), endian big or little (default little), strict mode true to restrict extending file size (default true for reader, false for writer), extended file size amount.
+    </td>
+    <td rowspan="2">Start with new Constructor.<br><br><b>Note:</b> The file must be opened with <b>.open()</b> and closed with <b>.close()</b>. The <b>.data</b> value is always the Buffer to the last read or write value. Read sizes outside of Node's max size will error, unless remove then it will create a new file.<br><br><b>Writer note:</b> You can set the <b>extendBufferSize</b> value to always extend the file by this minimum amount when reaching the end of the file. The file is saved after every write.</td>
+  </tr>
+  <tr>
+    <td>Name</td>
+    <td>new BiWriterStream(<b>filePath</b>, {byteOffset, bitOffset, endianess, strict, extendBufferSize})</td>
+  </tr>
+  <th align="center" colspan="4"><i>File Control</i></th>
+  <tr>
+    <td>Name</td>
+    <td>open()
+    <td align="center"><b>none</td>
+    <td>Opens file for reading / writing.</td>
+  </tr>
+  <tr>
+    <td>Name</td>
+    <td>close()
+    <td align="center"><b>none</td>
+    <td>Closes file after reading / writing.</td>
+  </tr>
+  <tr>
+    <td>Name</td>
+    <td>writeMode(writable)
+    <td align="center"><b>True if you want to switch to writing in BiReaderStream.</td>
+    <td>Note: This changes reader to write mode. Allows file to be expanded in size as well.</td>
+  </tr>
+  
+</tbody>
+</table>
+
+### Streaming Caveats
+
+ * Naming: Same naming applies to streamers as [Common Functions](#common-functions) section but the file is saved after every operation.
+ * Writing: Unlike the other BiReader, **all write functions will throw an error unless you switch to ``.writeMode(true)``** The file is read only until you do. Any write functions inside the reader will error beforehand.
+ * Large removal: When using any function that removes data from the file and would return a Buffer, **if the size of the returned Buffer is outside of the Node max size for a Buffer, a new file will be made with the location and size concat to the name with a .removed file extention instead.**
+
 ## Bit field
 
 Parse value as a bit field. There are 32 functions from bit1 to bit32 and can be signed or unsigned (with a ``u`` at the start) and in little or big endian order (``be`` or ``le`` at the end).

package/dist/BiReader.d.ts

@@ -0,0 +1,339 @@
+/// <reference types="node" />
+import { BiOptions, endian, stringOptions } from "./common.js";
+import { BiBase } from './core/BiBase.js';
+import { BinaryAliasReader } from "./aliases/BinaryAliasReader.js";
+declare const BiReaderBase: typeof BiBase;
+/**
+ * Binary reader, includes bitfields and strings.
+ *
+ * @param {Buffer|Uint8Array} data - ``Buffer`` or ``Uint8Array``. Always found in ``BiReader.data``
+ * @param {BiOptions?} options - Any options to set at start
+ * @param {number?} options.byteOffset - Byte offset to start reader (default ``0``)
+ * @param {number?} options.bitOffset - Bit offset 0-7 to start reader (default ``0``)
+ * @param {string?} options.endianness - Endianness ``big`` or ``little`` (default ``little``)
+ * @param {boolean?} options.strict - Strict mode: if ``true`` does not extend supplied array on outside write (default ``true``)
+ * @param {number?} options.extendBufferSize - Amount of data to add when extending the buffer array when strict mode is false. Note: Changes logic in ``.get`` and ``.return``.
+ *
+ * @since 2.0
+ */
+export declare class BiReader extends BiReaderBase implements BinaryAliasReader {
+    /**
+     * Binary reader, includes bitfields and strings.
+     *
+     * @param {Buffer|Uint8Array} data - ``Buffer`` or ``Uint8Array``. Always found in ``BiReader.data``
+     * @param {BiOptions?} options - Any options to set at start
+     * @param {number?} options.byteOffset - Byte offset to start reader (default ``0``)
+     * @param {number?} options.bitOffset - Bit offset 0-7 to start reader (default ``0``)
+     * @param {string?} options.endianness - Endianness ``big`` or ``little`` (default ``little``)
+     * @param {boolean?} options.strict - Strict mode: if ``true`` does not extend supplied array on outside write (default ``true``)
+     * @param {number?} options.extendBufferSize - Amount of data to add when extending the buffer array when strict mode is false. Note: Changes logic in ``.get`` and ``.return``.
+     */
+    constructor(data: Buffer | Uint8Array, options?: BiOptions);
+    bit(bits: number, unsigned?: boolean, endian?: endian): number;
+    ubit(bits: number, endian?: endian): number;
+    ubitbe(bits: number): number;
+    bitbe(bits: number, unsigned?: boolean): number;
+    ubitle(bits: number): number;
+    bitle(bits: number, unsigned?: boolean): number;
+    get bit1(): number;
+    get bit1le(): number;
+    get bit1be(): number;
+    get ubit1(): number;
+    get ubit1le(): number;
+    get ubit1be(): number;
+    get bit2(): number;
+    get bit2le(): number;
+    get bit2be(): number;
+    get ubit2(): number;
+    get ubit2le(): number;
+    get ubit2be(): number;
+    get bit3(): number;
+    get bit3le(): number;
+    get bit3be(): number;
+    get ubit3(): number;
+    get ubit3le(): number;
+    get ubit3be(): number;
+    get bit4(): number;
+    get bit4le(): number;
+    get bit4be(): number;
+    get ubit4(): number;
+    get ubit4le(): number;
+    get ubit4be(): number;
+    get bit5(): number;
+    get bit5le(): number;
+    get bit5be(): number;
+    get ubit5(): number;
+    get ubit5le(): number;
+    get ubit5be(): number;
+    get bit6(): number;
+    get bit6le(): number;
+    get bit6be(): number;
+    get ubit6(): number;
+    get ubit6le(): number;
+    get ubit6be(): number;
+    get bit7(): number;
+    get bit7le(): number;
+    get bit7be(): number;
+    get ubit7(): number;
+    get ubit7le(): number;
+    get ubit7be(): number;
+    get bit8(): number;
+    get bit8le(): number;
+    get bit8be(): number;
+    get ubit8(): number;
+    get ubit8le(): number;
+    get ubit8be(): number;
+    get bit9(): number;
+    get bit9le(): number;
+    get bit9be(): number;
+    get ubit9(): number;
+    get ubit9le(): number;
+    get ubit9be(): number;
+    get bit10(): number;
+    get bit10le(): number;
+    get bit10be(): number;
+    get ubit10(): number;
+    get ubit10le(): number;
+    get ubit10be(): number;
+    get bit11(): number;
+    get bit11le(): number;
+    get bit11be(): number;
+    get ubit11(): number;
+    get ubit11le(): number;
+    get ubit11be(): number;
+    get bit12(): number;
+    get bit12le(): number;
+    get bit12be(): number;
+    get ubit12(): number;
+    get ubit12le(): number;
+    get ubit12be(): number;
+    get bit13(): number;
+    get bit13le(): number;
+    get bit13be(): number;
+    get ubit13(): number;
+    get ubit13le(): number;
+    get ubit13be(): number;
+    get bit14(): number;
+    get bit14le(): number;
+    get bit14be(): number;
+    get ubit14(): number;
+    get ubit14le(): number;
+    get ubit14be(): number;
+    get bit15(): number;
+    get bit15le(): number;
+    get bit15be(): number;
+    get ubit15(): number;
+    get ubit15le(): number;
+    get ubit15be(): number;
+    get bit16(): number;
+    get bit16le(): number;
+    get bit16be(): number;
+    get ubit16(): number;
+    get ubit16le(): number;
+    get ubit16be(): number;
+    get bit17(): number;
+    get bit17le(): number;
+    get bit17be(): number;
+    get ubit17(): number;
+    get ubit17le(): number;
+    get ubit17be(): number;
+    get bit18(): number;
+    get bit18le(): number;
+    get bit18be(): number;
+    get ubit18(): number;
+    get ubit18le(): number;
+    get ubit18be(): number;
+    get bit19(): number;
+    get bit19le(): number;
+    get bit19be(): number;
+    get ubit19(): number;
+    get ubit19le(): number;
+    get ubit19be(): number;
+    get bit20(): number;
+    get bit20le(): number;
+    get bit20be(): number;
+    get ubit20(): number;
+    get ubit20le(): number;
+    get ubit20be(): number;
+    get bit21(): number;
+    get bit21le(): number;
+    get bit21be(): number;
+    get ubit21(): number;
+    get ubit21le(): number;
+    get ubit21be(): number;
+    get bit22(): number;
+    get bit22le(): number;
+    get bit22be(): number;
+    get ubit22(): number;
+    get ubit22le(): number;
+    get ubit22be(): number;
+    get bit23(): number;
+    get bit23le(): number;
+    get bit23be(): number;
+    get ubit23(): number;
+    get ubit23le(): number;
+    get ubit23be(): number;
+    get bit24(): number;
+    get bit24le(): number;
+    get bit24be(): number;
+    get ubit24(): number;
+    get ubit24le(): number;
+    get ubit24be(): number;
+    get bit25(): number;
+    get bit25le(): number;
+    get bit25be(): number;
+    get ubit25(): number;
+    get ubit25le(): number;
+    get ubit25be(): number;
+    get bit26(): number;
+    get bit26le(): number;
+    get bit26be(): number;
+    get ubit26(): number;
+    get ubit26le(): number;
+    get ubit26be(): number;
+    get bit27(): number;
+    get bit27le(): number;
+    get bit27be(): number;
+    get ubit27(): number;
+    get ubit27le(): number;
+    get ubit27be(): number;
+    get bit28(): number;
+    get bit28le(): number;
+    get bit28be(): number;
+    get ubit28(): number;
+    get ubit28le(): number;
+    get ubit28be(): number;
+    get bit29(): number;
+    get bit29le(): number;
+    get bit29be(): number;
+    get ubit29(): number;
+    get ubit29le(): number;
+    get ubit29be(): number;
+    get bit30(): number;
+    get bit30le(): number;
+    get bit30be(): number;
+    get ubit30(): number;
+    get ubit30le(): number;
+    get ubit30be(): number;
+    get bit31(): number;
+    get bit31le(): number;
+    get bit31be(): number;
+    get ubit31(): number;
+    get ubit31le(): number;
+    get ubit31be(): number;
+    get bit32(): number;
+    get bit32le(): number;
+    get bit32be(): number;
+    get ubit32(): number;
+    get ubit32le(): number;
+    get ubit32be(): number;
+    get byte(): number;
+    get int8(): number;
+    get uint8(): number;
+    get ubyte(): number;
+    get int16(): number;
+    get short(): number;
+    get word(): number;
+    get uint16(): number;
+    get ushort(): number;
+    get uword(): number;
+    get uint16le(): number;
+    get ushortle(): number;
+    get uwordle(): number;
+    get int16le(): number;
+    get shortle(): number;
+    get wordle(): number;
+    get uint16be(): number;
+    get ushortbe(): number;
+    get uwordbe(): number;
+    get int16be(): number;
+    get shortbe(): number;
+    get wordbe(): number;
+    get halffloat(): number;
+    get half(): number;
+    get halffloatbe(): number;
+    get halfbe(): number;
+    get halffloatle(): number;
+    get halfle(): number;
+    get int(): number;
+    get double(): number;
+    get int32(): number;
+    get long(): number;
+    get uint(): number;
+    get udouble(): number;
+    get uint32(): number;
+    get ulong(): number;
+    get intbe(): number;
+    get doublebe(): number;
+    get int32be(): number;
+    get longbe(): number;
+    get uintbe(): number;
+    get udoublebe(): number;
+    get uint32be(): number;
+    get ulongbe(): number;
+    get intle(): number;
+    get doublele(): number;
+    get int32le(): number;
+    get longle(): number;
+    get uintle(): number;
+    get udoublele(): number;
+    get uint32le(): number;
+    get ulongle(): number;
+    get float(): number;
+    get floatbe(): number;
+    get floatle(): number;
+    get int64(): bigint;
+    get bigint(): bigint;
+    get quad(): bigint;
+    get uint64(): bigint;
+    get ubigint(): bigint;
+    get uquad(): bigint;
+    get int64be(): bigint;
+    get bigintbe(): bigint;
+    get quadbe(): bigint;
+    get uint64be(): bigint;
+    get ubigintbe(): bigint;
+    get uquadbe(): bigint;
+    get int64le(): bigint;
+    get bigintle(): bigint;
+    get quadle(): bigint;
+    get uint64le(): bigint;
+    get ubigintle(): bigint;
+    get uquadle(): bigint;
+    get doublefloat(): number;
+    get dfloat(): number;
+    get dfloatebe(): number;
+    get doublefloatbe(): number;
+    get dfloatle(): number;
+    get doublefloatle(): number;
+    string(options?: stringOptions): string;
+    get str(): string;
+    utf8string(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    cstring(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    ansistring(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    utf16string(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    unistring(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    utf16stringle(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    unistringle(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    utf16stringbe(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    unistringbe(length?: stringOptions["length"], terminateValue?: stringOptions["terminateValue"], stripNull?: stringOptions["stripNull"]): string;
+    pstring(lengthReadSize?: stringOptions["lengthReadSize"], stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    pstring1(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    pstring1le(stripNull?: stringOptions["stripNull"]): string;
+    pstring1be(stripNull?: stringOptions["stripNull"]): string;
+    pstring2(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    pstring2le(stripNull?: stringOptions["stripNull"]): string;
+    pstring2be(stripNull?: stringOptions["stripNull"]): string;
+    pstring4(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    pstring4le(stripNull?: stringOptions["stripNull"]): string;
+    pstring4be(stripNull?: stringOptions["stripNull"]): string;
+    wpstring(lengthReadSize?: stringOptions["lengthReadSize"], stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    wpstring1(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    wpstring2(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    wpstring2le(stripNull?: stringOptions["stripNull"]): string;
+    wpstring2be(stripNull?: stringOptions["stripNull"]): string;
+    wpstring4(stripNull?: stringOptions["stripNull"], endian?: stringOptions["endian"]): string;
+    wpstring4be(stripNull?: stringOptions["stripNull"]): string;
+    wpstring4le(stripNull?: stringOptions["stripNull"]): string;
+}
+export {};