miijs 2.4.2 → 2.5.1

package/README.md

@@ -47,9 +47,10 @@ MiiJS is a complete and comprehensive Mii library for reading, converting, modif
 - **`miiHeightToMeasurements(miiHeight)`** - Converts Mii height value (0-127) to real-world feet and inches. Returns `{feet, inches, totalInches, centimeters}`.
 - **`inchesToMiiHeight(totalInches)`** - Converts real-world height in inches to Mii height value (0-127).
 - **`centimetersToMiiHeight(totalCentimeters)`** - Converts real-world height in centimeters to Mii height value (0-127).
-- **`miiHeightWeightToRealWeight(miiWeight)`** - Converts Mii weight value (0-127) to real-world weight values. Returns `{pounds, kilograms}`.
+- **`miiWeightToRealWeight(miiWeight)`** - Converts Mii weight value (0-127) to real-world weight values. Returns `{pounds, kilograms}`.
 - **`imperialHeightWeightToMiiWeight(heightInches, weightLbs)`** - Converts real-world imperial measurements to Mii weight values.
 - **`metricHeightWeightToMiiWeight(heightCentimeters, weightKilograms)`** - Converts real-world metric measurements to Mii weight values.
+- **`miiIdToTimestamp(miiId, consoleMiiIdIsFrom)`** - Converts the Mii ID into a JS Date/Timestamp.
 
 ### Other Functions
 - **`makeChild(miiJson1, miiJson2, options?)`** - Returns an array of 6 different Mii JSONs, which represent a child generated from the two parent Miis passed to the function at different stages of life. This is somewhat experimental, but should be accurate to my current knowledge. You can pass any or none of { name: "The Name", creatorName: "The Name", favoriteColor: 0-11, gender: 0-1/\*0:Male, 1:Female\*/ }
@@ -62,12 +63,11 @@ MiiJS is a complete and comprehensive Mii library for reading, converting, modif
 ```javascript
 const miijs = require('miijs');
 
-// Read from file path
+// Read from file path for image, or buffer of the data - encrypted or decrypted
 const miiJson = await miijs.read3DSQR('./example3DSQR.jpg');
 console.log('Mii Name:', miiJson.meta.name);
-console.log('Favorite Color:', miiJson.general.favoriteColor);
 
-// Or get just the decrypted binary data
+// Get the decrypted binary data
 const decryptedBin = await miijs.read3DSQR('./example3DSQR.jpg', true);
 console.log('Decrypted binary length:', decryptedBin.length);
 ```
@@ -79,7 +79,6 @@ const miijs = require('miijs');
 // Read from file path
 const miiJson = await miijs.readWiiBin('./exampleWii.bin');
 console.log('Mii Name:', miiJson.meta.name);
-console.log('Gender:', miiJson.general.gender === 0 ? 'Male' : 'Female');
 
 // Or pass binary data directly
 const fs = require('fs');
@@ -94,13 +93,10 @@ const miijs = require('miijs');
 // First, read or create a Mii JSON
 const miiJson = await miijs.read3DSQR('./example3DSQR.jpg');
 
-// Write QR code with Studio rendering (no FFLResHigh.dat needed)
+// Write QR code. If FFLResHigh.dat is in the same directory, will be used automatically. You can pass a buffer containing FFLResHigh.dat as a fourth parameter. Will use Studio rendering instead of local without FFLResHigh.dat.
 await miijs.write3DSQR(miiJson, './output_qr.jpg');
