silphscope 1.4.2 → 1.4.4

package/README.md

@@ -1,5 +1,11 @@
 still a WIP however hopefully with some more work I can get this into a workable state...
 
+(Amazingly Newer!) Update:
+
+so now ball extraction works! still need to cut the images up but that should be simple
+
+(also move graphics are basically done except for ICE_CHUNK it is a weird image... and I don't know how I am going to cut it up... but everything else is working! that makes it sound like ICE_CHUNK doesn't work... which it does it just doesn't get nicely cut up)
+
 (Even Newer!) Update:
 
 moves now work... kinda... still working on getting it all the way done but it mostly works!
@@ -26,11 +32,12 @@ await renderAllGraphics(rom, {
     outputIconDir: "./Assets/Icons", // same thing here :p
     outputTrainerDir: "./Assets/Trainers", // ...
     outputMoveDir: "./Assets/Moves",
-    sortUnusedMoves: true // just sorts the unused moves into a sub-directory
+    sortUnusedMoves: true, // just sorts the unused moves into a sub-directory
+    outputBallDir: "./Assets/Balls"
 });
 ```
 
-Of course though the above is for extracting all graphics (which is kinda a lie... In reality it only extracts mon images, item icons, trainer images, and move images... but like I said this is a WIP :p so wait a bit please!).
+Of course though the above is for extracting all graphics (which is kinda a lie... In reality it only extracts mon images, item icons, trainer images, move images, and ball images... but like I said this is a WIP :p so wait a bit please!).
 
 But if you want say just the mon images or item icons refer below:
 
@@ -81,4 +88,15 @@ await renderAllMoves(rom, {
     renderMasterImage: true, // kinda forgot about this... basically it renders a uncut image of the move anim if you like
     sortUnused: true, // sorts unused moves into a sub-directory
 })
-```
+```
+
+ball image extraction:
+```JavaScript
+import fs from "fs";
+import { renderAllBalls } from "silphscope" // o-O
+
+const rom = fs.readFileSync("./path/to/your/rom.gba") // the file path explains :/
+await renderAllBalls(rom, {
+    outputDir: "./Assets/Balls",
+    ballParticles: true, // set to false if you don't want the ball particles :p
+})

package/ball-data/ballData.json

@@ -1,38 +1,156 @@
 {
     "POKE": {
-        "index": 0
+        "index": 0,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 3,
+        "particleFrames": [
+            { "x": 0, "y": 0, "width": 8, "height": 8 },
+            { "x": 0, "y": 8, "width": 8, "height": 8 },
+            { "x": 0, "y": 16, "width": 8, "height": 8 }
+        ]
     },
     "GREAT": {
-        "index": 1
+        "index": 1,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 2,
+        "particleFrames": [
+            { "x": 0, "y": 8, "width": 8, "height": 8 },
+            { "x": 0, "y": 16, "width": 8, "height": 8 }
+        ]
     },
     "SAFARI": {
-        "index": 2
+        "index": 2,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 2,
+        "particleFrames": [
+            { "x": 0, "y": 0, "width": 8, "height": 8 },
+            { "x": 0, "y": 8, "width": 8, "height": 8 }
+        ]
     },
     "ULTRA": {
-        "index": 3
+        "index": 3,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 56, "width": 8, "height": 8 }
+        ]
     },
     "MASTER": {
-        "index": 4
+        "index": 4,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 24, "width": 8, "height": 8 }
+        ]
     },
     "NET": {
-        "index": 5
+        "index": 5,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 32, "width": 8, "height": 8 }
+        ]
     },
     "DIVE": {
-        "index": 6
+        "index": 6,
+        "frameCount": 3,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 },
+            { "x": 0, "y": 32, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 32, "width": 8, "height": 8 }
+        ]
     },
     "NEST": {
-        "index": 7
+        "index": 7,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 40, "width": 8, "height": 8 }
+        ]
     },
     "REPEAT": {
-        "index": 8
+        "index": 8,
+        "frameCount": 2,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 56, "width": 8, "height": 8 }
+        ]
     },
     "TIMER": {
-        "index": 9
+        "index": 9,
+        "frameCount": 3,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 },
+            { "x": 0, "y": 32, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 1,
+        "particleFrames": [
+            { "x": 0, "y": 56, "width": 8, "height": 8 }
+        ]
     },
     "LUXURY": {
-        "index": 10
+        "index": 10,
+        "frameCount": 3,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 },
+            { "x": 0, "y": 32, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 2,
+        "particleFrames": [
+            { "x": 0, "y": 48, "width": 8, "height": 8 },
+            { "x": 0, "y": 56, "width": 8, "height": 8 }
+        ]
     },
     "PREMIER": {
-        "index": 11
+        "index": 11,
+        "frameCount": 3,
+        "frames": [
+            { "x": 0, "y": 0, "width": 16, "height": 16 },
+            { "x": 0, "y": 16, "width": 16, "height": 16 },
+            { "x": 0, "y": 32, "width": 16, "height": 16 }
+        ],
+        "particleFrameCount": 2,
+        "particleFrames": [
+            { "x": 0, "y": 48, "width": 8, "height": 8 },
+            { "x": 0, "y": 56, "width": 8, "height": 8 }
+        ]
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silphscope",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "A firered/leafgreen ROM asset extractor for use in web applications",
   "main": "main.js",
   "exports": {
@@ -26,9 +26,26 @@
     "!src/rom-map-parser.js",
     "!rom-maps/",
     "!graphics-maps/",
-    "ball-data/"
+    "ball-data/",
+    "!src/object-event-data-parser.js"
+  ],
+  "keywords": [
+    "gba",
+    "gameboy-advance",
+    "pokemon",
+    "firered",
+    "pokemon-firered",
+    "leafgreen",
+    "pokemon-leafgreen",
+    "rom",
+    "asset",
+    "asset-extractor",
+    "sprite",
+    "sprite-extractor",
+    "extractor",
+    "gen3",
+    "generation-3"
   ],
-  "keywords": [],
   "author": "chickenPoo",
   "license": "MIT",
   "type": "module",

package/rom-configs/{firered.js → fireredRev0.js}

@@ -3,8 +3,9 @@
 
 // I have an idea but it needs math D:
 
-export const firered = {
+export const fireredRev0 = {
     code: "BPRE", // I find this weird... like what does BP stand for? is it: "Battle Pokemon"? no idea :o
+    rev: 0, // I probably should have mentioned I have been making this tool with a rev0 ROM... but oh well it isn't like people are actually using this tool at least right now so no one has probably run into the "why isn't m firered ROM working!" issue :p
     tables: { // so the idea is essentially instead of a big JSON like we have now we instead just view the table graphics and build from that... it in theory could be slower because more lookups instead of direct references but it should be more maintainable...
         monFrontSprites: 0x2350AC,
         monBackSprites: 0x23654C,
@@ -25,5 +26,7 @@ export const firered = {
         ballParticlePalTable: 0x40BFA8,
         ballAnimPicTable: 0x26056C,
         ballAnimPalTable: 0x2605CC, // any idea what I am doing next?
+        objectEventPicTable: 0x39FDB0,
+        objectEventPalTable: 0x3A5158, // so these tables... technically aren't tables (except for the palette one kinda...) they are actually pointers to objects which then contain children who actually contain another object which finally contains a pointer to the actual graphics... this will be fun... (anyway will work on this eventually...)
     } // if this works out... well hehe... :D
 }

package/rom-configs/fireredRev1.js

@@ -0,0 +1,12 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+// time to see if my goofy ideas payed off lol
+
+export const fireredRev1 = {
+    code: "BPRE",
+    rev: 1,
+    tables: {
+        // will add these later :p
+    }
+}

package/rom-configs/leafgreenRev0.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export const leafgreenRev0 = {
+    code: "BPGE",
+    rev: 0,
+    tables: {
+        // :p
+    }
+}

package/rom-configs/leafgreenRev1.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export const leafgreenRev1 = {
+    code: "BPGE",
+    rev: 1,
+    tables: {
+        // later...
+    }
+}

package/src/get-rom-config.js

@@ -1,14 +1,27 @@
 // Copyright (c) 2026 chickenPoo
 // Licensed under the MIT License. See LICENSE file in project root.
 
-import { firered } from "../rom-configs/firered.js";
+import { fireredRev0 } from "../rom-configs/fireredRev0.js";
+import { fireredRev1 } from "../rom-configs/fireredRev1.js";
+import { leafgreenRev0 } from "../rom-configs/leafgreenRev0.js";
+import { leafgreenRev1 } from "../rom-configs/leafgreenRev1.js";
 
-function detectRomCode(rom) {
-    return new TextDecoder().decode(rom.slice(0xAC, 0xB0));
+function detectRomInfo(rom) {
+    return {
+        code: new TextDecoder().decode(rom.slice(0xAC, 0xB0)),
+        rev: rom[0xBC],
+    }
 }
 
 export function getRomConfig(rom) {
-    const code = detectRomCode(rom);
-    if (code === firered.code) return firered; // eventually will add more and so on :p (by more I mean leafgreen lol)
-    throw new Error(`Unsupported ROM: ${code}`);
+    const romInfo = detectRomInfo(rom);
+    if (romInfo.code === fireredRev0.code || romInfo.code === fireredRev1.code) {
+        if (romInfo.rev === fireredRev0.rev) return fireredRev0;
+        if (romInfo.rev === fireredRev1.rev) return fireredRev1;
+    }
+    if (romInfo.code === leafgreenRev0.code || romInfo.code === leafgreenRev1.code) { // yes I know checking both of the codes is redundant since they are the same but let me enjoy my useless non-DRY code ;)
+        if (romInfo.rev === leafgreenRev0.rev) return leafgreenRev0;
+        if (romInfo.rev === leafgreenRev1.rev) return leafgreenRev1;
+    }
+    throw new Error(`Unsupported ROM: ${romInfo.code} rev ${romInfo.rev}`); // should be evrything I think...
 }

package/src/graphics/balls/render-ball-particle.js

@@ -15,8 +15,29 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     stream.on("error", reject);
 })
 
+const extractFrameFromImage = (imageData, fullWidth, frameData) => {
+    const { x, y, width, height } = frameData;
+    const frameImage = new Uint8ClampedArray(width * height * 4);
+
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            const srcIndex = ((y + row) * fullWidth + (x + col)) * 4;
+            const dstIndex = (row * width + col) * 4;
+            frameImage[dstIndex] = imageData[srcIndex];
+            frameImage[dstIndex + 1] = imageData[srcIndex + 1];
+            frameImage[dstIndex + 2] = imageData[srcIndex + 2];
+            frameImage[dstIndex + 3] = imageData[srcIndex + 3];
+        }
+    }
+
+    return frameImage;
+};
+
 export async function renderBallParticle(ballName, balls, reader, rom, options = {}) {
-    const { outputDir = null } = options;
+    const {
+        outputDir = null,
+        renderMasterBallParticleImage = false,
+    } = options;
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderBallParticle(..., rom) requires a ROM Buffer/Uint8Array");
     }
