roomie 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,52 @@
+# roomie
+
+Roomie is a library for analyzing basic metadata of ROM files from various classic consoles. It allows extracting relevant information such as the game name, region, code, ROM and RAM size, version, and other console-specific data.
+
+## Installation
+
+```bash
+npm install roomie
+```
+
+## Usage
+
+```ts
+import Roomie from "roomie";
+
+const romPath = "/path/to/game.sfc";
+const roomie = new Roomie(romPath);
+
+roomie.on("loaded", (info) => {
+  console.log("ROM Information:", info);
+});
+
+await roomie.load(romPath); // Load ROM from file path
+
+const romBuffer = Buffer.from([...]); // Load ROM from a Buffer
+await roomie.load(romBuffer);
+
+console.log(roomie.info);
+```
+
+## Supported Consoles
+
+Roomie supports metadata extraction from the following systems:
+
+- **Nintendo DS (NDS):** Retrieves data such as the game name, region, game code, ROM and RAM size, version, among others.
+- **Game Boy Advance (GBA):** Extracts information about the title, game code, region, ROM and RAM size, version, etc.
+- **Game Boy (GB):** Provides details about the title, cartridge type, ROM and RAM size, and other metadata.
+- **Super Nintendo / Super Famicom (SNES/SFC):** Detects the ROM type (HiROM/LoROM), game name, region, code, ROM size, and other specific fields.
+
+## API
+
+- `new Roomie(path: string | Buffer)` – Creates an instance and immediately loads the specified ROM file or buffer. Emits the `'loaded'` event when the information is available.
+- `await roomie.load(pathOrBuffer: string | Buffer)` – Loads or reloads a different ROM file from a file path or a Buffer.
+- `roomie.info: RomInfo` – Object with the analyzed ROM metadata, including system, size, game code, region, and other specific fields.
+- `roomie.rom: Buffer` – Contains the raw bytes of the loaded ROM file.
+- `roomie.system: "nds" | "gba" | "gb" | "sfc"` – Detected system based on the file extension and content.
+
+If the system cannot be identified, the library throws errors with codes `unknown_file` (when loading from a path) or `unknown_bytes` (when loading from a Buffer).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1 @@
+module.exports = require("./index.mjs");

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Roomie as default } from "./roomie";
+export * from "./roomie";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Roomie as default } from "./roomie";
+export * from "./roomie";
+export * from "./types";

package/dist/index.mjs

@@ -0,0 +1,3 @@
+export { Roomie as default } from "./roomie";
+export * from "./roomie";
+export * from "./types";

package/dist/roomie.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from "node:events";
+import type { SupportedSystem } from "./types";
+export interface RomInfo {
+    path: string;
+    system: SupportedSystem;
+    size: number;
+    hash: {
+        sha1: string;
+    };
+    gameCode?: string;
+    region?: string;
+    sfc?: {
+        romSpeed?: string;
+        rom?: {
+            size?: number;
+            type?: string;
+            speed?: string;
+        };
+        ram?: number;
+        hardware?: Record<string, unknown>;
+    };
+}
+export declare class Roomie extends EventEmitter {
+    private _path;
+    private _rom;
+    private _system;
+    private _info;
+    constructor(path: string);
+    private detectSystemFromPath;
+    private readGameCode;
+    private computeRegion;
+    private computeSfcInfo;
+    load(pathOrBuffer: string | Buffer): Promise<void>;
+    get info(): RomInfo;
+    get system(): SupportedSystem;
+    get path(): string;
+    get rom(): Buffer;
+}
+export default Roomie;

package/dist/roomie.js

