brs-js 1.4.1 → 2.0.2

package/src/{utils.js → utils.ts}

@@ -1,10 +1,14 @@
-import pako from 'pako';
-import punycode from 'punycode';
-import {
-  uuidStringify,
-  uuidParse,
-} from './uuid';
+import { deflate, inflate } from 'pako';
 import { MAX_INT } from './constants';
+import {
+  BRSBytes,
+  Bytes,
+  UnrealColor,
+  UnrealFloat,
+  UnrealType,
+  Uuid,
+} from './types';
+import { uuidParse, uuidStringify } from './uuid';
 
 /*
   Notes:
@@ -16,66 +20,87 @@ import { MAX_INT } from './constants';
  */
 
 // Determine if a string is ascii-only
-function isASCII(str) {
-    return /^[\x00-\x7F]*$/.test(str);
+function isASCII(text: string): boolean {
+  return /^[\x00-\x7F]*$/.test(text);
 }
 
 // convert BGRA color to RGBA color
-const bgra = ([b, g, r, a]) => [r, g, b, a];
+export const bgra = ([b, g, r, a]: number[]): [
+  number,
+  number,
+  number,
+  number
+] => [r, g, b, a];
 
 // Compare equality of byte arrays
-export function isEqual(arrA, arrB) {
-  return arrA.every((a, i) => arrB[i] === a);
+export function isEqual<T>(arrA: Array<T>, arrB: Array<T>): boolean {
+  return arrA.length === arrB.length && arrA.every((a: T, i) => arrB[i] === a);
 }
 
+function isBRSBytes(data: Bytes): data is BRSBytes {
+  return (data as BRSBytes).brsOffset !== undefined;
+}
 
 // read `len` bytes and return slice while updating offset
-function bytes(data, len, isCopy=false) {
+export function subarray(data: Bytes, len: number, isCopy = false): Uint8Array {
   if (!(data instanceof Uint8Array)) {
     throw new Error(`Invalid data type in bytes reader (${typeof data})`);
   }
-  if (typeof data.brsOffset === 'undefined')
-    data.brsOffset = 0;
-  const chunk = data[isCopy ? 'slice' : 'subarray'](data.brsOffset, data.brsOffset + len);
-  chunk.brsOffset = 0;
-  data.brsOffset += len;
+
+  let bytes: BRSBytes;
+  if (!isBRSBytes(data)) {
+    bytes = data as BRSBytes;
+    bytes.brsOffset = 0;
+  } else {
+    bytes = data;
+  }
+
+  const chunk = bytes[isCopy ? 'slice' : 'subarray'](
+    bytes.brsOffset,
+    bytes.brsOffset + len
+  );
+  bytes.brsOffset += len;
   return chunk;
 }
 
 // break a byte array into chunks of a specified size
-function chunk(arr, size) {
-  const out = [];
+export function chunk(arr: Bytes, size: number): BRSBytes[] {
+  // relative length based on the offset of the array's data view
+  const length = arr.length - (isBRSBytes(arr) ? arr.brsOffset : 0);
 
-  for (let i = 0; i < arr.length; i += size) {
-    out.push(bytes(arr, size, true));
+  // out array of chunks pre-allocated
+  const out = Array(Math.floor(length / size));
+
+  for (let i = 0; i < length / size; i++) {
+    out[i] = subarray(arr, size, true);
   }
 
   return out;
 }
 
 // Read a u16 from a byte array
-function read_u16(data, littleEndian=true) {
-  const [a, b] = bytes(data, 2);
+function read_u16(data: Bytes, littleEndian = true): number {
+  const [a, b] = subarray(data, 2);
 
-  return littleEndian ? (b << 8 | a) : (a << 8 | b);
+  return littleEndian ? (b << 8) | a : (a << 8) | b;
 }
 
 // Write a u16 into byte array
-function write_u16(num, littleEndian=true) {
+function write_u16(num: number, littleEndian = true): Uint8Array {
   const data = [num & 255, (num >> 8) & 255];
   return new Uint8Array(!littleEndian ? data.reverse() : data);
 }
 
 // Read an i32 from a byte array
-function read_i32(data, littleEndian=true) {
-  const [a, b, c, d] = bytes(data, 4);
+function read_i32(data: Bytes, littleEndian = true): number {
+  const [a, b, c, d] = subarray(data, 4);
   return littleEndian
-    ? (d << 24 | c << 16 | b << 8 | a)
-    : (a << 24 | b << 16 | c << 8 | d);
+    ? (d << 24) | (c << 16) | (b << 8) | a
+    : (a << 24) | (b << 16) | (c << 8) | d;
 }
 
 // Write an i32 from a byte array
-function write_i32(num, littleEndian=true) {
+function write_i32(num: number, littleEndian = true): Uint8Array {
   const data = new Uint8Array([
     num & 255,
     (num >> 8) & 255,
@@ -87,32 +112,47 @@ function write_i32(num, littleEndian=true) {
 }
 
 // Decompress a byte array of compressed data
-function read_compressed(data) {
+function read_compressed(data: Bytes): Bytes {
   const uncompressedSize = read_i32(data);
   const compressedSize = read_i32(data);
 
   // Throw error for weird compression/uncompression sizes
-  if (compressedSize < 0 || uncompressedSize < 0 || compressedSize >= uncompressedSize) {
-    throw new Error(`Invalid compressed section size (comp: ${compressedSize}, uncomp: ${uncompressedSize})`);
+  if (
+    compressedSize < 0 ||
+    uncompressedSize < 0 ||
+    compressedSize >= uncompressedSize
+  ) {
+    throw new Error(
+      `Invalid compressed section size (comp: ${compressedSize}, uncomp: ${uncompressedSize})`
+    );
   }
 
   // No compressed data? Return those bytes
   if (compressedSize === 0) {
-    return bytes(data, uncompressedSize);
+    return subarray(data, uncompressedSize);
   } else {
     // Decompress the data otherwise
-    const compressed = bytes(data, compressedSize);
-    return pako.inflate(compressed);
+    const compressed = subarray(data, compressedSize);
+    return inflate(compressed);
   }
 }
 
 // Compress a byte array into fewer bytes
-function write_compressed(...args) {
+function write_uncompressed(...args: Uint8Array[]): Uint8Array {
+  // Concat the args to one massive array
+  const data = concat(...args);
+
+  // Build the output
+  return concat(write_i32(data.length), write_i32(0), data);
+}
+
+// Compress a byte array into fewer bytes
+function write_compressed(...args: Uint8Array[]): Uint8Array {
   // Concat the args to one massive array
   const data = concat(...args);
 
   // Do the compression
-  const compressed = pako.deflate(data);
+  const compressed = deflate(data);
   const uncompressedSize = data.length;
   const compressedSize = compressed.length;
 
@@ -121,7 +161,7 @@ function write_compressed(...args) {
   }
 
   if (compressedSize > MAX_INT) {
-    throw new Error(`compressedSize (${compression}) out of range`);
+    throw new Error(`compressedSize (${compressedSize}) out of range`);
   }
 
   // Determine if compression increases size
@@ -131,12 +171,12 @@ function write_compressed(...args) {
   return concat(
     write_i32(uncompressedSize),
     write_i32(badCompress ? 0 : compressedSize),
-    badCompress ? data : compressed,
+    badCompress ? data : compressed
   );
 }
 
 // Read a string from a byte array
-function read_string(data) {
+function read_string(data: Bytes): string {
   const raw_size = read_i32(data);
   const is_ucs2 = raw_size < 0;
   const size = is_ucs2 ? -raw_size : raw_size;
@@ -148,14 +188,13 @@ function read_string(data) {
     }
 
     // Create ucs2 encoded string
-    return punycode.ucs2.encode(
+    return String.fromCodePoint(
       // Read the data in 2 byte windows
-      chunk(bytes(data, size), 2)
-        .map(arr => read_u16(arr)) // Convert the two bytes into u16
+      ...chunk(subarray(data, size), 2).map(arr => read_u16(arr)) // Convert the two bytes into u16
     );
   } else {
     // Read the data, remove the \u0000 at the end :)
-    const strData = bytes(data, size).subarray(0, -1);
+    const strData = subarray(data, size).subarray(0, -1);
 
     // Convert into ascii
     return String.fromCharCode.apply(null, strData);
@@ -163,46 +202,48 @@ function read_string(data) {
 }
 
 // Write a string to bytes
-function write_string(str) {
+function write_string(str: string): Uint8Array {
   if (isASCII(str)) {
     return concat(
       write_i32(str.length + 1), // Write string length (+ null term)
       new Uint8Array(str.split('').map(s => s.charCodeAt(0))), // Write string as bytes
-      new Uint8Array([0]), // Null terminator
+      new Uint8Array([0]) // Null terminator
     );
   } else {
     // ucs2 strings denoted by negative length
     const len = -((str.length + 1) * 2);
     return concat(
       write_i32(len), // write length
-      punycode.ucs2.decode(str), // write decoded string
-      new Uint8Array([0]), // Null terminator
-    )
+      // convert string to little endian ucs2
+      new Uint8Array(
+        str
+          .split('')
+          .flatMap(s => [s.charCodeAt(0) & 0xff, s.charCodeAt(0) >> 8])
+      ),
+      new Uint8Array([0]) // Null terminator
+    );
   }
 }
 
 // Read uuid from 4 LE ints
-function read_uuid(data) {
-  return uuidStringify(chunk(bytes(data, 16), 4)
-    .flatMap(arr => {
-      arr.reverse();
-      return Array.from(arr);
-    })); // each chunk is LE
+function read_uuid(data: Bytes): string {
+  return uuidStringify(
+    // each chunk is LE
+    chunk(subarray(data, 16), 4).flatMap(([a, b, c, d]) => [d, c, b, a])
+  );
 }
 
 // parse a uuid into 4 LE ints
-function write_uuid(uuid) {
+function write_uuid(uuid: Uuid) {
   return concat(
-    ...chunk(uuidParse(uuid), 4)
-    .map(arr => {
-      arr.reverse(); // convert into 4 LE ints;
-      return new Uint8Array(arr);
-    })
+    ...chunk(uuidParse(uuid), 4).map(
+      ([a, b, c, d]) => new Uint8Array([d, c, b, a])
+    )
   );
 }
 
 // Read an array of things given a fn
-function read_array(data, fn) {
+function read_array<T>(data: Bytes, fn: (_: Bytes) => T): T[] {
   const length = read_i32(data);
   const arr = Array(length);
   for (let i = 0; i < length; i++) {
@@ -212,7 +253,7 @@ function read_array(data, fn) {
 }
 
 // iterate an array of things given a fn
-function read_each(data, fn) {
+function read_each(data: Bytes, fn: (_: Bytes) => void) {
   const length = read_i32(data);
   for (let i = 0; i < length; i++) {
     fn(data);
@@ -220,26 +261,25 @@ function read_each(data, fn) {
 }
 
 // Write an array of things to bytes
-function write_array(arr, fn) {
-  return concat(
-    write_i32(arr.length),
-    ...arr.map(o => fn(o))
-  );
+function write_array<T>(arr: T[], fn: (_: T) => Uint8Array) {
+  return concat(write_i32(arr.length), ...arr.map(o => fn(o)));
 }
 
 // Tool for reading byte arrays 1 bit at a time
 class BitReader {
-  constructor(data) {
-    this.buffer = new Uint8Array(data);
-    this.pos = 0;
+  buffer: Uint8Array;
+  pos: number = 0;
+
+  constructor(data: Uint8Array) {
+    this.buffer = data;
   }
 
-  empty() {
+  empty(): boolean {
     return this.pos >= this.buffer.length * 8;
   }
 
   // Read one bit as a boolean
-  bit() {
+  bit(): boolean {
     const bit = (this.buffer[this.pos >> 3] & (1 << (this.pos & 0b111))) !== 0;
     this.pos++;
     return bit;
@@ -251,7 +291,7 @@ class BitReader {
   }
 
   // read an int up to max
-  int(max) {
+  int(max: number): number {
     let value = 0;
     let mask = 1;
 
@@ -266,7 +306,7 @@ class BitReader {
   }
 
   // read a packet in from bits
-  uint_packed() {
+  uint_packed(): number {
     let value = 0;
     for (let i = 0; i < 5; i++) {
       const next = this.bit();
@@ -285,58 +325,59 @@ class BitReader {
   }
 
   // an item in a read_positive_int_vector array
-  int_packed() {
+  int_packed(): number {
     const value = this.uint_packed();
-    return (value >> 1) * (value & 1 !== 0 ? 1 : -1);
+    return (value >> 1) * ((value & 1) !== 0 ? 1 : -1);
   }
 
   // read some bits
-  bits(num) {
-    const arr = [];
+  bits(num: number): number[] {
+    const arr: number[] = [];
     for (let bit = 0; bit < num; bit++) {
       const shift = bit & 7;
-      arr[bit >> 3] = (arr[bit >> 3] & ~(1 << shift)) | ((this.bit() ? 1 : 0) << shift);
+      arr[bit >> 3] =
+        (arr[bit >> 3] & ~(1 << shift)) | ((this.bit() ? 1 : 0) << shift);
     }
     return arr;
   }
 
   // Read some bytes
-  bytes(num) {
-    return new Uint8Array(this.bits(num * 8));
+  bytes(num: number): Uint8Array {
+    return new Uint8Array(this.bytesArr(num));
   }
 
   // read some bytes but not as a Uint8Array
-  bytesArr(num) {
+  bytesArr(num: number): number[] {
     return this.bits(num * 8);
   }
 
   // read an array
-  array(fn) {
+  array<T>(fn: (_: BitReader) => T): T[] {
     const length = read_i32(this.bytes(4));
     const arr = Array(length);
-    for(let i = 0; i < length; i++) {
+    for (let i = 0; i < length; i++) {
       arr[i] = fn(this);
     }
     return arr;
   }
 
   // for each
-  each(fn) {
+  each(fn: (data: BitReader) => void) {
     const length = read_i32(this.bytes(4));
-    for(let i = 0; i < length; i++) {
+    for (let i = 0; i < length; i++) {
       fn(this);
     }
   }
 
   // read a string
-  string() {
+  string(): string {
     const lenBytes = this.bytesArr(4);
     const len = read_i32(new Uint8Array(lenBytes));
     return read_string(new Uint8Array(lenBytes.concat(this.bytesArr(len))));
   }
 
   // read a 32-bit float
-  float() {
+  float(): number {
     const view = new DataView(new ArrayBuffer(4));
 
     // Write the ints to it
@@ -349,35 +390,33 @@ class BitReader {
   }
 
   // read unreal types
-  unreal(type) {
-   switch(type) {
-    case 'Class': case 'Object':
-      return this.string();
-    case 'Boolean':
-      return !!read_i32(new Uint8Array(this.bytes(4)));
-    case 'Float':
-      return this.float();
-    case 'Color':
-      return bgra(this.bytes(4));
-    case 'Byte':
-      return this.bytes(1)[0];
-    case 'Rotator':
-      return [this.float(), this.float(), this.float()];
+  unreal(type: string): UnrealType {
+    switch (type) {
+      case 'Class':
+      case 'Object':
+        return this.string();
+      case 'Boolean':
+        return !!read_i32(this.bytes(4));
+      case 'Float':
+        return this.float();
+      case 'Color':
+        return bgra(this.bytesArr(4)) as UnrealColor;
+      case 'Byte':
+        return this.bytes(1)[0];
+      case 'Rotator':
+        return [this.float(), this.float(), this.float()];
     }
     throw new Error('Unknown unreal type ' + type);
   }
 }
 
 class BitWriter {
-  constructor() {
-    this.buffer = [];
-    this.cur = 0;
-    this.bitNum = 0;
-
-  }
+  buffer: number[] = [];
+  cur: number = 0;
+  bitNum: number = 0;
 
   // Write a boolean as a bit
-  bit(val) {
+  bit(val: boolean) {
     this.cur |= (val ? 1 : 0) << this.bitNum;
     this.bitNum++;
     if (this.bitNum >= 8) {
@@ -386,14 +425,14 @@ class BitWriter {
   }
 
   // Write `len` bits from `src` bytes
-  bits(src, len) {
+  bits(src: number[] | Uint8Array, len: number) {
     for (let bit = 0; bit < len; bit++) {
       this.bit((src[bit >> 3] & (1 << (bit & 7))) !== 0);
     }
   }
 
   // Write multiple bytes
-  bytes(src) {
+  bytes(src: number[] | Uint8Array) {
     this.bits(src, 8 * src.length);
   }
 
@@ -407,19 +446,23 @@ class BitWriter {
   }
 
   // Write an int up to the potential max size
-  int(value, max) {
+  int(value: number, max: number) {
     if (max < 2) {
-      throw new Error(`Invalid input (BitWriter) -- max (${max}) must be at least 2`)
+      throw new Error(
+        `Invalid input (BitWriter) -- max (${max}) must be at least 2`
+      );
     }
 
     if (value >= max) {
-      throw new Error(`Invalid input (BitWriter) -- value (${value}) is larger than max (${max})`)
+      throw new Error(
+        `Invalid input (BitWriter) -- value (${value}) is larger than max (${max})`
+      );
     }
 
     let new_val = 0;
     let mask = 1;
 
-    while ((new_val + mask) < max && mask !== 0) {
+    while (new_val + mask < max && mask !== 0) {
       this.bit((value & mask) !== 0);
       if ((value & mask) !== 0) {
         new_val |= mask;
@@ -430,7 +473,7 @@ class BitWriter {
   }
 
   // Write a packed unsigned int
-  uint_packed(value) {
+  uint_packed(value: number) {
     do {
       const src = value & 0b1111111;
       value >>= 7;
@@ -440,26 +483,28 @@ class BitWriter {
   }
 
   // Write a packed integer
-  int_packed(value) {
+  int_packed(value: number) {
     this.uint_packed((Math.abs(value) << 1) | (value >= 0 ? 1 : 0));
   }
 
   // Return built buffer
-  finish() {
+  finish(): Uint8Array {
     this.align();
-    return this.buffer;
+    return new Uint8Array(this.buffer);
   }
 
   // Return built buffer (and include length)
   finishSection() {
     this.align();
-    return concat(write_i32(this.buffer.length), this.buffer);
+    return concat(write_i32(this.buffer.length), new Uint8Array(this.buffer));
   }
 
   // write a string
-  string(str) { this.bytes(write_string(str)); }
+  string(str: string) {
+    this.bytes(write_string(str));
+  }
 
-  float(num) {
+  float(num: UnrealFloat) {
     // create a float array
     const floatArr = new Float32Array(1);
     // assign the number
@@ -469,96 +514,110 @@ class BitWriter {
     this.bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
   }
 
-  // use
-  self(fn) {
+  // run a function with `this` as a BitReader
+  self(fn: (this: BitWriter) => void) {
     fn.bind(this)();
     return this;
   }
 
   // write an array
-  array(arr, fn) {
+  array<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {
     this.bytes(write_i32(arr.length));
     arr.forEach(fn.bind(this));
     return this;
   }
 
   // write things from an array
-  each(arr, fn) {
+  each<T>(arr: T[], fn: (this: BitWriter, item: T, index: number) => void) {
     arr.forEach(fn.bind(this));
     return this;
   }
 
   // write unreal types
-  unreal(type, value) {
-   switch(type) {
-    case 'Class':
-      if (typeof value !== 'string') {
-        throw new Error(`writing unreal type Class, did not receive string (${value})`);
-      }
-      this.string(value);
-      return;
-    case 'Object':
-      if (typeof value !== 'string') {
-        throw new Error(`writing unreal type Object, did not receive string (${value})`);
-      }
-      this.string(value);
-      return;
-    case 'Boolean':
-      if (typeof value !== 'boolean') {
-        throw new Error(`writing unreal type Boolean, did not receive boolean (${value})`);
-      }
-      this.bytes(write_i32(value ? 1 : 0));
-      return;
-    case 'Float':
-      if (typeof value !== 'number') {
-        throw new Error(`writing unreal type Float, did not receive float (${value})`);
-      }
-      this.float(value);
-      return;
-    case 'Byte':
-      if (typeof value !== 'number') {
-        throw new Error(`writing unreal type Byte, did not receive Byte (${value})`);
-      }
-      this.bytes([value & 255]);
-      return;
-    case 'Color':
-      if (typeof value !== 'object' && value.length === 4) {
-        throw new Error(`writing unreal type Array, did not receive Array (${value})`);
-      }
-      this.bytes(bgra(value));
-      return;
-    case 'Rotator':
-      if (typeof value !== 'object' && value.length === 3) {
-        throw new Error(`writing unreal type Array, did not receive Array (${value})`);
-      }
-
-      this.float(value[0]);
-      this.float(value[1]);
-      this.float(value[2]);
-      return;
+  unreal(type: string, value: UnrealType) {
+    switch (type) {
+      case 'Class':
+        if (typeof value !== 'string') {
+          throw new Error(
+            `writing unreal type Class, did not receive string (${value})`
+          );
+        }
+        this.string(value);
+        return;
+      case 'Object':
+        if (typeof value !== 'string') {
+          throw new Error(
+            `writing unreal type Object, did not receive string (${value})`
+          );
+        }
+        this.string(value);
+        return;
+      case 'Boolean':
+        if (typeof value !== 'boolean') {
+          throw new Error(
+            `writing unreal type Boolean, did not receive boolean (${value})`
+          );
+        }
+        this.bytes(write_i32(value ? 1 : 0));
+        return;
+      case 'Float':
+        if (typeof value !== 'number') {
+          throw new Error(
+            `writing unreal type Float, did not receive float (${value})`
+          );
+        }
+        this.float(value);
+        return;
+      case 'Byte':
+        if (typeof value !== 'number') {
+          throw new Error(
+            `writing unreal type Byte, did not receive Byte (${value})`
+          );
+        }
+        this.bytes([value & 255]);
+        return;
+      case 'Color':
+        if (!Array.isArray(value) || value.length !== 4) {
+          throw new Error(
+            `writing unreal type Array, did not receive Array (${value})`
+          );
+        }
+        this.bytes(bgra(value));
+        return;
+      case 'Rotator':
+        if (!Array.isArray(value) || value.length !== 3) {
+          throw new Error(
+            `writing unreal type Array, did not receive Array (${value})`
+          );
+        }
+
+        this.float(value[0]);
+        this.float(value[1]);
+        this.float(value[2]);
+        return;
     }
     throw new Error('Unknown unreal type ' + type);
   }
 }
 
 // concat uint8arrays together
-export function concat(...arrays) {
+export function concat(...arrays: Uint8Array[]): Uint8Array {
   const buffLen = arrays.reduce((sum, value) => sum + value.length, 0);
   const buff = new Uint8Array(buffLen);
 
   // for each array - copy it over buff
   // next array is copied right after the previous one
   let length = 0;
-  for(const array of arrays) {
+  for (const array of arrays) {
     buff.set(array, length);
     length += array.length;
   }
 
   return buff;
-};
+}
 
 export const read = {
-  bytes,
+  bytes: subarray,
   u16: read_u16,
   i32: read_i32,
   compressed: read_compressed,
@@ -566,15 +625,16 @@ export const read = {
   uuid: read_uuid,
   array: read_array,
   each: read_each,
-  bits: data => new BitReader(data),
+  bits: (data: Bytes) => new BitReader(data),
 };
 
 export const write = {
   u16: write_u16,
   i32: write_i32,
   compressed: write_compressed,
+  uncompressed: write_uncompressed,
   string: write_string,
   uuid: write_uuid,
   array: write_array,
-  bits: data => new BitWriter(),
+  bits: () => new BitWriter(),
 };