asbytearray
Version:
Simple implementation of the ByteArray from ActionScript3 in Node.js
302 lines (300 loc) • 10.4 kB
text/typescript
declare class ByteArray {
buffer: Buffer;
private _position;
private _endian;
constructor(buffer?: Buffer);
/**
* Moves, or returns the current position, in bytes, of the file
* pointer into the ByteArray object. This is the point at which the
* next call to a read method starts reading or a write method starts
* writing.
*/
get position(): number;
/**
* Moves, or returns the current position, in bytes, of the file
* pointer into the ByteArray object. This is the point at which the
* next call to a read method starts reading or a write method starts
* writing.
*/
set position(value: number);
/**
* Changes or reads the byte order for the data; either
* Endian.BIG_ENDIAN or Endian.LITTLE_ENDIAN.
*/
get endian(): Endian;
/**
* Changes or reads the byte order for the data; either
* Endian.BIG_ENDIAN or Endian.LITTLE_ENDIAN.
*/
set endian(value: Endian);
/**
* The length of the ByteArray object, in bytes.
*
* If the length is set to a value that is larger than the current
* length, the right side of the byte array is filled with zeros.
*
* If the length is set to a value that is smaller than the current
* length, the byte array is truncated.
*/
get length(): number;
/**
* The length of the ByteArray object, in bytes.
*
* If the length is set to a value that is larger than the current
* length, the right side of the byte array is filled with zeros.
*
* If the length is set to a value that is smaller than the current
* length, the byte array is truncated.
*/
set length(value: number);
/**
* The number of bytes of data available for reading from the current
* position in the byte array to the end of the array.
*
* Use the bytesAvailable property in conjunction with the read methods
* each time you access a ByteArray object to ensure that you are
* reading valid data.
*/
get bytesAvailable(): number;
/**
* Clears the contents of the byte array and resets the length and
* position properties to 0. Calling this method explicitly frees up
* the memory used by the ByteArray instance.
*/
clear(): void;
/**
* zlib deflate
*/
compress(): void;
/**
* zlib inflate
*/
uncompress(): void;
/**
* Writes a sequence of length bytes from the specified byte array,
* bytes, starting offset(zero-based index) bytes into the byte stream.
*
* If the length parameter is omitted, the default length of 0 is used;
* the method writes the entire buffer starting at offset. If the
* offset parameter is also omitted, the entire buffer is written.
*
*
*
* If offset or length is out of range, they are clamped to the
* beginning and end of the bytes array.
*
* @param bytes The ByteArray object.
*
* @param offset A zero-based index indicating the position into the
* array to begin writing.
*
* @param length An unsigned integer indicating how far into the buffer
* to write.
*/
writeBytes(bytes: ByteArray, offset?: number, length?: number): void;
/**
* Reads the number of data bytes, specified by the length parameter,
* from the byte stream. The bytes are read into the ByteArray object
* specified by the bytes parameter, and the bytes are written into the
* destination ByteArray starting at the position specified by offset.
*
* @param bytes The ByteArray object to read data into.
*
* @param offset The offset (position) in bytes at which the read data
* should be written.
*
* @param length The number of bytes to read. The default value of 0
* causes all available data to be read.
*/
readBytes(bytes: ByteArray, offset?: number, length?: number): void;
/**
* Writes a Boolean value. A single byte is written according to the
* value parameter, either 1 if true or 0 if false.
*
* @param value A Boolean value determining which byte is written. If
* the parameter is true, the method writes a 1; if false, the
* method writes a 0.
*/
writeBoolean(value: boolean): void;
/**
* Reads a Boolean value from the byte stream. A single byte is read,
* and true is returned if the byte is nonzero, false otherwise.
*
* @return Returns true if the byte is nonzero, false otherwise.
*/
readBoolean(): boolean;
/**
* Writes a byte to the byte stream.
*
* The low 8 bits of the parameter are used. The high 24 bits are
* ignored.
*
* @param value A integer. The low 8 bits are written to the byte
* stream.
*/
writeByte(value: number): void;
/**
* Reads a signed byte from the byte stream.
*
* The returned value is in the range -128 to 127.
*
* @return An integer between -128 and 127.
*/
readByte(): number;
/**
* Reads an unsigned byte from the byte stream.
*
* The returned value is in the range 0 to 255.
*
* @return A 32-bit unsigned integer between 0 and 255.
*/
readUnsignedByte(): number;
/**
* Writes a 16-bit integer to the byte stream. The low 16 bits of the
* parameter are used. The high 16 bits are ignored.
*
* @param value integer, whose low 16 bits are written to the
* byte stream.
*/
writeShort(value: number): void;
/**
* Reads a signed 16-bit integer from the byte stream.
*
* The returned value is in the range -32768 to 32767.
*
* @return A 16-bit signed integer between -32768 and 32767.
*/
readShort(): number;
/**
* Reads an unsigned 16-bit integer from the byte stream.
*
* The returned value is in the range 0 to 65535.
*
* @return A 16-bit unsigned integer between 0 and 65535.
*/
readUnsignedShort(): number;
/**
* Writes a 32-bit integer to the byte stream.
*
* @param value An integer to write to the byte stream.
*/
writeInt(value: number): void;
/**
* Reads a signed 32-bit integer from the byte stream.
*
* The returned value is in the range -2147483648 to 2147483647.
*
* @return A 32-bit signed integer between -2147483648 and 2147483647.
*/
readInt(): number;
/**
* Reads an unsigned 32-bit integer from the byte stream.
*
* The returned value is in the range 0 to 4294967295.
*
* @return A 32-bit unsigned integer between 0 and 4294967295.
*/
readUnsignedInt(): number;
/**
* Writes an IEEE 754 single-precision (32-bit) floating-point number
* to the byte stream.
*
* @param value A single-precision (32-bit) floating-point number.
*/
writeFloat(value: number): void;
/**
* Reads a signed 32-bit integer from the byte stream.
*
* The returned value is in the range -2147483648 to 2147483647.
*
* @return A 32-bit signed integer between -2147483648 and 2147483647.
*/
readFloat(): number;
/**
* Writes an IEEE 754 double-precision (64-bit) floating-point number
* to the byte stream.
*
* @param value A double-precision (64-bit) floating-point number.
*/
writeDouble(value: number): void;
/**
* Reads an IEEE 754 single-precision (32-bit) floating-point number
* from the byte stream.
*
* @return A single-precision (32-bit) floating-point number.
*
* @throws EOFError There is not sufficient data available to
* read.
*/
readDouble(): number;
/**
* Writes a UTF-8 string to the byte stream. The length of the UTF-8
* string in bytes is written first, as a 16-bit integer, followed by
* the bytes representing the characters of the string.
*
* @param value The string value to be written.
*
* @throws RangeError If the length is larger than 65535.
*/
writeUTF(value: string): void;
/**
* Reads a UTF-8 string from the byte stream. The string is assumed to
* be prefixed with an unsigned short indicating the length in bytes.
*
* @return UTF-8 encoded string.
*/
readUTF(): string;
/**
* Writes a UTF-8 string to the byte stream. Similar to the writeUTF()
* method, but writeUTFBytes() does not prefix the string with a 16-bit
* length word.
*
* @param value The string value to be written.
*/
writeUTFBytes(value: string): void;
/**
* Reads a sequence of UTF-8 bytes specified by the length parameter
* from the byte stream and returns a string.
*
* @param length An unsigned short indicating the length of the UTF-8
* bytes.
*
* @return A string composed of the UTF-8 bytes of the specified
* length.
*/
readUTFBytes(length: number): string;
private checkBuffer;
}
declare enum Endian {
/**
* Indicates the most significant byte of the multibyte number appears
* first in the sequence of bytes.
*
* The hexadecimal number 0x12345678 has 4 bytes (2 hexadecimal digits
* per byte). The most significant byte is 0x12. The least significant
* byte is 0x78. (For the equivalent decimal number, 305419896, the
* most significant digit is 3, and the least significant digit is 6).
*
* A stream using the bigEndian byte order (the most significant byte
* first) writes:
*
* 12 34 56 78
*/
BIG_ENDIAN = "bigEndian",
/**
* Indicates the least significant byte of the multibyte number appears
* first in the sequence of bytes.
*
* The hexadecimal number 0x12345678 has 4 bytes (2 hexadecimal digits
* per byte). The most significant byte is 0x12. The least significant
* byte is 0x78. (For the equivalent decimal number, 305419896, the
* most significant digit is 3, and the least significant digit is 6).
*
* A stream using the littleEndian byte order (the least significant
* byte first) writes:
*
* 78 56 34 12
*/
LITTLE_ENDIAN = "littleEndian"
}
export { ByteArray, Endian };