@@ -0,0 +1,171 @@
+import { EventEmitter } from "node:events";
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { regions } from "./tables/regions";
+import { specs } from "./tables/specs";
+import { isHiRomBuffer } from "./systems/snes";
+export class Roomie extends EventEmitter {
+    constructor(path) {
+        super();
+        this.load(path);
+    }
+    detectSystemFromPath(p) {
+        const ext = p.toLowerCase().split(".").pop();
+        if (ext === "nds")
+            return "nds";
+        if (ext === "gba")
+            return "gba";
+        if (ext === "gb" || ext === "gbc")
+            return "gb";
+        if (ext === "sfc" || ext === "smc")
+            return "sfc";
+        // Default to sfc to keep compatibility with original intent; could be improved.
+        return "sfc";
+    }
+    readGameCode(system) {
+        const b = this._rom;
+        try {
+            if (system === "nds" && b.length >= 0x10) {
+                return b.subarray(0x0C, 0x10).toString("ascii");
+            }
+            if (system === "gba" && b.length >= 0xB0) {
+                return b.subarray(0xAC, 0xB0).toString("ascii");
+            }
+            if (system === "gb" && b.length >= 0x0143) {
+                return b.subarray(0x013F, 0x0143).toString("ascii");
+            }
+        }
+        catch { }
+        return undefined;
+    }
+    computeRegion(system, gameCode) {
+        switch (system) {
+            case "nds":
+                if (gameCode && gameCode.length >= 4) {
+                    const key = gameCode[3];
+                    return regions.nds[key];
+                }
+                return undefined;
+            case "gba":
+                if (gameCode && gameCode.length >= 4) {
+                    const key = gameCode[3];
+                    return regions.gba[key];
+                }
+                return undefined;
+            case "gb":
+                if (this._rom.length > 0x14A) {
+                    const v = this._rom[0x14A];
+                    return regions.gb[v];
+                }
+                return undefined;
+            case "sfc":
+                const hi = isHiRomBuffer(this._rom);
+                const off = hi ? 0xFFD9 : 0x7FD9;
+                if (this._rom.length > off) {
+                    const key = this._rom[off];
+                    return regions.snes[key];
+                }
+                return undefined;
+        }
+    }
+    computeSfcInfo() {
+        if (this._system !== "sfc")
+            return undefined;
+        const hi = isHiRomBuffer(this._rom);
+        const base = hi ? 0xFFD0 : 0x7FD0; // region/speed map nearby
+        const romspeedOff = base + 0x09; // D9
+        const romTypeOff = base + 0x05; // D5
+        const romSizeOff = base + 0x07; // D7
+        const ramSizeOff = base + 0x08; // D8
+        const out = {};
+        if (this._rom.length > romspeedOff) {
+            const key = this._rom[romspeedOff].toString(16);
+            out.romSpeed = key;
+            const spec = specs.sfc?.romspeed?.[key];
+            if (spec)
+                out.rom = { ...(out.rom || {}), type: spec.type, speed: spec.speed };
+        }
+        if (this._rom.length > romTypeOff) {
+            const hwKey = this._rom[romTypeOff].toString(16);
+            const hw = specs.sfc?.hardware?.[hwKey];
+            if (hw)
+                out.hardware = hw;
+        }
+        if (this._rom.length > romSizeOff) {
+            const exp = this._rom[romSizeOff];
+            out.rom = { ...(out.rom || {}), size: Math.pow(2, exp) * 1024 };
+        }
+        if (this._rom.length > ramSizeOff) {
+            const exp = this._rom[ramSizeOff];
+            out.ram = Math.pow(2, exp) * 1024;
+        }
+        return out;
+    }
+    async load(pathOrBuffer) {
+        if (typeof pathOrBuffer === "string") {
+            this._path = pathOrBuffer;
+            this._rom = await fs.readFile(pathOrBuffer);
+            this._system = this.detectSystemFromPath(pathOrBuffer);
+            if (!this._system) {
+                throw new Error("unknown_file");
+            }
+        }
+        else {
+            this._rom = pathOrBuffer;
+            this._path = "in-memory";
+            const b = this._rom;
+            let detected = undefined;
+            // Check NDS: game code at 0x0C-0x10 ASCII uppercase letters/digits
+            if (b.length >= 0x10) {
+                const code = b.subarray(0x0C, 0x10).toString("ascii");
+                if (/^[A-Z0-9]{4}$/.test(code)) {
+                    detected = "nds";
+                }
+            }
+            // Check GBA: game code at 0xAC-0xB0 ASCII uppercase letters/digits
+            if (!detected && b.length >= 0xB0) {
+                const code = b.subarray(0xAC, 0xB0).toString("ascii");
+                if (/^[A-Z0-9]{4}$/.test(code)) {
+                    detected = "gba";
+                }
+            }
+            // Check GB: game code at 0x0134-0x0143 ASCII valid characters
+            if (!detected && b.length >= 0x0143) {
+                const code = b.subarray(0x0134, 0x0143).toString("ascii");
+                if (/^[A-Z0-9]{4,9}$/.test(code)) {
+                    detected = "gb";
+                }
+            }
+            // Check SFC: use isHiRomBuffer heuristic
+            if (!detected) {
+                if (b.length > 0x8000 && (isHiRomBuffer(b) || !isHiRomBuffer(b))) {
+                    detected = "sfc";
+                }
+            }
+            if (!detected) {
+                throw new Error("unknown_bytes");
+            }
+            this._system = detected;
+        }
+        const sha1 = createHash("sha1").update(this._rom).digest("hex");
+        const gameCode = this.readGameCode(this._system);
+        const info = {
+            path: this._path,
+            system: this._system,
+            size: this._rom.length,
+            hash: { sha1 },
+            gameCode,
+            region: this.computeRegion(this._system, gameCode),
+        };
+        if (this._system === "sfc") {
+            info.sfc = this.computeSfcInfo();
+        }
+        this._info = info;
+        this.emit("loaded", info);
+    }
+    get info() { return this._info; }
+    get system() { return this._system; }
+    get path() { return this._path; }
+    get rom() { return this._rom; }
+}
+export default Roomie;