@@ -51,8 +72,20 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
     if (outputDir) {
         const dir = `${outputDir}/${ballName}`;
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        const fileName = `${dir}/particle.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+        if (renderMasterBallParticleImage) {
+            fs.writeFileSync(`${dir}/master-particle.png`, pngBuffer);
+        }
+        for (let i = 0; i < ball.particleFrames.length; i++) {
+            const frame = ball.particleFrames[i];
+            const frameImageData = extractFrameFromImage(image, width, frame);
+
+            const png = new PNG({ width: frame.width, height: frame.height });
+            png.data = frameImageData;
+            const pngFrameBuffer = await streamToBuffer(png.pack());
+
+            const fileName = `${dir}/particle-${i}.png`;
+            fs.writeFileSync(fileName, pngFrameBuffer);
+        }
     }
 
     return pngBuffer;

package/src/graphics/balls/render-balls.js

@@ -16,10 +16,30 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     stream.on("error", reject);
 })
 
+const extractFrameFromImage = (imageData, fullWidth, frameData) => {
+    const { x, y, width, height } = frameData;
+    const frameImage = new Uint8ClampedArray(width * height * 4);
+
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            const srcIndex = ((y + row) * fullWidth + (x + col)) * 4;
+            const dstIndex = (row * width + col) * 4;
+            frameImage[dstIndex] = imageData[srcIndex];
+            frameImage[dstIndex + 1] = imageData[srcIndex + 1];
+            frameImage[dstIndex + 2] = imageData[srcIndex + 2];
+            frameImage[dstIndex + 3] = imageData[srcIndex + 3];
+        }
+    }
+
+    return frameImage;
+};
+
 export async function renderBall(ballName, balls, reader, rom, options = {}) {
     const {
         outputDir = null,
         ballParticles = false,
+        renderMasterBallImage = false,
+        renderMasterBallParticleImage = false,
     } = options;
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderBall(..., rom) requires a ROM Buffer/Uint8Array");
@@ -30,11 +50,14 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
         throw new Error(`Missing Ball: ${ballName}`);
     }
     if (ballParticles) {
-        renderBallParticle(ballName, balls, reader, rom, { outputDir });
+        renderBallParticle(ballName, balls, reader, rom, {
+            outputDir,
+            renderMasterBallParticleImage, 
+        });
     }
     const ballPal = resolveBallSpritePal(ball, reader, ballName);
     const ballPic = resolveBallSpritePic(ball, reader, ballName);
-    if(!ballPal || !ballPic) {
+    if (!ballPal || !ballPic) {
         throw new Error(`Missing assets for: ${ballName}`);
     }
 
@@ -57,8 +80,20 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
     if (outputDir) {
         const dir = `${outputDir}/${ballName}`;
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        const fileName = `${dir}/ball.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+        if (renderMasterBallImage) {
+            fs.writeFileSync(`${dir}/master-image.png`, pngBuffer)
+        }
+        for (let i = 0; i < ball.frames.length; i++) {
+            const frame = ball.frames[i];
+            const frameImageData = extractFrameFromImage(image, width, frame);
+
+            const png = new PNG({ width: frame.width, height: frame.height });
+            png.data = frameImageData;
+            const pngFrameBuffer = await streamToBuffer(png.pack());
+
+            const fileName = `${dir}/frame-${i}.png`;
+            fs.writeFileSync(fileName, pngFrameBuffer);
+        }
     }
 
     return pngBuffer;

