rw-parser-ng 2.1.1 → 2.3.0

package/lib/codecs/dxt.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bc1 = bc1;
+exports.bc2 = bc2;
+exports.bc3 = bc3;
+var color_1 = require("./color");
+function bc1(data, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    var colorPalette = new Uint8Array(16);
+    var offset = 0;
+    for (var y = 0; y < height; y += 4) {
+        for (var x = 0; x < width; x += 4) {
+            var color0 = (0, color_1.readUInt16LE)(data, offset);
+            var color1 = (0, color_1.readUInt16LE)(data, offset + 2);
+            var colorBits = (0, color_1.readUInt32LE)(data, offset + 4);
+            offset += 8;
+            var _a = (0, color_1.decode565)(color0), c0r = _a[0], c0g = _a[1], c0b = _a[2];
+            var _b = (0, color_1.decode565)(color1), c1r = _b[0], c1g = _b[1], c1b = _b[2];
+            colorPalette[0] = c0r;
+            colorPalette[1] = c0g;
+            colorPalette[2] = c0b;
+            colorPalette[4] = c1r;
+            colorPalette[5] = c1g;
+            colorPalette[6] = c1b;
+            if (color0 > color1) {
+                colorPalette[8] = (2 * c0r + c1r) / 3;
+                colorPalette[9] = (2 * c0g + c1g) / 3;
+                colorPalette[10] = (2 * c0b + c1b) / 3;
+                colorPalette[12] = (c0r + 2 * c1r) / 3;
+                colorPalette[13] = (c0g + 2 * c1g) / 3;
+                colorPalette[14] = (c0b + 2 * c1b) / 3;
+            }
+            else {
+                colorPalette[8] = (c0r + c1r) >> 1;
+                colorPalette[9] = (c0g + c1g) >> 1;
+                colorPalette[10] = (c0b + c1b) >> 1;
+                colorPalette[12] = 0;
+                colorPalette[13] = 0;
+                colorPalette[14] = 0;
+            }
+            var baseIndex = (y * width + x) * 4;
+            for (var k = 0; k < 16; k++) {
+                var colorIdx = colorBits & 0x3;
+                colorBits >>>= 2;
+                var j = k >> 2, i = k & 3;
+                var idx = baseIndex + ((j * width + i) << 2);
+                rgba[idx] = colorPalette[colorIdx * 4];
+                rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+                rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+                rgba[idx + 3] = color0 <= color1 && colorIdx === 3 ? 0 : 255;
+            }
+        }
+    }
+    return rgba;
+}
+function bc2(data, width, height, premultiplied) {
+    var rgba = new Uint8Array(4 * width * height);
+    var colorPalette = new Uint8Array(16);
+    var alphaTable = new Uint8Array(16);
+    for (var i = 0; i < 16; i++)
+        alphaTable[i] = ((i * 255 + 7.5) / 15) | 0;
+    var offset = 0;
+    for (var y = 0; y < height; y += 4) {
+        for (var x = 0; x < width; x += 4) {
+            var alpha0 = (0, color_1.readUInt32LE)(data, offset);
+            var alpha1 = (0, color_1.readUInt32LE)(data, offset + 4);
+            offset += 8;
+            var color0 = (0, color_1.readUInt16LE)(data, offset);
+            var color1 = (0, color_1.readUInt16LE)(data, offset + 2);
+            var colorBits = (0, color_1.readUInt32LE)(data, offset + 4);
+            offset += 8;
+            var _a = (0, color_1.decode565)(color0), c0r = _a[0], c0g = _a[1], c0b = _a[2];
+            var _b = (0, color_1.decode565)(color1), c1r = _b[0], c1g = _b[1], c1b = _b[2];
+            colorPalette[0] = c0r;
+            colorPalette[1] = c0g;
+            colorPalette[2] = c0b;
+            colorPalette[4] = c1r;
+            colorPalette[5] = c1g;
+            colorPalette[6] = c1b;
+            if (color0 > color1) {
+                colorPalette[8] = (2 * c0r + c1r) / 3;
+                colorPalette[9] = (2 * c0g + c1g) / 3;
+                colorPalette[10] = (2 * c0b + c1b) / 3;
+                colorPalette[12] = (c0r + 2 * c1r) / 3;
+                colorPalette[13] = (c0g + 2 * c1g) / 3;
+                colorPalette[14] = (c0b + 2 * c1b) / 3;
+            }
+            else {
+                colorPalette[8] = (c0r + c1r) >> 1;
+                colorPalette[9] = (c0g + c1g) >> 1;
+                colorPalette[10] = (c0b + c1b) >> 1;
+                colorPalette[12] = 0;
+                colorPalette[13] = 0;
+                colorPalette[14] = 0;
+            }
+            var baseIndex = (y * width + x) << 2;
+            for (var k = 0; k < 16; k++) {
+                var j = k >> 2, i = k & 3;
+                var idx = baseIndex + ((j * width + i) << 2);
+                var colorIdx = colorBits & 0x3;
+                colorBits >>>= 2;
+                var bitPos = (j << 2) + i;
+                var byteIndex = bitPos >> 3;
+                var shift = (bitPos & 7) << 2;
+                var alpha4 = ((byteIndex === 0 ? alpha0 : alpha1) >>> shift) & 0xf;
+                var alpha = alphaTable[alpha4];
+                rgba[idx] = colorPalette[colorIdx * 4];
+                rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+                rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+                rgba[idx + 3] = alpha;
+                if (premultiplied && alpha > 0 && alpha < 255) {
+                    var factor = 255 / alpha;
+                    rgba[idx] = Math.min(255, Math.round(rgba[idx] * factor));
+                    rgba[idx + 1] = Math.min(255, Math.round(rgba[idx + 1] * factor));
+                    rgba[idx + 2] = Math.min(255, Math.round(rgba[idx + 2] * factor));
+                }
+            }
+        }
+    }
+    return rgba;
+}
+function bc3(data, width, height, premultiplied) {
+    var rgba = new Uint8Array(4 * width * height);
+    var alphaPalette = new Uint8Array(8);
+    var colorPalette = new Uint8Array(16);
+    var alphaIndices = new Uint8Array(16);
+    var offset = 0;
+    for (var y = 0; y < height; y += 4) {
+        for (var x = 0; x < width; x += 4) {
+            var alpha0 = data[offset++];
+            var alpha1 = data[offset++];
+            var alphaBits = data.subarray(offset, offset + 6);
+            offset += 6;
+            var color0 = (0, color_1.readUInt16LE)(data, offset);
+            var color1 = (0, color_1.readUInt16LE)(data, offset + 2);
+            var colorBits = (0, color_1.readUInt32LE)(data, offset + 4);
+            offset += 8;
+            var _a = (0, color_1.decode565)(color0), c0r = _a[0], c0g = _a[1], c0b = _a[2];
+            var _b = (0, color_1.decode565)(color1), c1r = _b[0], c1g = _b[1], c1b = _b[2];
+            colorPalette[0] = c0r;
+            colorPalette[1] = c0g;
+            colorPalette[2] = c0b;
+            colorPalette[4] = c1r;
+            colorPalette[5] = c1g;
+            colorPalette[6] = c1b;
+            if (color0 > color1) {
+                colorPalette[8] = (2 * c0r + c1r) / 3;
+                colorPalette[9] = (2 * c0g + c1g) / 3;
+                colorPalette[10] = (2 * c0b + c1b) / 3;
+                colorPalette[12] = (c0r + 2 * c1r) / 3;
+                colorPalette[13] = (c0g + 2 * c1g) / 3;
+                colorPalette[14] = (c0b + 2 * c1b) / 3;
+            }
+            else {
+                colorPalette[8] = (c0r + c1r) >> 1;
+                colorPalette[9] = (c0g + c1g) >> 1;
+                colorPalette[10] = (c0b + c1b) >> 1;
+                colorPalette[12] = 0;
+                colorPalette[13] = 0;
+                colorPalette[14] = 0;
+            }
+            if (alpha0 > alpha1) {
+                alphaPalette[0] = alpha0;
+                alphaPalette[1] = alpha1;
+                alphaPalette[2] = (alpha0 * 6 + alpha1 + 3) / 7;
+                alphaPalette[3] = (alpha0 * 5 + alpha1 * 2 + 3) / 7;
+                alphaPalette[4] = (alpha0 * 4 + alpha1 * 3 + 3) / 7;
+                alphaPalette[5] = (alpha0 * 3 + alpha1 * 4 + 3) / 7;
+                alphaPalette[6] = (alpha0 * 2 + alpha1 * 5 + 3) / 7;
+                alphaPalette[7] = (alpha0 + alpha1 * 6 + 3) / 7;
+            }
+            else {
+                alphaPalette[0] = alpha0;
+                alphaPalette[1] = alpha1;
+                alphaPalette[2] = (alpha0 * 4 + alpha1 + 2) / 5;
+                alphaPalette[3] = (alpha0 * 3 + alpha1 * 2 + 2) / 5;
+                alphaPalette[4] = (alpha0 * 2 + alpha1 * 3 + 2) / 5;
+                alphaPalette[5] = (alpha0 + alpha1 * 4 + 2) / 5;
+                alphaPalette[6] = 0;
+                alphaPalette[7] = 255;
+            }
+            for (var k = 0; k < 16; k++) {
+                var bitOffset = k * 3;
+                var byteOffset = bitOffset >> 3;
+                var shift = bitOffset & 7;
+                alphaIndices[k] =
+                    shift <= 5
+                        ? (alphaBits[byteOffset] >> shift) & 0x7
+                        : ((alphaBits[byteOffset] >> shift) | (alphaBits[byteOffset + 1] << (8 - shift))) & 0x7;
+            }
+            var baseIndex = (y * width + x) << 2;
+            for (var k = 0; k < 16; k++) {
+                var j = k >> 2, i = k & 3;
+                var idx = baseIndex + ((j * width + i) << 2);
+                var colorIdx = colorBits & 0x3;
+                colorBits >>>= 2;
+                var alpha = alphaPalette[alphaIndices[k] & 0x7];
+                rgba[idx] = colorPalette[colorIdx * 4];
+                rgba[idx + 1] = colorPalette[colorIdx * 4 + 1];
+                rgba[idx + 2] = colorPalette[colorIdx * 4 + 2];
+                rgba[idx + 3] = alpha;
+                if (premultiplied && alpha > 0 && alpha < 255) {
+                    var factor = 255 / alpha;
+                    rgba[idx] = Math.min(255, Math.round(rgba[idx] * factor));
+                    rgba[idx + 1] = Math.min(255, Math.round(rgba[idx + 1] * factor));
+                    rgba[idx + 2] = Math.min(255, Math.round(rgba[idx + 2] * factor));
+                }
+            }
+        }
+    }
+    return rgba;
+}