package/dist/systems/snes.d.ts

@@ -0,0 +1,3 @@
+/** Heuristic detection. Defaults to LoROM (false) if unsure. */
+export declare function isHiRom(path: string): Promise<boolean>;
+export declare function isHiRomBuffer(buf: Buffer): boolean;

package/dist/systems/snes.js

@@ -0,0 +1,31 @@
+import { promises as fs } from "node:fs";
+function plausibleHeaderByte(b) {
+    return Number.isInteger(b) && b >= 0 && b <= 0xFF;
+}
+/** Heuristic detection. Defaults to LoROM (false) if unsure. */
+export async function isHiRom(path) {
+    const buf = await fs.readFile(path);
+    return isHiRomBuffer(buf);
+}
+export function isHiRomBuffer(buf) {
+    const offLo = 0x7FD5;
+    const offHi = 0xFFD5;
+    if (buf.length > offHi) {
+        const lo = buf[offLo];
+        const hi = buf[offHi];
+        if (plausibleHeaderByte(lo) && plausibleHeaderByte(hi)) {
+            // Very simple heuristic: choose the one whose "map" nibble looks like HiROM (0x21, 0x31, 0x23, 0x32, 0x25)
+            const hiromCandidates = new Set([0x21, 0x31, 0x23, 0x32, 0x25]);
+            const loromCandidates = new Set([0x20, 0x30]);
+            const hiLikely = hiromCandidates.has(hi);
+            const loLikely = loromCandidates.has(lo);
+            if (hiLikely && !loLikely)
+                return true;
+            if (loLikely && !hiLikely)
+                return false;
+            // If both plausible, prefer the one with a valid checksum complement just as a tie-breaker (not implemented)
+        }
+    }
+    // Fallback: LoROM
+    return false;
+}

package/dist/tables/regions.d.ts

@@ -0,0 +1,46 @@
+export declare const regions: {
+    readonly nds: {
+        readonly A: "asia";
+        readonly C: "china";
+        readonly P: "europe";
+        readonly E: "americas";
+        readonly J: "japan";
+        readonly F: "french";
+        readonly H: "dutch";
+        readonly I: "italian";
+        readonly K: "korean";
+        readonly L: "usa#2";
+        readonly M: "swedish";
+        readonly N: "norwegian";
+        readonly O: "international";
+        readonly Q: "danish";
+        readonly R: "russian";
+        readonly S: "spanish";
+        readonly T: "usa+aus";
+        readonly U: "australia";
+        readonly V: "eur+aus";
+        readonly W: "europe#3";
+        readonly X: "europe#4";
+        readonly Y: "europe#5";
+        readonly Z: "europe#5";
+    };
+    readonly gba: {
+        readonly J: "japan";
+        readonly E: "english";
+        readonly P: "europe";
+        readonly D: "german";
+        readonly F: "french";
+        readonly I: "italian";
+        readonly S: "spanish";
+    };
+    readonly gb: {
+        readonly 0: "japan";
+        readonly 1: "overseas";
+    };
+    readonly snes: {
+        readonly 0: "japan";
+        readonly 1: "americas";
+        readonly 2: "europe";
+    };
+};
+export type SupportedSystemsForRegions = keyof typeof regions;

