Define Error subclasses differently for better TS definitions

Custom exception classes are now defined in a more idiomatic way - this
approach was adopted from https://stackoverflow.com/a/68201883

In the generated JavaScript code, this commit only causes cosmetic
changes that don't affect the observable behavior. However, it improves
the quality of the generated TypeScript definitions - see the comparison
below.

Before:

```ts
    static EOFError: {
        new (bytesReq: number, bytesAvail: number): {
            name: string;
            bytesReq: number;
            bytesAvail: number;
            message: string;
            stack?: string;
        };
        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
        stackTraceLimit: number;
    };
```

Now:

```ts
    class EOFError extends Error {
        name: string;
        bytesReq: number;
        bytesAvail: number;
        /**
         * @param bytesReq The number of bytes requested.
         * @param bytesAvail The number of bytes available.
         */
        constructor(bytesReq: number, bytesAvail: number);
    }
```

Author: generalmimon

KaitaiStream.ts

@@ -977,7 +977,57 @@ class KaitaiStream {
   // Internal implementation details
   // ========================================================================
 
-  public static EOFError = class EOFError extends Error {
+  /**
+   * Ensures that we have at least `length` bytes left in the stream.
+   * If not, throws an EOFError.
+   *
+   * @param length Number of bytes to require.
+   * @throws {KaitaiStream.EOFError}
+   */
+  protected ensureBytesLeft(length: number): void {
+    if (this.pos + length > this.size) {
+      throw new KaitaiStream.EOFError(length, this.size - this.pos);
+    }
+  }
+
+  /**
+   * Maps a Uint8Array into the KaitaiStream buffer.
+   * Nice for quickly reading in data.
+   *
+   * @param length Number of elements to map.
+   * @returns A Uint8Array to the KaitaiStream backing buffer.
+   */
+  protected mapUint8Array(length: number): Uint8Array {
+    length |= 0;
+
+    this.ensureBytesLeft(length);
+
+    const arr = new Uint8Array(this._buffer, this.byteOffset + this.pos, length);
+    this.pos += length;
+    return arr;
+  }
+
+  /**
+   * Creates an array from an array of character codes.
+   * Uses String.fromCharCode in chunks for memory efficiency and then concatenates
+   * the resulting string chunks.
+   *
+   * @param array Array of character codes.
+   * @returns String created from the character codes.
+   */
+  protected static createStringFromArray(array: Uint8Array): string {
+    const chunk_size = 0x8000;
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunk_size) {
+      const chunk = array.subarray(i, i + chunk_size);
+      chunks.push(String.fromCharCode.apply(null, chunk));
+    }
+    return chunks.join("");
+  }
+}
+
+namespace KaitaiStream {
+  export class EOFError extends Error {
     public name = "EOFError";
     public bytesReq: number;
     public bytesAvail: number;
@@ -998,7 +1048,7 @@ class KaitaiStream {
   /**
    * Unused since Kaitai Struct Compiler v0.9+ - compatibility with older versions.
    */
-  public static UnexpectedDataError = class UnexpectedDataError extends Error {
+  export class UnexpectedDataError extends Error {
     public name = "UnexpectedDataError";
     public expected: any;
     public actual: any;
@@ -1016,7 +1066,7 @@ class KaitaiStream {
     }
   };
 
-  public static UndecidedEndiannessError = class UndecidedEndiannessError extends Error {
+  export class UndecidedEndiannessError extends Error {
     public name = "UndecidedEndiannessError";
 
     public constructor() {
@@ -1026,7 +1076,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationNotEqualError = class ValidationNotEqualError extends Error {
+  export class ValidationNotEqualError extends Error {
     public name = "ValidationNotEqualError";
     public expected: any;
     public actual: any;
@@ -1044,7 +1094,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationLessThanError = class ValidationLessThanError extends Error {
+  export class ValidationLessThanError extends Error {
     public name = "ValidationLessThanError";
     public min: any;
     public actual: any;
@@ -1062,7 +1112,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationGreaterThanError = class ValidationGreaterThanError extends Error {
+  export class ValidationGreaterThanError extends Error {
     public name = "ValidationGreaterThanError";
     public max: any;
     public actual: any;
@@ -1080,7 +1130,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationNotAnyOfError = class ValidationNotAnyOfError extends Error {
+  export class ValidationNotAnyOfError extends Error {
     public name = "ValidationNotAnyOfError";
     public actual: any;
 
@@ -1095,7 +1145,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationNotInEnumError = class ValidationNotInEnumError extends Error {
+  export class ValidationNotInEnumError extends Error {
     public name = "ValidationNotInEnumError";
     public actual: any;
 
@@ -1110,7 +1160,7 @@ class KaitaiStream {
     }
   };
 
-  public static ValidationExprError = class ValidationExprError extends Error {
+  export class ValidationExprError extends Error {
     public name = "ValidationExprError";
     public actual: any;
 
@@ -1124,54 +1174,6 @@ class KaitaiStream {
       this.actual = actual;
     }
   };
-
-  /**
-   * Ensures that we have at least `length` bytes left in the stream.
-   * If not, throws an EOFError.
-   *
-   * @param length Number of bytes to require.
-   * @throws {KaitaiStream.EOFError}
-   */
-  protected ensureBytesLeft(length: number): void {
-    if (this.pos + length > this.size) {
-      throw new KaitaiStream.EOFError(length, this.size - this.pos);
-    }
-  }
-
-  /**
-   * Maps a Uint8Array into the KaitaiStream buffer.
-   * Nice for quickly reading in data.
-   *
-   * @param length Number of elements to map.
-   * @returns A Uint8Array to the KaitaiStream backing buffer.
-   */
-  protected mapUint8Array(length: number): Uint8Array {
-    length |= 0;
-
-    this.ensureBytesLeft(length);
-
-    const arr = new Uint8Array(this._buffer, this.byteOffset + this.pos, length);
-    this.pos += length;
-    return arr;
-  }
-
-  /**
-   * Creates an array from an array of character codes.
-   * Uses String.fromCharCode in chunks for memory efficiency and then concatenates
-   * the resulting string chunks.
-   *
-   * @param array Array of character codes.
-   * @returns String created from the character codes.
-   */
-  protected static createStringFromArray(array: Uint8Array): string {
-    const chunk_size = 0x8000;
-    const chunks = [];
-    for (let i = 0; i < array.length; i += chunk_size) {
-      const chunk = array.subarray(i, i + chunk_size);
-      chunks.push(String.fromCharCode.apply(null, chunk));
-    }
-    return chunks.join("");
-  }
 }
 
 export default KaitaiStream;