package/lib/codecs/formats.d.ts

@@ -0,0 +1,25 @@
+export declare enum RasterFormat {
+    RASTER_1555 = 256,
+    RASTER_565 = 512,
+    RASTER_4444 = 768,
+    RASTER_LUM = 1024,
+    RASTER_8888 = 1280,
+    RASTER_888 = 1536,
+    RASTER_555 = 2560
+}
+export declare enum D3DFormat {
+    D3DFMT_A8L8 = "3",
+    D3D_DXT1 = "DXT1",
+    D3D_DXT2 = "DXT2",
+    D3D_DXT3 = "DXT3",
+    D3D_DXT4 = "DXT4",
+    D3D_DXT5 = "DXT5"
+}
+export declare enum PaletteType {
+    PALETTE_NONE = 0,
+    PALETTE_8 = 1
+}
+export declare enum PlatformType {
+    D3D8 = 8,
+    D3D9 = 9
+}

package/lib/codecs/formats.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformType = exports.PaletteType = exports.D3DFormat = exports.RasterFormat = void 0;
+var RasterFormat;
+(function (RasterFormat) {
+    RasterFormat[RasterFormat["RASTER_1555"] = 256] = "RASTER_1555";
+    RasterFormat[RasterFormat["RASTER_565"] = 512] = "RASTER_565";
+    RasterFormat[RasterFormat["RASTER_4444"] = 768] = "RASTER_4444";
+    RasterFormat[RasterFormat["RASTER_LUM"] = 1024] = "RASTER_LUM";
+    RasterFormat[RasterFormat["RASTER_8888"] = 1280] = "RASTER_8888";
+    RasterFormat[RasterFormat["RASTER_888"] = 1536] = "RASTER_888";
+    RasterFormat[RasterFormat["RASTER_555"] = 2560] = "RASTER_555";
+})(RasterFormat || (exports.RasterFormat = RasterFormat = {}));
+var D3DFormat;
+(function (D3DFormat) {
+    D3DFormat["D3DFMT_A8L8"] = "3";
+    D3DFormat["D3D_DXT1"] = "DXT1";
+    D3DFormat["D3D_DXT2"] = "DXT2";
+    D3DFormat["D3D_DXT3"] = "DXT3";
+    D3DFormat["D3D_DXT4"] = "DXT4";
+    D3DFormat["D3D_DXT5"] = "DXT5";
+})(D3DFormat || (exports.D3DFormat = D3DFormat = {}));
+var PaletteType;
+(function (PaletteType) {
+    PaletteType[PaletteType["PALETTE_NONE"] = 0] = "PALETTE_NONE";
+    PaletteType[PaletteType["PALETTE_8"] = 1] = "PALETTE_8";
+})(PaletteType || (exports.PaletteType = PaletteType = {}));
+var PlatformType;
+(function (PlatformType) {
+    PlatformType[PlatformType["D3D8"] = 8] = "D3D8";
+    PlatformType[PlatformType["D3D9"] = 9] = "D3D9";
+})(PlatformType || (exports.PlatformType = PlatformType = {}));