package/{lib → dist/tables}/regions.js

@@ -1,47 +1,46 @@
-exports.regions = {
-    nds: {
-        "A": "asia",
-        "C": "china",
-        "P": "europe",
-        "E": "americas",
-        "J": "japan",
-        "F": "french",
-        "H": "dutch",
-        "I": "italian",
-        "J": "japanese",
-        "K": "korean",
-        "L": "usa#2",
-        "M": "swedish",
-        "N": "norwegian",
-        "O": "international",
-        "Q": "danish",
-        "R": "russian",
-        "S": "spanish",
-        "T": "usa+aus",
-        "U": "australia",
-        "V": "eur+aus",
-        "W": "europe#3",
-        "X": "europe#4",
-        "Y": "europe#5",
-        "Z": "europe#5"
-
-    },
-    gba: {
-        "J": "japan",
-        "E": "english",
-        "P": "europe",
-        "D": "german",
-        "F": "french",
-        "I": "italian",
-        "S": "spanish"
-    },
-    gb: {
-        0: "japan",
-        1: "overseas"
-    },
-    snes: {
-        0: "japan",
-        1: "americas",
-        2: "europe"
-    }
-}
+/* Auto-generated from original JS */
+export const regions = {
+    nds: {
+        "A": "asia",
+        "C": "china",
+        "P": "europe",
+        "E": "americas",
+        "J": "japan",
+        "F": "french",
+        "H": "dutch",
+        "I": "italian",
+        "K": "korean",
+        "L": "usa#2",
+        "M": "swedish",
+        "N": "norwegian",
+        "O": "international",
+        "Q": "danish",
+        "R": "russian",
+        "S": "spanish",
+        "T": "usa+aus",
+        "U": "australia",
+        "V": "eur+aus",
+        "W": "europe#3",
+        "X": "europe#4",
+        "Y": "europe#5",
+        "Z": "europe#5"
+    },
+    gba: {
+        "J": "japan",
+        "E": "english",
+        "P": "europe",
+        "D": "german",
+        "F": "french",
+        "I": "italian",
+        "S": "spanish"
+    },
+    gb: {
+        0: "japan",
+        1: "overseas"
+    },
+    snes: {
+        0: "japan",
+        1: "americas",
+        2: "europe"
+    }
+};

package/dist/tables/specs.d.ts

