miijs 2.5.0 → 2.5.2

package/index.js

@@ -1,24 +1,43 @@
-//Imports
-const fs = require('fs');
-const nodeCanvas = require('canvas');
-const { createCanvas, loadImage, ImageData } = nodeCanvas;
+//Imports - Environment detection
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+// Node.js-only imports (conditionally loaded)
+let fs, nodeCanvas, createCanvas, loadImage, ImageData, Jimp, JSDOM, httpsLib, path, createGL;
+let ModuleFFL, FFLShaderMaterial, fflWrapper;
+
+if (isNode) {
+    fs = require('fs');
+    nodeCanvas = require('canvas');
+    createCanvas = nodeCanvas.createCanvas;
+    loadImage = nodeCanvas.loadImage;
+    ImageData = nodeCanvas.ImageData;
+    Jimp = require('jimp');
+    JSDOM = require("jsdom").JSDOM;
+    httpsLib = require('https');
+    path = require("path");
+    createGL = require('gl');
+    ModuleFFL = require("ffl.js/examples/ffl-emscripten-single-file.js");
+    FFLShaderMaterial = require("ffl.js/FFLShaderMaterial.js");
+    fflWrapper = require("./fflWrapper.js");
+}
+
+// Cross-platform imports
 const jsQR = require('jsqr');
-const Jimp = require('jimp');
 const THREE = require('three');
 var GLTFLoader = null;
 const QRCodeStyling = require("qr-code-styling");
-const { JSDOM } = require("jsdom");
-const httpsLib = require('https');
 const asmCrypto = require("./asmCrypto.js");
-const path = require("path");
-const createGL = require('gl');
-const {
-    createCharModel, initCharModelTextures,
-    initializeFFL, exitFFL, parseHexOrB64ToUint8Array,
-    setIsWebGL1State, getCameraForViewType, ViewType
-} = require("./fflWrapper.js");
-const ModuleFFL = require("ffl.js/examples/ffl-emscripten-single-file.js");
-const FFLShaderMaterial = require("ffl.js/FFLShaderMaterial.js");
+
+// FFL exports (only available in Node.js)
+const createCharModel = isNode ? fflWrapper.createCharModel : null;
+const initCharModelTextures = isNode ? fflWrapper.initCharModelTextures : null;
+const initializeFFL = isNode ? fflWrapper.initializeFFL : null;
+const exitFFL = isNode ? fflWrapper.exitFFL : null;
+const parseHexOrB64ToUint8Array = isNode ? fflWrapper.parseHexOrB64ToUint8Array : null;
+const setIsWebGL1State = isNode ? fflWrapper.setIsWebGL1State : null;
+const getCameraForViewType = isNode ? fflWrapper.getCameraForViewType : null;
+const ViewType = isNode ? fflWrapper.ViewType : null;
 const typeCheat = [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3];
 
 // Typedefs for intellisence