-
-// Or with local rendering (requires FFLResHigh.dat in project root or passed as buffer)
-const fs = require('fs');
-const fflRes = fs.readFileSync('./FFLResHigh.dat');
-await miijs.write3DSQR(miiJson, './output_qr_local.jpg', fflRes);
+//The third parameter asks MiiJS to return an encrypted 3DS data instead
+const encryptedData=await miijs.write3DSQR(miiJson,'',true);
 ```
 
 ## Writing a Wii Mii Binary
@@ -108,11 +104,8 @@ await miijs.write3DSQR(miiJson, './output_qr_local.jpg', fflRes);
 const miijs = require('miijs');
 const fs = require('fs');
 
-// Read a Mii (from any format)
-const miiJson = await miijs.read3DSQR('./example3DSQR.jpg');
-
-// Convert to Wii format first if needed
-const wiiMii = miijs.convertMii(miiJson, 'wii');
+// Read a Mii
+const miiJson = await miijs.readWiiBin('./exampleWii.bin');
 
 // Write to file
 await miijs.writeWiiBin(wiiMii, './output_wii.bin');
@@ -127,16 +120,16 @@ fs.writeFileSync('./manual_write.bin', buffer);
 const miijs = require('miijs');
 
 // Read a 3DS Mii
-const ds3Mii = await miijs.read3DSQR('./example3DSQR.jpg');
+const mii3DS = await miijs.read3DSQR('./example3DSQR.jpg');
 
 // Convert to Wii format
-const wiiMii = miijs.convertMii(ds3Mii, 'wii');
+const miiWii = miijs.convertMii(mii3DS, 'wii');
 
 // Convert back to 3DS
-const backTo3DS = miijs.convertMii(wiiMii, '3ds');
+const backTo3DS = miijs.convertMii(miiWii, '3ds');
 
 // Auto-detect and convert to opposite
-const autoConverted = miijs.convertMii(ds3Mii);
+const autoConverted = miijs.convertMii(mii3DS);
 ```
 
 ## Converting to/from Studio Format