@@ -0,0 +1,221 @@
+export declare const specs: {
+    readonly nds: {
+        readonly unitcode: {
+            readonly "0": "nds";
+            readonly "1": "nds/dsi";
+            readonly "2": "dsi";
+        };
+    };
+    readonly gb: {
+        readonly a: "";
+    };
+    readonly sfc: {
+        readonly hardware: {
+            readonly "0": {
+                readonly coprocessor: false;
+                readonly rom: true;
+            };
+            readonly "1": {
+                readonly coprocessor: false;
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "2": {
+                readonly coprocessor: false;
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "3": {
+                readonly coprocessor: "dsp";
+                readonly rom: true;
+            };
+            readonly "4": {
+                readonly coprocessor: "dsp";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "5": {
+                readonly coprocessor: "dsp";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "6": {
+                readonly coprocessor: "dsp";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly "13": {
+                readonly coprocessor: "gsu/superFX";
+                readonly rom: true;
+            };
+            readonly "14": {
+                readonly coprocessor: "gsu/superFX";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "15": {
+                readonly coprocessor: "gsu/superFX";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "16": {
+                readonly coprocessor: "gsu/superFX";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly "23": {
+                readonly coprocessor: "obc1";
+                readonly rom: true;
+            };
+            readonly "24": {
+                readonly coprocessor: "obc1";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "25": {
+                readonly coprocessor: "obc1";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "26": {
+                readonly coprocessor: "obc1";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly "33": {
+                readonly coprocessor: "sa-1";
+                readonly rom: true;
+            };
+            readonly "34": {
+                readonly coprocessor: "sa-1";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "35": {
+                readonly coprocessor: "sa-1";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "36": {
+                readonly coprocessor: "sa-1";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly "43": {
+                readonly coprocessor: "s-dd1";
+                readonly rom: true;
+            };
+            readonly "44": {
+                readonly coprocessor: "s-dd1";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "45": {
+                readonly coprocessor: "s-dd1";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "46": {
+                readonly coprocessor: "s-dd1";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly "53": {
+                readonly coprocessor: "s-rtc";
+                readonly rom: true;
+            };
+            readonly "54": {
+                readonly coprocessor: "s-rtc";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly "55": {
+                readonly coprocessor: "s-rtc";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly "56": {
+                readonly coprocessor: "s-rtc";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly e3: {
+                readonly coprocessor: "other";
+                readonly rom: true;
+            };
+            readonly e4: {
+                readonly coprocessor: "other";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly e5: {
+                readonly coprocessor: "other";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly e6: {
+                readonly coprocessor: "other";
+                readonly rom: true;
+                readonly battery: true;
+            };
+            readonly f3: {
+                readonly coprocessor: "custom";
+                readonly rom: true;
+            };
+            readonly f4: {
+                readonly coprocessor: "custom";
+                readonly rom: true;
+                readonly ram: true;
+            };
+            readonly f5: {
+                readonly coprocessor: "custom";
+                readonly rom: true;
+                readonly ram: true;
+                readonly battery: true;
+            };
+            readonly f6: {
+                readonly coprocessor: "custom";
+                readonly rom: true;
+                readonly battery: true;
+            };
+        };
+        readonly romspeed: {
+            readonly "20": {
+                readonly type: "LoROM";
+                readonly speed: "2.68MHz";
+            };
+            readonly "21": {
+                readonly type: "HiROM";
+                readonly speed: "2.68MHz";
+            };
+            readonly "23": {
+                readonly type: "SA-1";
+            };
+            readonly "25": {
+                readonly type: "ExHiROM";
+                readonly speed: "2.68MHz";
+            };
+            readonly "30": {
+                readonly type: "LoROM";
+                readonly speed: "3.58MHz";
+            };
+            readonly "31": {
+                readonly type: "HiROM";
+                readonly speed: "3.58MHz";
+            };
+            readonly "32": {
+                readonly type: "ExHiROM";
+                readonly speed: "3.58MHz";
+            };
+        };
+    };
+};
+export type SupportedSystemsForSpecs = keyof typeof specs;

package/{lib → dist/tables}/specs.js

@@ -1,61 +1,61 @@
-exports.specs = {
-    nds:{
-        unitcode:{
-            "0":"nds",
-            "1": "nds/dsi",
-            "2": "dsi"
-        }
-    },
-    gb:{
-        "a":""
-    },
-    sfc: {
-        hardware: {
-            "0": { coprocessor: false, rom: true },
-            "1": { coprocessor: false, rom: true, ram: true },
-            "2": { coprocessor: false, rom: true, ram: true, battery: true },
-            "2": { coprocessor: false, rom: true, ram: true, battery: true },
-            "3": { coprocessor: "dsp", rom: true },
-            "4": { coprocessor: "dsp", rom: true, ram: true },
-            "5": { coprocessor: "dsp", rom: true, ram: true, battery: true },
-            "6": { coprocessor: "dsp", rom: true, battery: true },
-            "13": { coprocessor: "gsu/superFX", rom: true },
-            "14": { coprocessor: "gsu/superFX", rom: true, ram: true },
-            "15": { coprocessor: "gsu/superFX", rom: true, ram: true, battery: true },
-            "16": { coprocessor: "gsu/superFX", rom: true, battery: true },
-            "23": { coprocessor: "obc1", rom: true },
-            "24": { coprocessor: "obc1", rom: true, ram: true },
-            "25": { coprocessor: "obc1", rom: true, ram: true, battery: true },
-            "26": { coprocessor: "obc1", rom: true, battery: true },
-            "33": { coprocessor: "sa-1", rom: true },
-            "34": { coprocessor: "sa-1", rom: true, ram: true },
-            "35": { coprocessor: "sa-1", rom: true, ram: true, battery: true },
-            "36": { coprocessor: "sa-1", rom: true, battery: true },
-            "43": { coprocessor: "s-dd1", rom: true },
-            "44": { coprocessor: "s-dd1", rom: true, ram: true },
-            "45": { coprocessor: "s-dd1", rom: true, ram: true, battery: true },
-            "46": { coprocessor: "s-dd1", rom: true, battery: true },
-            "53": { coprocessor: "s-rtc", rom: true },
-            "54": { coprocessor: "s-rtc", rom: true, ram: true },
-            "55": { coprocessor: "s-rtc", rom: true, ram: true, battery: true },
-            "56": { coprocessor: "s-rtc", rom: true, battery: true },
-            "e3": { coprocessor: "other", rom: true },
-            "e4": { coprocessor: "other", rom: true, ram: true },
-            "e5": { coprocessor: "other", rom: true, ram: true, battery: true },
-            "e6": { coprocessor: "other", rom: true, battery: true },
-            "f3": { coprocessor: "custom", rom: true },
-            "f4": { coprocessor: "custom", rom: true, ram: true },
-            "f5": { coprocessor: "custom", rom: true, ram: true, battery: true },
-            "f6": { coprocessor: "custom", rom: true, battery: true },
-        },
-        romspeed: {
-            "20": { type: "LoROM", speed: "2.68MHz" },
-            "21": { type: "HiROM", speed: "2.68MHz" },
-            "23": { type: "SA-1"},
-            "25": { type: "ExHiROM", speed: "2.68MHz" },
-            "30": { type: "LoROM", speed: "3.58MHz" },
-            "31": { type: "HiROM", speed: "3.58MHz" },
-            "32": { type: "ExHiROM", speed: "3.58MHz" },
-        }
-    }
-}
+/* Auto-generated from original JS */
+export const specs = {
+    nds: {
+        unitcode: {
+            "0": "nds",
+            "1": "nds/dsi",
+            "2": "dsi"
+        }
+    },
+    gb: {
+        "a": ""
+    },
+    sfc: {
+        hardware: {
+            "0": { coprocessor: false, rom: true },
+            "1": { coprocessor: false, rom: true, ram: true },
+            "2": { coprocessor: false, rom: true, ram: true, battery: true },
+            "3": { coprocessor: "dsp", rom: true },
+            "4": { coprocessor: "dsp", rom: true, ram: true },
+            "5": { coprocessor: "dsp", rom: true, ram: true, battery: true },
+            "6": { coprocessor: "dsp", rom: true, battery: true },
+            "13": { coprocessor: "gsu/superFX", rom: true },
+            "14": { coprocessor: "gsu/superFX", rom: true, ram: true },
+            "15": { coprocessor: "gsu/superFX", rom: true, ram: true, battery: true },
+            "16": { coprocessor: "gsu/superFX", rom: true, battery: true },
+            "23": { coprocessor: "obc1", rom: true },
+            "24": { coprocessor: "obc1", rom: true, ram: true },
+            "25": { coprocessor: "obc1", rom: true, ram: true, battery: true },
+            "26": { coprocessor: "obc1", rom: true, battery: true },
+            "33": { coprocessor: "sa-1", rom: true },
+            "34": { coprocessor: "sa-1", rom: true, ram: true },
+            "35": { coprocessor: "sa-1", rom: true, ram: true, battery: true },
+            "36": { coprocessor: "sa-1", rom: true, battery: true },
+            "43": { coprocessor: "s-dd1", rom: true },
+            "44": { coprocessor: "s-dd1", rom: true, ram: true },
+            "45": { coprocessor: "s-dd1", rom: true, ram: true, battery: true },
+            "46": { coprocessor: "s-dd1", rom: true, battery: true },
+            "53": { coprocessor: "s-rtc", rom: true },
+            "54": { coprocessor: "s-rtc", rom: true, ram: true },
+            "55": { coprocessor: "s-rtc", rom: true, ram: true, battery: true },
+            "56": { coprocessor: "s-rtc", rom: true, battery: true },
+            "e3": { coprocessor: "other", rom: true },
+            "e4": { coprocessor: "other", rom: true, ram: true },
+            "e5": { coprocessor: "other", rom: true, ram: true, battery: true },
+            "e6": { coprocessor: "other", rom: true, battery: true },
+            "f3": { coprocessor: "custom", rom: true },
+            "f4": { coprocessor: "custom", rom: true, ram: true },
+            "f5": { coprocessor: "custom", rom: true, ram: true, battery: true },
+            "f6": { coprocessor: "custom", rom: true, battery: true },
+        },
+        romspeed: {
+            "20": { type: "LoROM", speed: "2.68MHz" },
+            "21": { type: "HiROM", speed: "2.68MHz" },
+            "23": { type: "SA-1" },
+            "25": { type: "ExHiROM", speed: "2.68MHz" },
+            "30": { type: "LoROM", speed: "3.58MHz" },
+            "31": { type: "HiROM", speed: "3.58MHz" },
+            "32": { type: "ExHiROM", speed: "3.58MHz" },
+        }
+    }
+};

package/dist/types.d.ts

@@ -0,0 +1 @@
+export type SupportedSystem = "nds" | "gba" | "gb" | "sfc";

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/stringHelper.d.ts

@@ -0,0 +1 @@
+export declare function hexEncode(input: string): string;

package/dist/utils/stringHelper.js

@@ -0,0 +1,8 @@
+export function hexEncode(input) {
+    let result = "";
+    for (let i = 0; i < input.length; i++) {
+        const hex = input.charCodeAt(i).toString(16);
+        result += ("000" + hex).slice(-4);
+    }
+    return result;
+}

package/package.json

@@ -1,36 +1,35 @@
 {
-  "dependencies": {
-    "cryptography": "^1.2.3",
-    "path": "^0.12.7"
-  },
   "name": "roomie",
-  "version": "1.0.0",
-  "description": "ROM analyzer for major consoles (NDS,GBA,GB,SNES...)",
-  "main": "index.js",
-  "directories": {
-    "lib": "lib"
-  },
-  "devDependencies": {},
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "1.0.2",
+  "description": "ROM metadata helper",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nikitacontreras/roomie.git"
+  "engines": {
+    "node": ">=18"
   },
-  "keywords": [
-    "rom",
-    "emulation",
-    "emurom",
-    "snes",
-    "gba",
-    "nds",
-    "nes"
+  "files": [
+    "dist"
   ],
-  "author": "nikitacontreras",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/nikitacontreras/roomie/issues"
+  "scripts": {
+    "build": "tsc && node scripts/emit-dual.js",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "prepare": "npm run clean && npm run build"
   },
-  "homepage": "https://github.com/nikitacontreras/roomie#readme"
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.6.0"
+  }
 }

package/index.js

@@ -1 +0,0 @@
-module.exports = require("./lib/roomie")

package/lib/roomie.js

@@ -1,124 +0,0 @@
-const { createHash } = require("cryptography");
-const { EventEmitter } = require('events');
-const { regions } = require("./regions")
-const { specs } = require("./specs")
-const { stringHelper } = require("./stringHelper")
-const fs = require('fs');
-const { systems } = require('./system')
-
-let rom, system;
-
-class Roomie extends EventEmitter {
-    constructor(path) {
-        super()
-        this.load(path)
-
-        this.__rom, this.__system, this.__romInfo, this.__path
-        this.name = this._name()
-        this.gameid = this._gameid()
-        this.region = this._region()
-        this.gamecode = this._gamecode()
-        this.cartridge = this._cartridge()
-    }
-    get system() {
-        return this.__system
-    }
-    set system(extension) {
-        this.__system = extension
-    }
-    get rom() {
-        return this.__rom
-    }
-    set rom(buffer) {
-        this.__rom = buffer
-    }
-
-    load = (path) => {
-        this.__path = path
-        this.__rom = fs.readFileSync(path)
-        this.__romInfo = fs.statSync(path)
-        this.__system = path.split(".")[path.split().length]
-    }
-
-    _name() {
-        switch (this.system) {
-            case "nds":
-                return this.rom.slice(0x0, 0xB).toString().trim()
-            case "gba":
-                return this.rom.slice(0xA0, 0xA0 + 12).toString().trim()
-            case "gb":
-                return this.rom.slice(0x134, 0x134 + 9).toString().trim()
-            case "sfc":
-                return this.rom.slice(systems.snes.isHiRom(this.__path, 0x7FC0), systems.snes.isHiRom(this.__path, 0x7FC0) + 21).toString().trim()
-            case "n64":
-                return this.rom.slice(0x20, 0x20 + 14).toString().match(/.{1,2}/g).reverse().join('').split("").reverse().join("").trim()
-        }
-    }
-
-    _gamecode() {
-        switch (this.system) {
-            case "nds":
-                return this.rom.slice(0xD, 0xD + 2).toString()
-            case "gba":
-                return this.rom.slice(0xAD, 0xAD + 2).toString()
-            case "sfc":
-                return this.rom.slice(systems.snes.isHiRom(this.__path, 0x7FB2), systems.snes.isHiRom(this.__path, 0x7FB2) + 4).toString("ASCII").trim()
-        }
-    }
-
-    _gameid() {
-        switch (this.system) {
-            case "nds":
-                return "NTR-" + this.rom.slice(0xC, 0xC + 4).toString()
-            case "gba":
-                return "AGB-" + this.rom.slice(0xAC, 0xAC + 4).toString()
-        }
-    }
-
-    _cartridge() {
-        switch (this.system) {
-            case "nds":
-                return {
-                    unit: specs.nds.unitcode[this.rom[0x012].toString(16)],
-                    developer: this.rom[0x012].toString(16),
-                    version: this.rom[0x01E],
-                    title: this.rom.slice(0x265440, 0x265440 + 0x3B).toString().replace(/\x00/g, '').replace(/(\\n)/g, "\n")
-                }
-            case "gba":
-                return {
-                    developer: this.rom.slice(0xB0, 0xB0 + 0x2).toString()
-                }
-            case "gb":
-                return {
-                    rom: {
-                        size: this.rom[0x148]
-                    }
-                }
-            case "sfc":
-                return {
-                    romSpeed: (systems.snes.isHiRom(this.__path) ? this.rom[0xFFD9] : this.rom[0x7FD9]).toString().trim(),
-                    rom: {
-                        size: 2 ** (2 ^ this.rom[systems.snes.isHiRom(this.__path, 0x7FD7)]) * 1000,
-                        specs: specs.sfc.romspeed[this.rom[systems.snes.isHiRom(this.__path, 0x7FD5)].toString(16)]
-                    },
-                    ram: 2 ** (2 ^ (this.rom[systems.snes.isHiRom(this.__path, 0x7FD8)])) * 1000,
-                    hardware: specs.sfc.hardware[this.rom[systems.snes.isHiRom(this.__path, 0x7FD6)].toString(16)],
-                }
-        }
-    }
-
-    _region() {
-        switch (this.system) {
-            case "nds":
-                return regions.nds[(this.gameid[this.gameid.length - 1])]
-            case "gba":
-                return regions.gba[(this.gameid[this.gameid.length - 1])]
-            case "gb":
-                return regions.gb[this.rom[0x14A].toString()]
-            case "sfc":
-                return regions.snes[this.rom[systems.snes.isHiRom(this.__path, 0x7FD9)].toString()]
-        }
-    }
-}
-
-module.exports = Roomie

package/lib/stringHelper.js

@@ -1,13 +0,0 @@
-module.exports = () => {
-    String.prototype.hexEncode = function () {
-        var hex, i;
-
-        var result = "";
-        for (i = 0; i < this.length; i++) {
-            hex = this.charCodeAt(i).toString(16);
-            result += ("000" + hex).slice(-4);
-        }
-
-        return result
-    }
-}

package/lib/system.js

@@ -1,10 +0,0 @@
-const fs = require("fs")
-files = {}
-fs.readdirSync(`${__dirname}/systems`)
-    .filter((module) => {
-        return module.slice(module.length - 3) === '.js';
-    })
-    .forEach((module) => {
-        files[module.split(".")[0]] = require(`${__dirname}/systems/` + module);
-    });
-module.exports.systems = files

package/lib/systems/snes.js

@@ -1,10 +0,0 @@
-const fs = require("fs")
-
-module.exports = {
-    isHiRom: (path, hex) => {
-        return fs.statSync(path).size % fs.readFileSync(path)[0x400] === 0 ? hex + 0x8000 : hex
-    },
-    name: (file) => {
-        this.isHiRom()
-    }
-}