package/lib/codecs/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./bitmap";
+export * from "./color";
+export * from "./dxt";
+export * from "./formats";
+export * from "./palette";

package/lib/codecs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bitmap"), exports);
+__exportStar(require("./color"), exports);
+__exportStar(require("./dxt"), exports);
+__exportStar(require("./formats"), exports);
+__exportStar(require("./palette"), exports);

package/lib/codecs/palette.d.ts

@@ -0,0 +1,6 @@
+export declare function lum8(data: Uint8Array, width: number, height: number): Uint8Array;
+export declare function lum8a8(data: Uint8Array, width: number, height: number): Uint8Array;
+export declare function pal4(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+export declare function pal4NoAlpha(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+export declare function pal8(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+export declare function pal8NoAlpha(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;

package/lib/codecs/palette.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lum8 = lum8;
+exports.lum8a8 = lum8a8;
+exports.pal4 = pal4;
+exports.pal4NoAlpha = pal4NoAlpha;
+exports.pal8 = pal8;
+exports.pal8NoAlpha = pal8NoAlpha;
+function lum8(data, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    for (var i = 0; i < data.length; i++) {
+        var offset = i * 4;
+        var lum = data[i];
+        rgba[offset] = lum;
+        rgba[offset + 1] = lum;
+        rgba[offset + 2] = lum;
+        rgba[offset + 3] = 0xff;
+    }
+    return rgba;
+}
+function lum8a8(data, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    var offset = 0;
+    for (var i = 0; i < data.length; i += 2) {
+        var lum = data[i], alpha = data[i + 1];
+        rgba[offset++] = lum;
+        rgba[offset++] = lum;
+        rgba[offset++] = lum;
+        rgba[offset++] = alpha;
+    }
+    return rgba;
+}
+function pal4(data, palette, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    var offset = 0;
+    for (var i = 0; i < data.length; i++) {
+        var idx1 = (data[i] >> 4) & 0xf, idx2 = data[i] & 0xf;
+        rgba[offset++] = palette[idx1 * 4];
+        rgba[offset++] = palette[idx1 * 4 + 1];
+        rgba[offset++] = palette[idx1 * 4 + 2];
+        rgba[offset++] = palette[idx1 * 4 + 3];
+        rgba[offset++] = palette[idx2 * 4];
+        rgba[offset++] = palette[idx2 * 4 + 1];
+        rgba[offset++] = palette[idx2 * 4 + 2];
+        rgba[offset++] = palette[idx2 * 4 + 3];
+    }
+    return rgba;
+}
+function pal4NoAlpha(data, palette, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    var offset = 0;
+    for (var i = 0; i < data.length; i++) {
+        var idx1 = (data[i] >> 4) & 0xf, idx2 = data[i] & 0xf;
+        rgba[offset++] = palette[idx1 * 4];
+        rgba[offset++] = palette[idx1 * 4 + 1];
+        rgba[offset++] = palette[idx1 * 4 + 2];
+        rgba[offset++] = 0xff;
+        rgba[offset++] = palette[idx2 * 4];
+        rgba[offset++] = palette[idx2 * 4 + 1];
+        rgba[offset++] = palette[idx2 * 4 + 2];
+        rgba[offset++] = 0xff;
+    }
+    return rgba;
+}
+function pal8(data, palette, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    for (var i = 0; i < data.length; i++) {
+        var idx = data[i];
+        rgba[i * 4] = palette[idx * 4];
+        rgba[i * 4 + 1] = palette[idx * 4 + 1];
+        rgba[i * 4 + 2] = palette[idx * 4 + 2];
+        rgba[i * 4 + 3] = palette[idx * 4 + 3];
+    }
+    return rgba;
+}
+function pal8NoAlpha(data, palette, width, height) {
+    var rgba = new Uint8Array(4 * width * height);
+    for (var i = 0; i < data.length; i++) {
+        var idx = data[i];
+        rgba[i * 4] = palette[idx * 4];
+        rgba[i * 4 + 1] = palette[idx * 4 + 1];
+        rgba[i * 4 + 2] = palette[idx * 4 + 2];
+        rgba[i * 4 + 3] = 0xff;
+    }
+    return rgba;
+}

package/lib/common/types.d.ts

@@ -0,0 +1,50 @@
+export interface RwVector2 {
+    x: number;
+    y: number;
+}
+export interface RwVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface RwVector4 {
+    x: number;
+    y: number;
+    z: number;
+    t: number;
+}
+export interface RwQuaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface RwMatrix3 {
+    right: RwVector3;
+    up: RwVector3;
+    at: RwVector3;
+}
+export interface RwMatrix4 {
+    right: RwVector4;
+    up: RwVector4;
+    at: RwVector4;
+    transform: RwVector4;
+}
+export interface RwColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface RwTextureCoordinate {
+    u: number;
+    v: number;
+}
+export interface RwTriangle {
+    vector: RwVector3;
+    materialId: number;
+}
+export interface RwSphere {
+    vector: RwVector3;
+    radius: number;
+}

package/lib/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/byte-stream.d.ts

@@ -0,0 +1,20 @@
+export declare class ByteStream {
+    private _cursor;
+    private _stream;
+    constructor(stream: Buffer);
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readInt16(): number;
+    readInt8(): number;
+    readInt32(): number;
+    readFloat(): number;
+    readString(size: number): string;
+    readBytes(size: number): Uint8Array;
+    read(size: number): Uint8Array;
+    getSize(): number;
+    getPosition(): number;
+    setPosition(position: number): void;
+    skip(size: number): void;
+    dispose(): void;
+}

package/lib/core/byte-stream.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteStream = void 0;
+var ByteStream = /** @class */ (function () {
+    function ByteStream(stream) {
+        this._cursor = 0;
+        this._stream = stream;
+    }
+    ByteStream.prototype.readUint8 = function () {
+        return this._stream.readUInt8(this._cursor++);
+    };
+    ByteStream.prototype.readUint16 = function () {
+        var val = this._stream.readUInt16LE(this._cursor);
+        this._cursor += 2;
+        return val;
+    };
+    ByteStream.prototype.readUint32 = function () {
+        var val = this._stream.readUInt32LE(this._cursor);
+        this._cursor += 4;
+        return val;
+    };
+    ByteStream.prototype.readInt16 = function () {
+        var val = this._stream.readInt16LE(this._cursor);
+        this._cursor += 2;
+        return val;
+    };
+    ByteStream.prototype.readInt8 = function () {
+        return this._stream.readInt8(this._cursor++);
+    };
+    ByteStream.prototype.readInt32 = function () {
+        var val = this._stream.readInt32LE(this._cursor);
+        this._cursor += 4;
+        return val;
+    };
+    ByteStream.prototype.readFloat = function () {
+        var val = this._stream.readFloatLE(this._cursor);
+        this._cursor += 4;
+        return val;
+    };
+    ByteStream.prototype.readString = function (size) {
+        var str = this._stream.toString("ascii", this._cursor, this._cursor + size);
+        this._cursor += size;
+        return str.split(/\0/g).shift() || "";
+    };
+    ByteStream.prototype.readBytes = function (size) {
+        var data = this._stream.subarray(this._cursor, this._cursor + size);
+        this._cursor += size;
+        return new Uint8Array(data);
+    };
+    ByteStream.prototype.read = function (size) {
+        return this.readBytes(size);
+    };
+    ByteStream.prototype.getSize = function () {
+        return this._stream.byteLength;
+    };
+    ByteStream.prototype.getPosition = function () {
+        return this._cursor;
+    };
+    ByteStream.prototype.setPosition = function (position) {
+        this._cursor = position;
+    };
+    ByteStream.prototype.skip = function (size) {
+        this._cursor += size;
+    };
+    ByteStream.prototype.dispose = function () {
+        this._stream = Buffer.alloc(0);
+        this._cursor = 0;
+    };
+    return ByteStream;
+}());
+exports.ByteStream = ByteStream;

package/lib/core/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class RwParseError extends Error {
+}
+export declare class RwParseStructureNotFoundError extends RwParseError {
+    constructor(structureName: string);
+}

package/lib/core/errors.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RwParseStructureNotFoundError = exports.RwParseError = void 0;
+var RwParseError = /** @class */ (function (_super) {
+    __extends(RwParseError, _super);
+    function RwParseError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return RwParseError;
+}(Error));
+exports.RwParseError = RwParseError;
+var RwParseStructureNotFoundError = /** @class */ (function (_super) {
+    __extends(RwParseStructureNotFoundError, _super);
+    function RwParseStructureNotFoundError(structureName) {
+        return _super.call(this, "Structure ".concat(structureName, " not found.")) || this;
+    }
+    return RwParseStructureNotFoundError;
+}(RwParseError));
+exports.RwParseStructureNotFoundError = RwParseStructureNotFoundError;

package/lib/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./byte-stream";
+export * from "./errors";
+export * from "./rw-file";
+export * from "./rw-sections";
+export * from "./rw-version";

package/lib/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./byte-stream"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./rw-file"), exports);
+__exportStar(require("./rw-sections"), exports);
+__exportStar(require("./rw-version"), exports);

package/lib/core/rw-file.d.ts

@@ -0,0 +1,9 @@
+import { ByteStream } from "./byte-stream";
+export interface RwSectionHeader {
+    sectionType: number;
+    sectionSize: number;
+    versionNumber: number;
+}
+export declare class RwFile extends ByteStream {
+    readSectionHeader(): RwSectionHeader;
+}

package/lib/core/rw-file.js

@@ -0,0 +1,36 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RwFile = void 0;
+var byte_stream_1 = require("./byte-stream");
+var RwFile = /** @class */ (function (_super) {
+    __extends(RwFile, _super);
+    function RwFile() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RwFile.prototype.readSectionHeader = function () {
+        if (this.getPosition() + 12 > this.getSize()) {
+            throw new Error("Cannot read section header at offset ".concat(this.getPosition().toString(16), ": need 12 bytes but only ").concat(this.getSize() - this.getPosition(), " bytes remaining"));
+        }
+        var sectionType = this.readUint32();
+        var sectionSize = this.readUint32();
+        var versionNumber = this.readUint32();
+        return { sectionType: sectionType, sectionSize: sectionSize, versionNumber: versionNumber };
+    };
+    return RwFile;
+}(byte_stream_1.ByteStream));
+exports.RwFile = RwFile;