@@ -151,7 +144,6 @@ console.log('Studio URL:', `https://studio.mii.nintendo.com/miis/image.png?data=
 // Convert Studio format back to JSON
 const studioData = '000d142a303f434b717a7b84939ba6b2bbbec5cbc9d0e2ea...';
 const miiFromStudio = miijs.convertStudioToMii(studioData);
-console.log('Converted Mii:', miiFromStudio.meta.name);
 ```
 
 ## Rendering Miis
@@ -162,16 +154,15 @@ const fs = require('fs');
 // Read a Mii
 const miiJson = await miijs.read3DSQR('./example3DSQR.jpg');
 
-// Render using Studio API (simple, no setup needed)
+// Render using Studio API (simple, no setup needed, requires internet access)
 const studioPng = await miijs.renderMiiWithStudio(miiJson);
 fs.writeFileSync('./mii_studio_render.png', studioPng);
 
 // Render locally with full body (requires FFLResHigh.dat)
+// FFLResHigh.dat can be placed in the project directory to automatically use
 const fflRes = fs.readFileSync('./FFLResHigh.dat');
 const localPng = await miijs.renderMii(miiJson, fflRes);
 fs.writeFileSync('./mii_local_render.png', localPng);
-
-// Shirt color comes from miiJson.general.favoriteColor
 ```
 
 ## Working with Amiibos
@@ -183,13 +174,11 @@ const fs = require('fs');
 const amiiboDump = fs.readFileSync('./exampleAmiiboDump.bin');
 
 // Extract the Mii from the Amiibo (returns 92 bytes decrypted)
-const miiData = miijs.extractMiiFromAmiibo(amiiboDump);
-
+let miiData = miijs.extractMiiFromAmiibo(amiiboDump);
 // Convert the raw Mii data to readable JSON
-// (miiData is already decrypted 3DS format)
-const miiJson = miijs.decode3DSMii(miiData); // Note: decode3DSMii not exported, use read3DSQR workflow
+const miiJson = miijs.read3DSQR(miiData);
 
-// Better workflow: Read from QR, get decrypted data, insert into Amiibo
+// Read from QR, get decrypted data, insert into Amiibo
 const qrMiiJson = await miijs.read3DSQR('./example3DSQR.jpg');
 const decryptedMiiData = await miijs.read3DSQR('./example3DSQR.jpg', true);
 
@@ -224,23 +213,28 @@ Object.entries(fullInstructions).forEach(([field, instruction]) => {
 ```javascript
 const miijs = require('miijs');
 
-// Convert Mii height (0-127) to feet/inches
-const heightInfo = miijs.miiHeightToFeetInches(64); // midpoint value
-console.log(`Height: ${heightInfo.feet}'${heightInfo.inches}" (${heightInfo.totalInches} inches)`);
+// Convert Mii height (0-127) to feet/inches and centimeters
+const heightInfo = miijs.miiHeightToMeasurements(64); // midpoint value
+console.log(`Height: ${heightInfo.feet}'${heightInfo.inches}" (${heightInfo.centimeters} cm)`);
 
 // Convert real height to Mii value
-const miiHeightValue = miijs.inchesToMiiHeight(72); // 6'0"
+const miiHeightValue = miijs.inchesToMiiHeight(72);
 console.log('Mii height value for 6\'0":', miiHeightValue);
 
-// EXPERIMENTAL: Convert real weight to Mii weight
-const heightInches = 69; // 5'9"
-const weightLbs = 160;
-const miiWeightValue = miijs.heightWeightToMiiWeight(heightInches, weightLbs);
+// Convert Mii weight to real weight (requires height)
+const miiHeight = 64;
+const miiWeight = 64;
+const weightInfo = miijs.miiWeightToRealWeight(miiHeight, miiWeight);
+console.log(`Weight: ${weightInfo.pounds.toFixed(1)} lbs (${weightInfo.kilograms} kg)`);
+
+// Convert real weight to Mii weight value
+const heightInches=70;
+const weightLbs = 150;
+const miiWeightValue = miijs.imperialHeightWeightToMiiWeight(heightInches, weightLbs);
 console.log('Mii weight value:', miiWeightValue);
 
-// EXPERIMENTAL: Convert Mii weight to real weight
-const weightInfo = miijs.miiWeightToRealWeight(heightInches, 64);
-console.log(`Weight: ${weightInfo.pounds.toFixed(1)} lbs, BMI: ${weightInfo.bmi.toFixed(1)}`);
+// Or use metric
+const miiWeightMetric = miijs.metricHeightWeightToMiiWeight(175, 72.5);
 ```
 
 ## Creating and Modifying a Mii
@@ -251,10 +245,10 @@ const miijs = require('miijs');
 const miiJson = await miijs.read3DSQR('./example3DSQR.jpg');
 
 // Modify properties
-miiJson.meta.name = 'Custom Name';
-miiJson.general.favoriteColor = 5; // Blue
-miiJson.hair.color = 0; // Black
-miiJson.eyes.color = 2; // Brown
+miiJson.meta.name = 'CustomName';
+miiJson.general.favoriteColor = 5;
+miiJson.hair.color = 0;
+miiJson.eyes.color = 2;
 
 // Make it a Special Mii (3DS only)
 miiJson.meta.type = 'Special';
@@ -287,6 +281,19 @@ for(var i=0;i<child.length;i++){
 }
 ```
 
+## Getting the Time the Mii Was Created From the Mii ID
+```javascript
+const miijs=require('miijs');
+
+//Read miis into JSON 
+const mii3DS=await miijs.read3DSQR('./example_mii.jpg');
+const miiWii=await miijs.readWiiBin('./example_mii.bin');
+
+//Same process for both, returns a JS Date/Timestamp
+console.log(miijs.miiIdToTimestamp(mii3DS.meta.miiId,mii3DS.console));
+console.log(miijs.miiIdToTimestamp(miiWii.meta.miiId,miiWii.console));
+```
+
 <hr>
 
 ## Special Miis

package/amiiboHandler.js

@@ -1,4 +1,12 @@
-const crypto = require('crypto');
+const { Buffer } = require('buffer');
+
+const isBrowser = typeof window !== 'undefined' && typeof window.crypto !== 'undefined';
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+const nodeCrypto = isNode ? require('crypto') : null;
+const subtleCrypto = (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle)
+    ? globalThis.crypto.subtle
+    : (nodeCrypto && nodeCrypto.webcrypto ? nodeCrypto.webcrypto.subtle : null);
 
 /*This constant is provided SOLELY because I cannot find a guide online to retrieve this file from a console or Amiibo on your own that doesn't just tell you to download it from somewhere anyway.
 If someone can find, or make, a guide for this, I will wipe all commits of this key from the repo and instead point to how to get this key for yourself.*/
@@ -89,7 +97,7 @@ function drbgGenerateBytes(hmacKey, seed, outputSize) {
         iterBuffer[0] = (iteration >> 8) & 0xFF;
         iterBuffer[1] = iteration & 0xFF;
         seed.copy(iterBuffer, 2);
-        const hmac = crypto.createHmac('sha256', hmacKey);
+        const hmac = nodeCrypto.createHmac('sha256', hmacKey);
         hmac.update(iterBuffer);
         const output = hmac.digest();
         const toCopy = Math.min(32, outputSize - offset);
@@ -100,6 +108,24 @@ function drbgGenerateBytes(hmacKey, seed, outputSize) {
     return result;
 }
 
+async function drbgGenerateBytesAsync(hmacKey, seed, outputSize) {
+    const result = Buffer.alloc(outputSize);
+    let offset = 0;
+    let iteration = 0;
+    while (offset < outputSize) {
+        const iterBuffer = Buffer.alloc(2 + seed.length);
+        iterBuffer[0] = (iteration >> 8) & 0xFF;
+        iterBuffer[1] = iteration & 0xFF;
+        seed.copy(iterBuffer, 2);
+        const output = await hmacSha256Async(hmacKey, iterBuffer);
+        const toCopy = Math.min(32, outputSize - offset);
+        output.copy(result, offset, 0, toCopy);
+        offset += toCopy;
+        iteration++;
+    }
+    return result;
+}
+
 function deriveKeys(typeString, magicBytes, magicBytesSize, xorPad, hmacKey, baseSeed) {
     const preparedSeed = prepareSeed(typeString, magicBytes, magicBytesSize, xorPad, baseSeed);
     const derived = drbgGenerateBytes(hmacKey, preparedSeed, 48);
@@ -110,6 +136,66 @@ function deriveKeys(typeString, magicBytes, magicBytesSize, xorPad, hmacKey, bas
     };
 }
 
+async function deriveKeysAsync(typeString, magicBytes, magicBytesSize, xorPad, hmacKey, baseSeed) {
+    const preparedSeed = prepareSeed(typeString, magicBytes, magicBytesSize, xorPad, baseSeed);
+    const derived = await drbgGenerateBytesAsync(hmacKey, preparedSeed, 48);
+    return {
+        aesKey: derived.slice(0, 16),
+        aesIV: derived.slice(16, 32),
+        hmacKey: derived.slice(32, 48)
+    };
+}
+
+function ensureBuffer(input, name) {
+    if (Buffer.isBuffer(input)) {
+        return input;
+    }
+    if (input instanceof Uint8Array) {
+        return Buffer.from(input);
+    }
+    if (input instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(input));
+    }
+    throw new Error(`${name} must be a Buffer or Uint8Array`);
+}
+
+async function hmacSha256Async(key, data) {
+    if (!subtleCrypto) {
+        throw new Error('Web Crypto API is not available');
+    }
+    const cryptoKey = await subtleCrypto.importKey(
+        'raw',
+        ensureBuffer(key, 'HMAC key'),
+        { name: 'HMAC', hash: 'SHA-256' },
+        false,
+        ['sign']
+    );
+    const signature = await subtleCrypto.sign('HMAC', cryptoKey, ensureBuffer(data, 'HMAC data'));
+    return Buffer.from(new Uint8Array(signature));
+}
+
+async function aesCtrCryptAsync(key, iv, data, encrypt) {
+    if (!subtleCrypto) {
+        throw new Error('Web Crypto API is not available');
+    }
+    const cryptoKey = await subtleCrypto.importKey(
+        'raw',
+        ensureBuffer(key, 'AES key'),
+        { name: 'AES-CTR' },
+        false,
+        encrypt ? ['encrypt'] : ['decrypt']
+    );
+    const algorithm = {
+        name: 'AES-CTR',
+        counter: ensureBuffer(iv, 'AES IV'),
+        length: 128,
+    };
+    const result = encrypt
+        ? await subtleCrypto.encrypt(algorithm, cryptoKey, ensureBuffer(data, 'AES data'))
+        : await subtleCrypto.decrypt(algorithm, cryptoKey, ensureBuffer(data, 'AES data'));
+    return Buffer.from(new Uint8Array(result));
+}
+
 function tagToInternal(tag) {
     const internal = Buffer.alloc(NFC3D_AMIIBO_SIZE);
     tag.slice(0x008, 0x010).copy(internal, 0x000);
@@ -140,38 +226,56 @@ function decryptAmiibo(tag) {
     const dataKeys = deriveKeys(DATA_TYPE_STRING, DATA_MAGIC_BYTES, DATA_MAGIC_BYTES_SIZE, DATA_XOR_PAD, DATA_HMAC_KEY, seed);
     const tagKeys = deriveKeys(TAG_TYPE_STRING, TAG_MAGIC_BYTES, TAG_MAGIC_BYTES_SIZE, TAG_XOR_PAD, TAG_HMAC_KEY, seed);
     const plain = Buffer.alloc(NFC3D_AMIIBO_SIZE);
-    const cipher = crypto.createDecipheriv('aes-128-ctr', dataKeys.aesKey, dataKeys.aesIV);
+    const cipher = nodeCrypto.createDecipheriv('aes-128-ctr', dataKeys.aesKey, dataKeys.aesIV);
     cipher.setAutoPadding(false);
     const decrypted = cipher.update(internal.slice(0x02C, 0x1B4));
     decrypted.copy(plain, 0x02C);
     internal.slice(0x000, 0x008).copy(plain, 0x000);
     internal.slice(0x028, 0x02C).copy(plain, 0x028);
     internal.slice(0x1D4, 0x208).copy(plain, 0x1D4);
-    const tagHmac = crypto.createHmac('sha256', tagKeys.hmacKey);
+    const tagHmac = nodeCrypto.createHmac('sha256', tagKeys.hmacKey);
     tagHmac.update(plain.slice(0x1D4, 0x208));
     const computedTagHmac = tagHmac.digest();
     computedTagHmac.copy(plain, 0x1B4);
-    const dataHmac = crypto.createHmac('sha256', dataKeys.hmacKey);
+    const dataHmac = nodeCrypto.createHmac('sha256', dataKeys.hmacKey);
     dataHmac.update(plain.slice(0x029, 0x208));
     const computedDataHmac = dataHmac.digest();
     computedDataHmac.copy(plain, 0x008);
     return plain;
 }
 
+async function decryptAmiiboAsync(tag) {
+    const internal = tagToInternal(tag);
+    const seed = calcSeed(internal);
+    const dataKeys = await deriveKeysAsync(DATA_TYPE_STRING, DATA_MAGIC_BYTES, DATA_MAGIC_BYTES_SIZE, DATA_XOR_PAD, DATA_HMAC_KEY, seed);
+    const tagKeys = await deriveKeysAsync(TAG_TYPE_STRING, TAG_MAGIC_BYTES, TAG_MAGIC_BYTES_SIZE, TAG_XOR_PAD, TAG_HMAC_KEY, seed);
+    const plain = Buffer.alloc(NFC3D_AMIIBO_SIZE);
+    const decrypted = await aesCtrCryptAsync(dataKeys.aesKey, dataKeys.aesIV, internal.slice(0x02C, 0x1B4), false);
+    decrypted.copy(plain, 0x02C);
+    internal.slice(0x000, 0x008).copy(plain, 0x000);
+    internal.slice(0x028, 0x02C).copy(plain, 0x028);
+    internal.slice(0x1D4, 0x208).copy(plain, 0x1D4);
+    const tagHmac = await hmacSha256Async(tagKeys.hmacKey, plain.slice(0x1D4, 0x208));
+    tagHmac.copy(plain, 0x1B4);
+    const dataHmac = await hmacSha256Async(dataKeys.hmacKey, plain.slice(0x029, 0x208));
+    dataHmac.copy(plain, 0x008);
+    return plain;
+}
+
 function encryptAmiibo(plain) {
     const seed = calcSeed(plain);
     const dataKeys = deriveKeys(DATA_TYPE_STRING, DATA_MAGIC_BYTES, DATA_MAGIC_BYTES_SIZE, DATA_XOR_PAD, DATA_HMAC_KEY, seed);
     const tagKeys = deriveKeys(TAG_TYPE_STRING, TAG_MAGIC_BYTES, TAG_MAGIC_BYTES_SIZE, TAG_XOR_PAD, TAG_HMAC_KEY, seed);
     const cipher_internal = Buffer.alloc(NFC3D_AMIIBO_SIZE);
-    const tagHmac = crypto.createHmac('sha256', tagKeys.hmacKey);
+    const tagHmac = nodeCrypto.createHmac('sha256', tagKeys.hmacKey);
     tagHmac.update(plain.slice(0x1D4, 0x208));
     tagHmac.digest().copy(cipher_internal, 0x1B4);
-    const dataHmac = crypto.createHmac('sha256', dataKeys.hmacKey);
+    const dataHmac = nodeCrypto.createHmac('sha256', dataKeys.hmacKey);
     dataHmac.update(plain.slice(0x029, 0x1B4));
     dataHmac.update(cipher_internal.slice(0x1B4, 0x1D4));
     dataHmac.update(plain.slice(0x1D4, 0x208));
     dataHmac.digest().copy(cipher_internal, 0x008);
-    const aesCipher = crypto.createCipheriv('aes-128-ctr', dataKeys.aesKey, dataKeys.aesIV);
+    const aesCipher = nodeCrypto.createCipheriv('aes-128-ctr', dataKeys.aesKey, dataKeys.aesIV);
     aesCipher.setAutoPadding(false);
     const encrypted = aesCipher.update(plain.slice(0x02C, 0x1B4));
     encrypted.copy(cipher_internal, 0x02C);
@@ -181,16 +285,38 @@ function encryptAmiibo(plain) {
     return internalToTag(cipher_internal);
 }
 
+async function encryptAmiiboAsync(plain) {
+    const seed = calcSeed(plain);
+    const dataKeys = await deriveKeysAsync(DATA_TYPE_STRING, DATA_MAGIC_BYTES, DATA_MAGIC_BYTES_SIZE, DATA_XOR_PAD, DATA_HMAC_KEY, seed);
+    const tagKeys = await deriveKeysAsync(TAG_TYPE_STRING, TAG_MAGIC_BYTES, TAG_MAGIC_BYTES_SIZE, TAG_XOR_PAD, TAG_HMAC_KEY, seed);
+    const cipher_internal = Buffer.alloc(NFC3D_AMIIBO_SIZE);
+    const tagHmac = await hmacSha256Async(tagKeys.hmacKey, plain.slice(0x1D4, 0x208));
+    tagHmac.copy(cipher_internal, 0x1B4);
+    const dataHmac = await hmacSha256Async(dataKeys.hmacKey, Buffer.concat([
+        plain.slice(0x029, 0x1B4),
+        cipher_internal.slice(0x1B4, 0x1D4),
+        plain.slice(0x1D4, 0x208)
+    ]));
+    dataHmac.copy(cipher_internal, 0x008);
+    const encrypted = await aesCtrCryptAsync(dataKeys.aesKey, dataKeys.aesIV, plain.slice(0x02C, 0x1B4), true);
+    encrypted.copy(cipher_internal, 0x02C);
+    plain.slice(0x000, 0x008).copy(cipher_internal, 0x000);
+    plain.slice(0x028, 0x02C).copy(cipher_internal, 0x028);
+    plain.slice(0x1D4, 0x208).copy(cipher_internal, 0x1D4);
+    return internalToTag(cipher_internal);
+}
+
 //Extract Mii data from an Amiibo dump
 function extractMiiFromAmiibo(amiiboDump) {
-    if (!Buffer.isBuffer(amiiboDump)) {
-        throw new Error('Amiibo dump must be a Buffer');
-    }
-    const size = amiiboDump.length;
+    const dump = ensureBuffer(amiiboDump, 'Amiibo dump');
+    const size = dump.length;
     if (size !== NFC3D_AMIIBO_SIZE && size !== NTAG215_SIZE && size !== NTAG215_SIZE_ALT) {
         throw new Error(`Invalid Amiibo dump size: ${size} (expected ${NFC3D_AMIIBO_SIZE}, ${NTAG215_SIZE_ALT}, or ${NTAG215_SIZE})`);
     }
-    const tag = amiiboDump.slice(0, NFC3D_AMIIBO_SIZE);
+    const tag = dump.slice(0, NFC3D_AMIIBO_SIZE);
+    if (!isNode) {
+        return extractMiiFromAmiiboAsync(tag, dump.length);
+    }
     const decrypted = decryptAmiibo(tag);
 
     // Extract only the first 92 bytes (the actual Mii data, without checksum)
@@ -199,26 +325,31 @@ function extractMiiFromAmiibo(amiiboDump) {
     return Buffer.from(miiData);
 }
 
+async function extractMiiFromAmiiboAsync(tag, dumpSize) {
+    const decrypted = await decryptAmiiboAsync(tag);
+    const miiData = decrypted.slice(MII_OFFSET_DECRYPTED, MII_OFFSET_DECRYPTED + 92);
+    return Buffer.from(miiData);
+}
+
 //Insert Mii data into an Amiibo dump
 function insertMiiIntoAmiibo(amiiboDump, miiData) {
-    if (!Buffer.isBuffer(amiiboDump)) {
-        throw new Error('Amiibo dump must be a Buffer');
-    }
-    if (!Buffer.isBuffer(miiData)) {
-        throw new Error('Mii data must be a Buffer');
-    }
-    const size = amiiboDump.length;
+    const dump = ensureBuffer(amiiboDump, 'Amiibo dump');
+    const miiBuf = ensureBuffer(miiData, 'Mii data');
+    const size = dump.length;
     if (size !== NFC3D_AMIIBO_SIZE && size !== NTAG215_SIZE && size !== NTAG215_SIZE_ALT) {
         throw new Error(`Invalid Amiibo dump size: ${size}`);
     }
-    if (miiData.length !== 92 && miiData.length !== MII_SIZE) {
-        throw new Error(`Mii data must be 92 or ${MII_SIZE} bytes, got ${miiData.length}`);
+    if (miiBuf.length !== 92 && miiBuf.length !== MII_SIZE) {
+        throw new Error(`Mii data must be 92 or ${MII_SIZE} bytes, got ${miiBuf.length}`);
+    }
+    const tag = dump.slice(0, NFC3D_AMIIBO_SIZE);
+    if (!isNode) {
+        return insertMiiIntoAmiiboAsync(tag, dump, miiBuf);
     }
-    const tag = amiiboDump.slice(0, NFC3D_AMIIBO_SIZE);
     const decrypted = decryptAmiibo(tag);
 
     // Validate and fix Mii checksum, ensuring it's 96 bytes with correct checksum
-    const miiWithChecksum = validateAndFixMiiChecksum(miiData);
+    const miiWithChecksum = validateAndFixMiiChecksum(miiBuf);
 
     // Insert Mii data (96 bytes)
     miiWithChecksum.copy(decrypted, MII_OFFSET_DECRYPTED);
@@ -227,12 +358,25 @@ function insertMiiIntoAmiibo(amiiboDump, miiData) {
     const result = Buffer.alloc(size);
     encrypted.copy(result, 0);
     if (size > NFC3D_AMIIBO_SIZE) {
-        amiiboDump.slice(NFC3D_AMIIBO_SIZE).copy(result, NFC3D_AMIIBO_SIZE);
+        dump.slice(NFC3D_AMIIBO_SIZE).copy(result, NFC3D_AMIIBO_SIZE);
     }
 
     return result;
 }
 
+async function insertMiiIntoAmiiboAsync(tag, dump, miiBuf) {
+    const decrypted = await decryptAmiiboAsync(tag);
+    const miiWithChecksum = validateAndFixMiiChecksum(miiBuf);
+    miiWithChecksum.copy(decrypted, MII_OFFSET_DECRYPTED);
+    const encrypted = await encryptAmiiboAsync(decrypted);
+    const result = Buffer.alloc(dump.length);
+    encrypted.copy(result, 0);
+    if (dump.length > NFC3D_AMIIBO_SIZE) {
+        dump.slice(NFC3D_AMIIBO_SIZE).copy(result, NFC3D_AMIIBO_SIZE);
+    }
+    return result;
+}
+
 module.exports = {
     insertMiiIntoAmiibo,
     extractMiiFromAmiibo

package/asmCrypto.js

@@ -3598,22 +3598,30 @@ function BigNumber_extGCD(a, b) {
 }
 
 function getRandomValues(buf) {
-    if (typeof process !== 'undefined') {
-        var nodeCrypto = require('crypto');
-        var bytes = nodeCrypto.randomBytes(buf.length);
-        buf.set(bytes);
-        return;
+    if (typeof process !== 'undefined' && typeof require === 'function') {
+        try {
+            var nodeCrypto = eval('require')('crypto');
+            var bytes = nodeCrypto.randomBytes(buf.length);
+            buf.set(bytes);
+            return;
+        } catch (e) {
+            // Fall through to browser methods
+        }
     }
-    if (window.crypto && window.crypto.getRandomValues) {
+    if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
         window.crypto.getRandomValues(buf);
         return;
     }
-    if (self.crypto && self.crypto.getRandomValues) {
+    if (typeof self !== 'undefined' && self.crypto && self.crypto.getRandomValues) {
         self.crypto.getRandomValues(buf);
         return;
     }
+    if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.getRandomValues) {
+        globalThis.crypto.getRandomValues(buf);
+        return;
+    }
     // @ts-ignore
-    if (window.msCrypto && window.msCrypto.getRandomValues) {
+    if (typeof window !== 'undefined' && window.msCrypto && window.msCrypto.getRandomValues) {
         // @ts-ignore
         window.msCrypto.getRandomValues(buf);
         return;