@@ -42,19 +61,30 @@ function Uint8Cat() {
     return dest;
 }
 async function downloadImage(url) {
-    return new Promise((resolve, reject) => {
-        httpsLib.get(url, (res) => {
-            if (res.statusCode === 200) {
-                const data = [];
-                res.on('data', chunk => data.push(chunk));
-                res.on('end', () => resolve(Buffer.concat(data)));
-                res.on('error', reject);
-            } else {
-                res.resume();
-                reject(new Error(`Request Failed With a Status Code: ${res.statusCode}`));
-            }
+    if (isBrowser) {
+        // Browser: use fetch
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Request Failed With a Status Code: ${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return new Uint8Array(arrayBuffer);
+    } else {
+        // Node.js: use https
+        return new Promise((resolve, reject) => {
+            httpsLib.get(url, (res) => {
+                if (res.statusCode === 200) {
+                    const data = [];
+                    res.on('data', chunk => data.push(chunk));
+                    res.on('end', () => resolve(Buffer.concat(data)));
+                    res.on('error', reject);
+                } else {
+                    res.resume();
+                    reject(new Error(`Request Failed With a Status Code: ${res.statusCode}`));
+                }
+            });
         });
-    });
+    }
 }
 function byteToString(int) {
     var str = int.toString(16);
@@ -62,13 +92,27 @@ function byteToString(int) {
     return str;
 }
 function getBinaryFromAddress(addr, bin) {
-    let byte = bin.readUInt8(addr);
+    // Support both Buffer (Node.js) and Uint8Array (browser)
+    let byte;
+    if (typeof bin.readUInt8 === 'function') {
+        byte = bin.readUInt8(addr);
+    } else {
+        byte = bin[addr];
+    }
     let binaryString = '';
     for (let i = 7; i >= 0; i--) {
         binaryString += ((byte >> i) & 1) ? '1' : '0';
     }
     return binaryString;
 }
+// Helper to read big-endian 32-bit unsigned int from Buffer or Uint8Array
+function readUInt32BE(bin, offset) {
+    if (typeof bin.readUInt32BE === 'function') {
+        return bin.readUInt32BE(offset);
+    }
+    // Manual big-endian read for Uint8Array
+    return ((bin[offset] << 24) | (bin[offset + 1] << 16) | (bin[offset + 2] << 8) | bin[offset + 3]) >>> 0;
+}
 function getKeyByValue(object, value) {
     for (var key in object) {
         if (object[key] === value) {
@@ -85,6 +129,9 @@ function lookupTable(table, value, paginated) {
                 }
             }
         }
+        // Value not found - return default [0, 0] to avoid crashes
+        console.warn(`lookupTable: ${table} value ${value} not found, defaulting to [0, 0]`);
+        return [0, 0];
     }
     else {
         for (var i = 0; i < lookupTables[table].values.length; i++) {
@@ -92,8 +139,10 @@ function lookupTable(table, value, paginated) {
                 return i;
             }
         }
+        // Value not found - return 0 to avoid crashes
+        console.warn(`lookupTable: ${table} value ${value} not found, defaulting to 0`);
+        return 0;
     }
-    return undefined;
 }
 function hexToBytes(hex) {
     const cleaned = hex.replace(/[\s:_-]/g, "").replace(/^0x/i, "");
@@ -149,6 +198,12 @@ function getFFLRes() {
         "../../afl/AFLResHigh.dat"
     ];
 
+    // Only search for files in Node.js environment
+    if (!isNode || !fs) {
+        // local rendering is currently not supported in-browser.
+        return _fflRes = null;
+    }
+
     for (const filePath of searchPaths) {
         try {
             if (fs.existsSync(filePath)) {
@@ -158,7 +213,7 @@ function getFFLRes() {
                     // Convert Buffer to Uint8Array explicitly
                     const buffer = fs.readFileSync(filePath);
                     _fflRes = new Uint8Array(buffer);
-                    console.log(`Loaded FFLResHigh.dat from: ${filePath} (${_fflRes.length} bytes)`);
+                    // console.log(`Loaded FFLResHigh.dat from: ${filePath} (${_fflRes.length} bytes)`);
                     return _fflRes;
                 }
             }
@@ -247,8 +302,16 @@ function decodeStudio(encoded) {
     return out;
 }
 function convertMii(jsonIn, typeTo) {
-    typeFrom = jsonIn.console?.toLowerCase();
-    if (typeFrom == null || typeTo === typeFrom) {
+    const typeFrom = jsonIn.console?.toLowerCase();
+    if (typeFrom == null) {
+        return jsonIn;
+    }
+    // If no target type specified, convert to the other format
+    if (!typeTo) {
+        typeTo = typeFrom === "wii" ? "3ds" : "wii";
+    }
+    typeTo = typeTo.toLowerCase();
+    if (typeTo === typeFrom) {
         return jsonIn;
     }
     let mii = jsonIn;
@@ -545,14 +608,36 @@ function convertStudioToMii(input) {
 
 async function readWiiBin(binOrPath) {
     let data;
-    if (Buffer.isBuffer(binOrPath)) {
+    
+    // Handle Uint8Array input (browser-friendly)
+    if (binOrPath instanceof Uint8Array) {
+        // In browser, use Uint8Array directly; in Node.js, convert to Buffer
+        data = typeof Buffer !== "undefined" ? Buffer.from(binOrPath) : binOrPath;
+    }
+    else if (typeof Buffer !== "undefined" && Buffer.isBuffer(binOrPath)) {
         data = binOrPath;
     }
-    else if (/[^01]/ig.test(binOrPath)) {
+    else if (typeof binOrPath === 'string' && /[^01]/ig.test(binOrPath)) {
+        // It's a file path - only works in Node.js
+        if (!isNode || !fs) {
+            throw new Error("File path reading only available in Node.js. Pass a Uint8Array or Buffer in browser.");
+        }
         data = await fs.promises.readFile(binOrPath);
     }
+    else if (typeof binOrPath === 'string') {
+        // Binary string of 0s and 1s - convert to bytes
+        const bytes = [];
+        for (let i = 0; i < binOrPath.length; i += 8) {
+            bytes.push(parseInt(binOrPath.slice(i, i + 8), 2));
+        }
+        data = typeof Buffer !== "undefined" ? Buffer.from(bytes) : new Uint8Array(bytes);
+    }
+    else if (binOrPath instanceof ArrayBuffer) {
+        const arr = new Uint8Array(binOrPath);
+        data = typeof Buffer !== "undefined" ? Buffer.from(arr) : arr;
+    }
     else {
-        data = Buffer.from(binOrPath);
+        throw new Error("Invalid input type for readWiiBin");
     }
     var thisMii = {
         general: {},
@@ -573,18 +658,30 @@ async function readWiiBin(binOrPath) {
 
     const get = address => getBinaryFromAddress(address, data);
 
+    // Parse Mii name (10 UTF-16BE characters starting at byte 2)
     var name = "";
     for (var i = 0; i < 10; i++) {
-        name += data.slice(3 + i * 2, 4 + i * 2) + "";
+        const offset = 2 + i * 2;
+        // Read as big-endian UTF-16
+        const charCode = (data[offset] << 8) | data[offset + 1];
+        if (charCode !== 0) {
+            name += String.fromCharCode(charCode);
+        }
     }
-    thisMii.meta.name = name.replaceAll("\x00", "");
+    thisMii.meta.name = name;
+    
+    // Parse creator name (10 UTF-16BE characters starting at byte 54)
     var cname = "";
     for (var i = 0; i < 10; i++) {
-        cname += data.slice(55 + i * 2, 56 + i * 2) + "";
+        const offset = 54 + i * 2;
+        const charCode = (data[offset] << 8) | data[offset + 1];
+        if (charCode !== 0) {
+            cname += String.fromCharCode(charCode);
+        }
     }
-    thisMii.meta.creatorName = cname.replaceAll("\x00", "");
+    thisMii.meta.creatorName = cname;
     thisMii.general.gender = +get(0x00)[1];//0 for Male, 1 for Female
-    thisMii.meta.miiId = data.readUInt32BE(0x18).toString(16).padStart(8, '0');
+    thisMii.meta.miiId = readUInt32BE(data, 0x18).toString(16).padStart(8, '0');
     switch (thisMii.meta.miiId.slice(0, 3)) {
         case "010":
             thisMii.meta.type = "Special";
@@ -596,7 +693,7 @@ async function readWiiBin(binOrPath) {
             thisMii.meta.type = "Default";
             break;
     }
-    thisMii.meta.systemId = data.readUInt32BE(0x1C).toString(16).padStart(8, '0').toUpperCase();
+    thisMii.meta.systemId = readUInt32BE(data, 0x1C).toString(16).padStart(8, '0').toUpperCase();
     var temp = get(0x20);
     thisMii.face.type = parseInt(temp.slice(0, 3), 2);//0-7
     thisMii.face.color = parseInt(temp.slice(3, 6), 2);//0-5
@@ -691,17 +788,20 @@ function decode3DSMii(data) {
     };
     const get = address => getBinaryFromAddress(address, data);
     miiJson.perms.copying = get(0x01)[7] === "1" ? true : false;
-    const miiIdValue = data.readUInt32BE(0x0C);
-    const systemIdHigh = data.readUInt32BE(0x04);
-    const systemIdLow = data.readUInt32BE(0x08);
+    const miiIdValue = readUInt32BE(data, 0x0C);
+    const systemIdHigh = readUInt32BE(data, 0x04);
+    const systemIdLow = readUInt32BE(data, 0x08);
 
     miiJson.meta.type = (miiIdValue & 0x80000000) === 0 ? "Special" : "Default";
     miiJson.meta.systemId = systemIdHigh.toString(16).padStart(8, '0') + systemIdLow.toString(16).padStart(8, '0');
     miiJson.meta.miiId = miiIdValue.toString(16).padStart(8, '0');
     var temp = get(0x18);
     var temp2 = get(0x19);
+    miiJson.meta.favorited=+temp2[1];
+    miiJson.general.favoriteColor = parseInt(temp2.slice(2, 6), 2);
     miiJson.general.birthday = parseInt(temp2.slice(6, 8) + temp.slice(0, 3), 2);
     miiJson.general.birthMonth = parseInt(temp.slice(3, 7), 2);
+    miiJson.general.gender = +temp[7];
     //Handle UTF-16 Names
     var name = "";
     for (var i = 0x1A; i < 0x2E; i += 2) {
@@ -727,10 +827,8 @@ function decode3DSMii(data) {
     miiJson.meta.creatorName = cname.replace(/\u0000/g, "");
     miiJson.general.height = parseInt(get(0x2E), 2);
     miiJson.general.weight = parseInt(get(0x2F), 2);
-    miiJson.general.gender = +temp[7];
     temp = get(0x30);
     miiJson.perms.sharing = temp[7] === "1" ? false : true;
-    miiJson.general.favoriteColor = parseInt(temp2.slice(2, 6), 2);
     miiJson.hair.page = lookupTable("hairs", parseInt(get(0x32), 2), true)[0];
     miiJson.hair.type = lookupTable("hairs", parseInt(get(0x32), 2), true)[1];
     miiJson.face.type = lookupTable("faces", parseInt(temp.slice(3, 7), 2), false);
@@ -802,12 +900,36 @@ function decode3DSMii(data) {
     miiJson.console = "3DS";
     return miiJson;
 }
+function read3DSBin(bin) {
+    if (bin instanceof Uint8Array) {
+        return decode3DSMii(bin);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer?.(bin)) {
+        return decode3DSMii(bin);
+    }
+    if (bin instanceof ArrayBuffer) {
+        return decode3DSMii(new Uint8Array(bin));
+    }
+    throw new Error("read3DSBin expects a Uint8Array, Buffer, or ArrayBuffer");
+}
 async function read3DSQR(binOrPath, returnDecryptedBin, returnEncryptedBin) {
     let qrCode;
-    if (Buffer.isBuffer(binOrPath)) {//Buffer
+    
+    // Handle Uint8Array input (browser-friendly)
+    if (binOrPath instanceof Uint8Array) {
+        qrCode = binOrPath;
+    }
+    else if (typeof Buffer !== "undefined" && Buffer.isBuffer(binOrPath)) {
         qrCode = binOrPath;
     }
-    else if (/[^01]/ig.test(binOrPath)) {//File path
+    else if (binOrPath instanceof ArrayBuffer) {
+        qrCode = new Uint8Array(binOrPath);
+    }
+    else if (typeof binOrPath === 'string' && /[^01]/ig.test(binOrPath)) {
+        // It's a file path - only works in Node.js
+        if (!isNode || !fs) {
+            throw new Error("File path reading only available in Node.js. Pass a Uint8Array or use read3DSQRFromImage in browser.");
+        }
         var data = await fs.promises.readFile(binOrPath);
         var img = await loadImage(data);
         const canvas = createCanvas(img.width, img.height);
@@ -820,19 +942,29 @@ async function read3DSQR(binOrPath, returnDecryptedBin, returnEncryptedBin) {
             return;
         }
     }
-    else {//String of 0s and 1s
+    else if (typeof binOrPath === 'string') {
+        // String of 0s and 1s
         var d = binOrPath.match(/(0|1){1,8}/g);
         qrCode = [];
         d.forEach(byte => {
             qrCode.push(parseInt(byte, 2));
         });
     }
+    else {
+        throw new Error("Invalid input type for read3DSQR");
+    }
+    
     if (qrCode) {
+        // If input looks like decrypted 3DS Mii data (Amiibo/Mii binary), decode directly
+        if ((qrCode.length === 92 || qrCode.length === 96) && !returnEncryptedBin && !returnDecryptedBin) {
+            return decode3DSMii(qrCode instanceof Uint8Array ? qrCode : new Uint8Array(qrCode));
+        }
         if (returnEncryptedBin) {
             return new Uint8Array(qrCode);
         }
         var data;
-        data = Buffer.from(decodeAesCcm(new Uint8Array(qrCode)));
+        const qrArray = qrCode instanceof Uint8Array ? qrCode : new Uint8Array(qrCode);
+        data = typeof Buffer !== "undefined" ? Buffer.from(decodeAesCcm(qrArray)) : new Uint8Array(decodeAesCcm(qrArray));
         if (returnDecryptedBin) {
             return data;
         }
@@ -850,6 +982,16 @@ async function read3DSQR(binOrPath, returnDecryptedBin, returnEncryptedBin) {
         console.error('Failed to read Mii.');
     }
 }
+
+// Browser-friendly QR code reader from ImageData
+async function read3DSQRFromImageData(imageData, returnDecryptedBin) {
+    const qrCode = jsQR(imageData.data, imageData.width, imageData.height)?.binaryData;
+    if (!qrCode) {
+        throw new Error("Failed to read QR Code from image data.");
+    }
+    return read3DSQR(new Uint8Array(qrCode), returnDecryptedBin);
+}
+
 async function renderMiiWithStudio(jsonIn) {
     if (!["3ds", "wii u"].includes(jsonIn.console?.toLowerCase())) {
         jsonIn = convertMii(jsonIn);
@@ -1212,6 +1354,12 @@ async function createFFLMiiIcon(data, options, shirtColor, fflRes) {
 }
 
 async function renderMii(jsonIn, options = {}, fflRes = getFFLRes()) {
+    // FFL rendering requires Node.js environment
+    if (!isNode) {
+        console.warn("renderMii with FFL requires Node.js. Falling back to Mii Studio rendering.");
+        return renderMiiWithStudio(jsonIn);
+    }
+    
     if (!["3ds", "wii u"].includes(jsonIn.console?.toLowerCase())) {
         jsonIn = convertMii(jsonIn);
     }
@@ -1343,15 +1491,25 @@ async function writeWiiBin(jsonIn, outPath) {
     for (var i = 0; i < toWrite.length; i++) {
         buffers.push(parseInt(toWrite[i], 2));
     }
-    toWrite = Buffer.from(buffers);
+    
+    // Return Uint8Array for browser compatibility, Buffer for Node.js
+    const result = typeof Buffer !== "undefined" ? Buffer.from(buffers) : new Uint8Array(buffers);
+    
     if (outPath) {
-        await fs.promises.writeFile(outPath, toWrite);
+        if (!isNode || !fs) {
+            throw new Error("File writing only available in Node.js. Omit outPath to get the binary data.");
+        }
+        await fs.promises.writeFile(outPath, result);
     }
     else {
-        return toWrite;
+        return result;
     }
 }
 async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
+    if (outPath && (!isNode || !fs)) {
+        throw new Error("File writing only available in Node.js. Omit outPath to get the QR image buffer.");
+    }
+    
     //Convert the Mii if it isn't in 3DS format
     if (!["3ds", "wii u"].includes(miiJson.console?.toLowerCase())) {
         miiJson = convertMii(miiJson);
@@ -1361,7 +1519,7 @@ async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
     var mii = miiJson;
     var miiBin = "00000011";//Mii version, which for 3DS is 3
     //If Special Miis are being used improperly, fix it and warn the user
-    if (mii.meta.type.toLowerCase() === "special" && (mii.console.toLowerCase() === "wii u" || mii.console.toLowerCase() === "wiiu")) {
+    if (mii.meta.type.toLowerCase() === "special" && (mii.console?.toLowerCase() === "wii u" || mii.console?.toLowerCase() === "wiiu")) {
         mii.meta.type = "Default";
         console.warn("Wii Us do not work with Special Miis. Reverted output to Default Mii.");
     }
@@ -1378,8 +1536,8 @@ async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
         miiBin += mii.meta.systemId.replaceAll(' ','').match(/.{1,2}/g).map(b=>parseInt(b,16).toString(2).padStart(8,'0')).join('').padStart(64,'0').slice(-64); // Use slice(-64)
     }
     else{
-        //Donor System ID
-        miiBin += "1000101011010010000001101000011100011000110001100100011001100110010101100111111110111100000001110101110001000101011101100000001110100100010000000000000000000000";
+        //Donor System ID (64 bits = 8 bytes)
+        miiBin += "1000101011010010000001101000011100011000110001100100011001100110";
     }
     miiBin += mii.meta.type === "Special" ? "0" : "1";
     miiBin += "001";
@@ -1391,7 +1549,7 @@ async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
         // Number of 2-second intervals since Jan 1, 2010
         temp += Math.floor((Date.now() - Date.UTC(2010, 0, 1)) / 2000).toString(2);
     }
-    miiBin += temp.padStart(32, '0').slice(-27); // Take rightmost 27 bits
+    miiBin += temp.padStart(28, '0').slice(-28); // Take rightmost 28 bits (type + 001 + 28 bits = 32 bits)
     miiBin += "0000000001000101011101100000001110100100010000000000000000000000";
     miiBin += mii.general.birthday.toString(2).padStart(5, "0").slice(2, 5);
     miiBin += mii.general.birthMonth.toString(2).padStart(4, "0");
@@ -1488,16 +1646,20 @@ async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
     for (var i = 0; i < toWrite.length; i++) {
         buffers.push(parseInt(toWrite[i], 2));
     }
-    const buffer = Buffer.from(buffers);
-    var encryptedData = Buffer.from(encodeAesCcm(new Uint8Array(buffer)));
+    const buffer = typeof Buffer !== "undefined" ? Buffer.from(buffers) : new Uint8Array(buffers);
+    const encryptedBytes = encodeAesCcm(new Uint8Array(buffer));
+    const encryptedData = typeof Buffer !== "undefined" ? Buffer.from(encryptedBytes) : new Uint8Array(encryptedBytes);
     if (returnBin) {
         return encryptedData;
     }
+    const qrData = (typeof Buffer !== "undefined" && Buffer.isBuffer?.(encryptedData))
+        ? encryptedData.toString("latin1")
+        : Array.from(encryptedData, b => String.fromCharCode(b)).join("");
     //Prepare a QR code
     const options = {
         width: 300,
         height: 300,
-        data: encryptedData.toString("latin1"),
+        data: qrData,
         image: "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==", // 1x1 gif
         dotsOptions: {
             color: "#000000",
@@ -1514,6 +1676,10 @@ async function write3DSQR(miiJson, outPath, returnBin, fflRes = getFFLRes()) {
             errorCorrectionLevel: 'H'
         }
     }
+    if (!isNode) {
+        const qrCodeImage = new QRCodeStyling(options);
+        return await qrCodeImage.getRawData("png");
+    }
     const qrCodeImage = new QRCodeStyling({
         jsdom: JSDOM,
         nodeCanvas,
@@ -1946,10 +2112,113 @@ function miiIdToTimestamp(miiId, mode){
     }
 }
 
+const formats=require("./formats.js");
+function bufferToBitString(buf) {
+    let out = '';
+    for (let i = 0; i < buf.length; i++) {
+        out += buf[i].toString(2).padStart(8, '0');
+    }
+    return out;
+}
+function isValidUTF16(bits) {
+    if (bits.length % 16) return false;
+
+    for (let i = 0; i < bits.length; i += 16) {
+        const u = parseInt(bits.slice(i, i + 16), 2);
+
+        // high surrogate must be followed by a low surrogate
+        if (u >= 0xD800 && u <= 0xDBFF) {
+            if (i + 32 > bits.length) return false;
+            const n = parseInt(bits.slice(i + 16, i + 32), 2);
+            if (!(n >= 0xDC00 && n <= 0xDFFF)) return false;
+            i += 16; // consumed the low surrogate too
+        }
+        // low surrogate without a preceding high surrogate is invalid
+        else if (u >= 0xDC00 && u <= 0xDFFF) {
+            return false;
+        }
+    }
+
+    return true;
+}
 
-module.exports = {
+function validateMii(buf, format, verbose) {
+    if (!Buffer.isBuffer(buf)) return false;
+    format = format ? format.toLowerCase().replaceAll(".", '') : null;
+    let matches = [];
+    Object.keys(formats).forEach(form => {
+        if (!(format === form || format === 'all' || format === 'any' || !format)) return;
+        if (buf.length !== formats[form].length) return;
+
+        let bits = bufferToBitString(buf);
+        let offset = 0;
+        let valid = true;
+        let wordBits = null;
+        let wordPos = 0;
+        let wordEnd = 0;
+        if (formats[form].hasOwnProperty('struct')) {
+            for (const field of formats[form].struct) {
+                // Start a word window (does NOT consume offset)
+                if (field.word) {
+                    const raw = bits.slice(offset, offset + field.length);
+                    const bytes = raw.match(/.{1,8}/g) || [];
+                    wordBits = bytes.map(b => b.split('').reverse().join('')).join('');
+                    wordPos = 0;
+                    wordEnd = field.length;
+                    continue;
+                }
+                let slice;
+                const inWord = wordBits && wordPos + field.length <= wordEnd;
+                if (inWord) {
+                    slice = wordBits.slice(wordPos, wordPos + field.length);
+                } else {
+                    slice = bits.slice(offset, offset + field.length);
+                }
+
+                if (field.text) {
+                    valid = isValidUTF16(slice);
+                    if (!valid) {
+                        if (verbose) console.warn(`${form} contains text that does not match UTF-16`);
+                        break;
+                    }
+                } else if (field.max || field.min) {
+                    // If slice came from wordBits, it's LSB->MSB; reverse it before parseInt.
+                    const numBits = inWord ? slice.split('').reverse().join('') : slice;
+                    const subset = parseInt(numBits, 2);
+
+                    if (subset < (field.min || 0) || subset > (field.max || subset + 1)) {
+                        valid = false;
+                        if (verbose) console.log(`${form} fails due to ${field.name} being ${subset}, which is outside the stated bounds of ${field.min || 0}-${field.max || subset + 1}`);
+                        break;
+                    }
+                }
+
+                // advance positions
+                offset += field.length;
+                if (inWord) {
+                    wordPos += field.length;
+                    if (wordPos >= wordEnd) wordBits = null; //Finished this word block
+                }
+            }
+        }
+
+        if (valid) matches.push(form);
+    });
+
+    return matches;
+}
+
+// Export for browser global when bundled
+const MiiJSExports = {
+    ...require("./amiiboHandler.js"),
+
+    // Environment detection
+    isBrowser,
+    isNode,
+    
     // Data
     Enums: require("./Enums"),
+    formats,
 
     //Convert
     convertMii,
@@ -1959,6 +2228,8 @@ module.exports = {
     //Read
     readWiiBin,
     read3DSQR,
+    read3DSBin,
+    read3DSQRFromImageData, // Browser-friendly QR reader
 
     //Render
     renderMiiWithStudio,
@@ -1984,10 +2255,19 @@ module.exports = {
 
     miiIdToTimestamp,
 
-    /*
-    Handle Amiibo Functions
-    insertMiiIntoAmiibo(amiiboDump, decrypted3DSMiiBuffer),
-    extractMiiFromAmiibo(amiiboDump)
-    */
-    ...require("./amiiboHandler.js")
+    // Crypto utilities (useful for browser)
+    decodeAesCcm,
+    encodeAesCcm,
+    encodeStudio,
+    decodeStudio,
+};
+
+// Export for CommonJS
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = MiiJSExports;
+}
+
+// Export for browser global
+if (typeof window !== 'undefined') {
+    window.MiiJS = MiiJSExports;
 }