package/src/graphics/graphics-extractor-main.js

@@ -4,6 +4,7 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+import { mapLimit } from "../map-limit.js";
 import { renderMon } from "./mons/render-mons.js";
 import { renderIcon } from "./icons/render-icons.js";
 import { renderTrainer } from "./trainers/render-trainers.js";
@@ -43,6 +44,16 @@ export async function renderAllMons(rom, options = {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
+    await mapLimit(Object.keys(providedMons), 4, async (monName) => { // so in theory we should be running the function 4 times concurrently now...
+        await renderMon(monName, providedMons, reader, rom, {
+            variant: ["normal", "shiny"],
+            icon,
+            footprint,
+            outputDir,
+        });
+        console.log(`Done: ${monName}`);
+    });
+/* just going to leave this here for now in case I decide to make it so that you can toggle between concurrent usage and I suppose synchronous would be the correct term for this down here...
     for (const monName of Object.keys(providedMons)) {
         await renderMon(monName, providedMons, reader, rom, { // hopefully this is faster since we are no longer calling the function 4 times lol
             side: ["front", "back"],
@@ -53,6 +64,7 @@ export async function renderAllMons(rom, options = {}) {
         });
         console.log(`Done: ${monName}`);
     }
+*/
 }
 
 export async function renderAllIcons(rom, options = {}) {
@@ -130,6 +142,8 @@ export async function renderAllBalls(rom, options= {}) {
         balls: providedBalls = balls,
         outputDir = "./out",
         ballParticles = true,
+        renderMasterBallImage = true,
+        renderMasterBallParticleImage = true,
     } = options;
 
     fs.mkdirSync(outputDir, { recursive: true });
@@ -141,6 +155,8 @@ export async function renderAllBalls(rom, options= {}) {
         await renderBall(ballName, providedBalls, reader, rom, { 
             outputDir,
             ballParticles, 
+            renderMasterBallImage,
+            renderMasterBallParticleImage,
         });
         console.log(`Done: ${ballName}`);
     }
@@ -184,6 +200,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
     await renderAllBalls(rom, {
         outputDir: outputBallDir,
         ballParticles: true,
+        renderMasterBallImage: true,
+        renderMasterBallParticleImage: true,
     });
 }
 

package/src/graphics/mons/render-mon-foot.js

@@ -74,9 +74,9 @@ export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true });
         const fileName = `${dir}/footprint.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+        await fs.promises.writeFile(fileName, pngBuffer);
     }
 
     return pngBuffer;

package/src/graphics/mons/render-mon-icon.js

@@ -56,9 +56,9 @@ export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(`${dir}/icon_frame1.png`, buffer1);
-        fs.writeFileSync(`${dir}/icon_frame2.png`, buffer2);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(`${dir}/icon_frame1.png`, buffer1);
+        await fs.promises.writeFile(`${dir}/icon_frame2.png`, buffer2);
     }
 
     return {

package/src/graphics/mons/render-mons.js

@@ -61,6 +61,9 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
     const results = [];
     const width = 64;
     const height = 64;
+    if (outputDir) {
+        await fs.promises.mkdir(dir, { recursive: true }); // why was I using existsSync... eh well "fixed?" now I guess... also I moved this out of the loop as you can see so it only has to run... 440 times now... instead of 4x that number :p
+    }
     for (const side of sides) {
         for (const variant of variants) {
             const image = render4bppImage({
@@ -76,9 +79,8 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
 
             if (outputDir) {
                 const dir = `${outputDir}/${monName}`;
-                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true }); // I suppose it is better to have this out of the loop for performance but erm I would say its fine for now :p
                 const fileName = `${dir}/${side}${variant === "shiny" ? "_shiny" : ""}.png`;
-                fs.writeFileSync(fileName, pngBuffer);
+                await fs.promises.writeFile(fileName, pngBuffer);
             }
 
             results.push(pngBuffer);

package/src/graphics/moves/render-moves.js

@@ -68,6 +68,10 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
         height,
     });
 
+    const png = new PNG({ width, height });
+    png.data = image;
+    const pngBuffer = await streamToBuffer(png.pack());
+
     if (outputDir) { // I will update this later but in theory it should also work... eventually though it will need a split inside to handle full image generation :p
         const rootDir = (sortUnused && move?.unused === true)? `${outputDir}/unused` : `${outputDir}`
         const dir = `${rootDir}/${moveName}`;
@@ -90,4 +94,6 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
             fs.writeFileSync(fileName, pngBuffer);
         }
     }
+
+    return pngBuffer;
 }

package/src/map-limit.js

@@ -0,0 +1,25 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export async function mapLimit(items, limit, mapper) { // I hope this works... in theory it should and it seems quite simple... it's just that I am garbage at async thingies...
+    const results = new Array(items.length);
+    let index = 0;
+
+    async function worker() {
+        while (true) {
+            const current = index++;
+
+            if (index >= items.length) return;
+
+            results[current] = await mapper(items[current], current);
+        }
+    }
+    await Promise.all(
+        Array.from(
+            { length: Math.min(limit, items.length) },
+            worker
+        )
+    );
+
+    return results;
+}