@bloopjs/toodle 0.0.101 → 0.0.103

package/dist/mod.d.ts

@@ -14,4 +14,5 @@ export * as Text from "./text/mod";
 export * as Textures from "./textures/mod";
 export * as Utils from "./utils/mod";
 export { AssetManager } from "./textures/AssetManager";
+export { Bundles } from "./textures/Bundles";
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAEA,mBAAmB,iBAAiB,CAAC;AAErC,mBAAmB,kBAAkB,CAAC;AACtC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,sBAAsB,CAAC;AAC1C,mBAAmB,iBAAiB,CAAC;AAErC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAEA,mBAAmB,iBAAiB,CAAC;AAErC,mBAAmB,kBAAkB,CAAC;AACtC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,sBAAsB,CAAC;AAC1C,mBAAmB,iBAAiB,CAAC;AAErC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AAEzB,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/mod.js

@@ -18088,6 +18088,276 @@ class Pool {
     this.#index = 0;
   }
 }
+// src/textures/Bundles.ts
+class Bundles {
+  #bundles = new Map;
+  #textures = new Map;
+  #atlasSize;
+  constructor(options = {}) {
+    this.#atlasSize = options.atlasSize ?? 4096;
+  }
+  async registerAtlasBundle(bundleId, opts) {
+    const atlases = [];
+    for (const atlas of opts.atlases) {
+      const jsonUrl = atlas.json ?? new URL(atlas.png.toString().replace(".png", ".json"), atlas.png.origin);
+      const pngUrl = atlas.png ?? new URL(atlas.json.toString().replace(".json", ".png"), atlas.json.origin);
+      const atlasDef = await (await fetch(jsonUrl)).json();
+      const bitmap = !opts.rg8 ? await this.#getBitmapFromUrl(pngUrl) : await createImageBitmap(new ImageData(1, 1));
+      let rg8Bytes;
+      if (opts.rg8) {
+        const rg8url = new URL(pngUrl.toString().replace(".png", ".rg8.gz"), pngUrl.origin);
+        rg8Bytes = await this.#fetchRg8Bytes(rg8url);
+      }
+      const cpuTextureAtlas = {
+        texture: bitmap,
+        rg8Bytes,
+        textureRegions: new Map,
+        width: opts.rg8 ? this.#atlasSize : bitmap.width,
+        height: opts.rg8 ? this.#atlasSize : bitmap.height
+      };
+      for (const [assetId, frame] of Object.entries(atlasDef.frames)) {
+        const textureRegion = this.#parsePixiFrame(frame, cpuTextureAtlas.width, cpuTextureAtlas.height);
+        cpuTextureAtlas.textureRegions.set(assetId, textureRegion);
+      }
+      atlases.push(cpuTextureAtlas);
+    }
+    this.#bundles.set(bundleId, {
+      atlases,
+      atlasIndices: [],
+      isLoaded: false
+    });
+    return bundleId;
+  }
+  registerDynamicBundle(bundleId, atlases) {
+    this.#bundles.set(bundleId, {
+      atlases,
+      atlasIndices: [],
+      isLoaded: false
+    });
+  }
+  hasBundle(bundleId) {
+    return this.#bundles.has(bundleId);
+  }
+  isBundleLoaded(bundleId) {
+    const bundle = this.#bundles.get(bundleId);
+    return bundle?.isLoaded ?? false;
+  }
+  getBundleAtlasIndices(bundleId) {
+    const bundle = this.#bundles.get(bundleId);
+    return bundle?.atlasIndices ?? [];
+  }
+  setBundleLoaded(bundleId, atlasIndices) {
+    const bundle = this.#bundles.get(bundleId);
+    if (!bundle) {
+      throw new Error(`Bundle ${bundleId} not found`);
+    }
+    bundle.atlasIndices = atlasIndices;
+    bundle.isLoaded = true;
+  }
+  markBundleLoaded(bundleId, atlasIndices) {
+    const bundle = this.#bundles.get(bundleId);
+    if (!bundle) {
+      throw new Error(`Bundle ${bundleId} not found`);
+    }
+    if (bundle.isLoaded) {
+      console.warn(`Bundle ${bundleId} is already loaded.`);
+      return;
+    }
+    const indices = atlasIndices ?? bundle.atlases.map(() => this.#getNextAtlasIndex());
+    if (indices.length !== bundle.atlases.length) {
+      throw new Error(`Expected ${bundle.atlases.length} atlas indices, got ${indices.length}`);
+    }
+    for (let i3 = 0;i3 < bundle.atlases.length; i3++) {
+      const atlas = bundle.atlases[i3];
+      const atlasIndex = indices[i3];
+      bundle.atlasIndices.push(atlasIndex);
+      for (const [id, region] of atlas.textureRegions) {
+        const coords = { ...region, atlasIndex };
+        const existing = this.#textures.get(id);
+        if (existing) {
+          existing.push(coords);
+        } else {
+          this.#textures.set(id, [coords]);
+        }
+      }
+    }
+    bundle.isLoaded = true;
+  }
+  unloadBundle(bundleId) {
+    const bundle = this.#bundles.get(bundleId);
+    if (!bundle) {
+      throw new Error(`Bundle ${bundleId} not found`);
+    }
+    if (!bundle.isLoaded) {
+      console.warn(`Bundle ${bundleId} is not loaded.`);
+      return;
+    }
+    for (const atlasIndex of bundle.atlasIndices) {
+      for (const [id, coords] of this.#textures.entries()) {
+        const indexToRemove = coords.findIndex((coord) => coord.atlasIndex === atlasIndex);
+        if (indexToRemove !== -1) {
+          coords.splice(indexToRemove, 1);
+        }
+        if (!coords.length) {
+          this.#textures.delete(id);
+        }
+      }
+    }
+    bundle.isLoaded = false;
+    bundle.atlasIndices = [];
+  }
+  get textures() {
+    return this.#textures;
+  }
+  get textureIds() {
+    return Array.from(this.#textures.keys());
+  }
+  getAtlasCoords(id) {
+    const coords = this.#textures.get(id);
+    if (!coords) {
+      throw new Error(`Texture ${id} not found. Have you registered and loaded a bundle containing this texture?`);
+    }
+    return coords;
+  }
+  setAtlasCoords(id, coords) {
+    const oldCoords = this.#textures.get(id);
+    if (!oldCoords)
+      return;
+    const indexToModify = oldCoords.findIndex((coord) => coord.atlasIndex === coords.atlasIndex);
+    if (indexToModify === -1)
+      return;
+    oldCoords[indexToModify] = coords;
+    this.#textures.set(id, oldCoords);
+  }
+  addTextureEntry(id, coords) {
+    const existing = this.#textures.get(id);
+    if (existing) {
+      existing.push(coords);
+    } else {
+      this.#textures.set(id, [coords]);
+    }
+  }
+  removeTextureEntriesForAtlas(atlasIndex) {
+    for (const [id, coords] of this.#textures.entries()) {
+      const indexToRemove = coords.findIndex((coord) => coord.atlasIndex === atlasIndex);
+      if (indexToRemove !== -1) {
+        coords.splice(indexToRemove, 1);
+      }
+      if (!coords.length) {
+        this.#textures.delete(id);
+      }
+    }
+  }
+  getTextureRegion(id) {
+    const coords = this.#textures.get(id);
+    if (!coords || coords.length === 0)
+      return;
+    const { atlasIndex: _3, ...region } = coords[0];
+    return region;
+  }
+  getTextureOffset(id) {
+    const coords = this.#textures.get(id);
+    if (!coords) {
+      throw new Error(`Texture ${id} not found. Have you registered and loaded a bundle containing this texture?`);
+    }
+    return coords[0].cropOffset;
+  }
+  getSize(id) {
+    const coords = this.getAtlasCoords(id);
+    const uvScale = coords[0].uvScale;
+    return {
+      width: uvScale.width * this.#atlasSize,
+      height: uvScale.height * this.#atlasSize
+    };
+  }
+  getCroppedSize(id) {
+    const coords = this.getAtlasCoords(id);
+    const uvScaleCropped = coords[0].uvScaleCropped;
+    if (uvScaleCropped) {
+      return {
+        width: uvScaleCropped.width * this.#atlasSize,
+        height: uvScaleCropped.height * this.#atlasSize
+      };
+    }
+    return this.getSize(id);
+  }
+  hasTexture(id) {
+    return this.#textures.has(id);
+  }
+  getRegisteredBundleIds() {
+    return Array.from(this.#bundles.keys());
+  }
+  getLoadedBundleIds() {
+    return Array.from(this.#bundles.entries()).filter(([, bundle]) => bundle.isLoaded).map(([id]) => id);
+  }
+  getBundleAtlases(bundleId) {
+    const bundle = this.#bundles.get(bundleId);
+    if (!bundle) {
+      throw new Error(`Bundle ${bundleId} not found`);
+    }
+    return bundle.atlases;
+  }
+  get atlasSize() {
+    return this.#atlasSize;
+  }
+  #parsePixiFrame(frame, atlasWidth, atlasHeight) {
+    const leftCrop = frame.spriteSourceSize.x;
+    const rightCrop = frame.sourceSize.w - frame.spriteSourceSize.x - frame.spriteSourceSize.w;
+    const topCrop = frame.spriteSourceSize.y;
+    const bottomCrop = frame.sourceSize.h - frame.spriteSourceSize.y - frame.spriteSourceSize.h;
+    return {
+      cropOffset: {
+        x: leftCrop - rightCrop,
+        y: bottomCrop - topCrop
+      },
+      originalSize: {
+        width: frame.sourceSize.w,
+        height: frame.sourceSize.h
+      },
+      uvOffset: {
+        x: frame.frame.x / atlasWidth,
+        y: frame.frame.y / atlasHeight
+      },
+      uvScale: {
+        width: frame.sourceSize.w / atlasWidth,
+        height: frame.sourceSize.h / atlasHeight
+      },
+      uvScaleCropped: {
+        width: frame.frame.w / atlasWidth,
+        height: frame.frame.h / atlasHeight
+      }
+    };
+  }
+  async#getBitmapFromUrl(url) {
+    const response = await fetch(url);
+    const blob = await response.blob();
+    return createImageBitmap(blob);
+  }
+  async#fetchRg8Bytes(url) {
+    const response = await fetch(url);
+    const enc = (response.headers.get("content-encoding") || "").toLowerCase();
+    if (enc.includes("gzip") || enc.includes("br") || enc.includes("deflate")) {
+      return new Uint8Array(await response.arrayBuffer());
+    }
+    if (!response.body) {
+      throw new Error("Response body of rg8 file is null");
+    }
+    const ds = new DecompressionStream("gzip");
+    const ab = await new Response(response.body.pipeThrough(ds)).arrayBuffer();
+    return new Uint8Array(ab);
+  }
+  #getNextAtlasIndex() {
+    let maxIndex = -1;
+    for (const bundle of this.#bundles.values()) {
+      for (const idx of bundle.atlasIndices) {
+        if (idx > maxIndex)
+          maxIndex = idx;
+      }
+    }
+    return maxIndex + 1;
+  }
+}
+
 // src/textures/pixel-scraping.wgsl.ts
 var pixel_scraping_wgsl_default = `
 // ==============================
@@ -18650,18 +18920,19 @@ async function textureToBitmap(device, texture, width, height) {
 // src/textures/AssetManager.ts
 class AssetManager {
   textureAtlas;
+  bundles;
   #device;
   #presentationFormat;
-  #bundles = new Map;
-  #textures = new Map;
   #fonts = new Map;
   #cropComputeShader;
   #limits;
   #availableIndices = new Set;
-  constructor(device, presentationFormat, limits, format = "rgba8unorm") {
+  constructor(device, presentationFormat, limits, options = {}) {
     this.#device = device;
     this.#presentationFormat = presentationFormat;
     this.#limits = limits;
+    this.bundles = options.bundles ?? new Bundles({ atlasSize: limits.textureSize });
+    const format = options.format ?? "rgba8unorm";
     this.textureAtlas = device.createTexture({
       label: "Asset Manager Atlas Texture",
       size: [
@@ -18694,16 +18965,16 @@ class AssetManager {
     return this.getSize(id);
   }
   isCropped(id) {
-    if (!this.#textures.has(id)) {
+    if (!this.bundles.hasTexture(id)) {
       throw new Error(`Texture ${id} not found in atlas. Have you called toodle.loadTextures with this id or toodle.loadBundle with a bundle that contains it?`);
     }
-    return this.#textures.get(id)[0].uvScaleCropped === undefined;
+    return this.bundles.getAtlasCoords(id)[0].uvScaleCropped === undefined;
   }
   get textures() {
-    return this.#textures;
+    return this.bundles.textures;
   }
   get textureIds() {
-    return Array.from(this.#textures.keys());
+    return this.bundles.textureIds;
   }
   async loadTextures(opts) {
     await Promise.all(Object.entries(opts).map(([id, url]) => this.loadTexture(id, url, opts)));
@@ -18730,7 +19001,7 @@ class AssetManager {
       },
       atlasIndex
     };
-    this.#textures.set(id, [coords]);
+    this.bundles.addTextureEntry(id, coords);
     this.#availableIndices.delete(atlasIndex);
     textureWrapper.texture.destroy();
     return { id, coords };
@@ -18747,32 +19018,32 @@ class AssetManager {
     return bundleId;
   }
   async loadBundle(bundleId) {
-    const bundle = this.#bundles.get(bundleId);
-    if (!bundle) {
+    if (!this.bundles.hasBundle(bundleId)) {
       throw new Error(`Bundle ${bundleId} not found`);
     }
-    if (bundle.isLoaded) {
+    if (this.bundles.isBundleLoaded(bundleId)) {
       console.warn(`Bundle ${bundleId} is already loaded.`);
       return;
     }
-    for (const atlas of bundle.atlases) {
+    const atlases = this.bundles.getBundleAtlases(bundleId);
+    const atlasIndices = [];
+    for (const atlas of atlases) {
       const atlasIndex = await this.extra.loadAtlas(atlas);
-      bundle.atlasIndices.push(atlasIndex);
+      atlasIndices.push(atlasIndex);
     }
-    bundle.isLoaded = true;
+    this.bundles.setBundleLoaded(bundleId, atlasIndices);
   }
   async unloadBundle(bundleId) {
-    const bundle = this.#bundles.get(bundleId);
-    if (!bundle) {
+    if (!this.bundles.hasBundle(bundleId)) {
       throw new Error(`Bundle ${bundleId} not found`);
     }
-    if (!bundle.isLoaded) {
+    if (!this.bundles.isBundleLoaded(bundleId)) {
       console.warn(`Bundle ${bundleId} is not loaded.`);
       return;
     }
-    await Promise.all(bundle.atlasIndices.map((atlasIndex) => this.extra.unloadAtlas(atlasIndex)));
-    bundle.isLoaded = false;
-    bundle.atlasIndices = [];
+    const atlasIndices = this.bundles.getBundleAtlasIndices(bundleId);
+    await Promise.all(atlasIndices.map((atlasIndex) => this.extra.unloadAtlas(atlasIndex)));
+    this.bundles.unloadBundle(bundleId);
   }
   async loadFont(id, url, fallbackCharacter = "_") {
     const font = await MsdfFont.create(id, url);
@@ -18791,22 +19062,14 @@ class AssetManager {
   validateTextureReference(node) {
     if (!(node instanceof QuadNode) || node.isPrimitive || node instanceof JumboQuadNode)
       return;
-    const coords = this.#textures.get(node.textureId);
-    if (!coords || !coords.length) {
+    if (!this.bundles.hasTexture(node.textureId)) {
       throw new Error(`Node ${node.id} references an invalid texture ${node.textureId}.`);
     }
+    const coords = this.bundles.getAtlasCoords(node.textureId);
     if (coords.find((coord) => coord.atlasIndex === node.atlasCoords.atlasIndex))
       return;
     node.extra.setAtlasCoords(coords[0]);
   }
-  #addTexture(id, textureRegion, atlasIndex) {
-    this.#textures.set(id, [
-      {
-        ...textureRegion,
-        atlasIndex
-      }
-    ]);
-  }
   #createTextureFromImageBitmap(bitmap, name) {
     const texture = this.#device.createTexture({
       label: `${name} Intermediary Texture`,
@@ -18835,106 +19098,26 @@ class AssetManager {
       images.set(id, textureWrapper);
     }));
     const atlases = await packBitmapsToAtlas(images, this.#limits.textureSize, this.#device);
-    this.#bundles.set(bundleId, {
-      atlases,
-      atlasIndices: [],
-      isLoaded: false
-    });
+    this.bundles.registerDynamicBundle(bundleId, atlases);
   }
   async#registerBundleFromAtlases(bundleId, opts) {
-    const atlases = [];
-    for (const atlas of opts.atlases) {
-      const jsonUrl = atlas.json ?? new URL(atlas.png.toString().replace(".png", ".json"), atlas.png.origin);
-      const pngUrl = atlas.png ?? new URL(atlas.json.toString().replace(".json", ".png"), atlas.json.origin);
-      const atlasDef = await (await fetch(jsonUrl)).json();
-      const bitmap = !opts.rg8 ? await getBitmapFromUrl(pngUrl) : await createImageBitmap(new ImageData(1, 1));
-      let rg8Bytes;
-      if (opts.rg8) {
-        const rg8url = new URL(pngUrl.toString().replace(".png", ".rg8.gz"), pngUrl.origin);
-        const rgBytes = await fetch(rg8url).then(async (r3) => {
-          const enc = (r3.headers.get("content-encoding") || "").toLowerCase();
-          if (enc.includes("gzip") || enc.includes("br") || enc.includes("deflate")) {
-            return new Uint8Array(await r3.arrayBuffer());
-          }
-          assert(r3.body, "Response body of rg8 file is null");
-          const ds = new DecompressionStream("gzip");
-          const ab = await new Response(r3.body.pipeThrough(ds)).arrayBuffer();
-          return new Uint8Array(ab);
-        });
-        rg8Bytes = rgBytes;
-      }
-      const cpuTextureAtlas = {
-        texture: bitmap,
-        rg8Bytes,
-        textureRegions: new Map,
-        width: opts.rg8 ? this.#limits.textureSize : bitmap.width,
-        height: opts.rg8 ? this.#limits.textureSize : bitmap.height
-      };
-      for (const [assetId, frame] of Object.entries(atlasDef.frames)) {
-        const leftCrop = frame.spriteSourceSize.x;
-        const rightCrop = frame.sourceSize.w - frame.spriteSourceSize.x - frame.spriteSourceSize.w;
-        const topCrop = frame.spriteSourceSize.y;
-        const bottomCrop = frame.sourceSize.h - frame.spriteSourceSize.y - frame.spriteSourceSize.h;
-        cpuTextureAtlas.textureRegions.set(assetId, {
-          cropOffset: {
-            x: leftCrop - rightCrop,
-            y: bottomCrop - topCrop
-          },
-          originalSize: {
-            width: frame.sourceSize.w,
-            height: frame.sourceSize.h
-          },
-          uvOffset: {
-            x: frame.frame.x / cpuTextureAtlas.width,
-            y: frame.frame.y / cpuTextureAtlas.height
-          },
-          uvScale: {
-            width: frame.sourceSize.w / cpuTextureAtlas.width,
-            height: frame.sourceSize.h / cpuTextureAtlas.height
-          },
-          uvScaleCropped: {
-            width: frame.frame.w / cpuTextureAtlas.width,
-            height: frame.frame.h / cpuTextureAtlas.height
-          }
-        });
-      }
-      atlases.push(cpuTextureAtlas);
-    }
-    this.#bundles.set(bundleId, {
-      atlases,
-      atlasIndices: [],
-      isLoaded: false
-    });
+    await this.bundles.registerAtlasBundle(bundleId, opts);
   }
   extra = {
     getRegisteredBundleIds: () => {
-      return this.#bundles ? Array.from(this.#bundles.keys()) : [];
+      return this.bundles.getRegisteredBundleIds();
     },
     getLoadedBundleIds: () => {
-      return Array.from(this.#bundles.entries()).filter(([, value]) => value.isLoaded).map(([key]) => key);
+      return this.bundles.getLoadedBundleIds();
     },
     setAtlasCoords: (id, coords) => {
-      const oldCoords = this.#textures.get(id);
-      if (!oldCoords)
-        return;
-      const indexToModify = oldCoords.findIndex((coord) => coord.atlasIndex === coords.atlasIndex);
-      if (indexToModify === -1)
-        return;
-      oldCoords[indexToModify] = coords;
-      this.#textures.set(id, oldCoords);
+      this.bundles.setAtlasCoords(id, coords);
     },
     getAtlasCoords: (id) => {
-      if (!this.#textures.has(id)) {
-        throw new Error(`Texture ${id} not found in atlas. Have you called toodle.loadBundle with a bundle that contains this id (or toodle.loadTextures with this id as a key)?`);
-      }
-      return this.#textures.get(id) ?? [];
+      return this.bundles.getAtlasCoords(id);
     },
     getTextureOffset: (id) => {
-      const texture = this.#textures.get(id);
-      if (!texture) {
-        throw new Error(`Texture ${id} not found in atlas. Have you called toodle.loadTextures with this id or toodle.loadBundle with a bundle that contains it?`);
-      }
-      return texture[0].cropOffset;
+      return this.bundles.getTextureOffset(id);
     },
     getAtlasUsage: () => {
       return {
@@ -18971,25 +19154,13 @@ class AssetManager {
         }, [atlas.texture.width, atlas.texture.height, 1]);
       }
       for (const [id, region] of atlas.textureRegions) {
-        const existing = this.#textures.get(id);
-        if (existing) {
-          existing.push({ ...region, atlasIndex });
-        } else
-          this.#addTexture(id, region, atlasIndex);
+        this.bundles.addTextureEntry(id, { ...region, atlasIndex });
       }
       return atlasIndex;
     },
     unloadAtlas: async (atlasIndex) => {
       this.#availableIndices.add(atlasIndex);
-      for (const [id, coords] of this.#textures.entries()) {
-        const indexToModify = coords.findIndex((coord) => coord.atlasIndex === atlasIndex);
-        if (indexToModify !== -1) {
-          coords.splice(indexToModify, 1);
-        }
-        if (!coords.length) {
-          this.#textures.delete(id);
-        }
-      }
+      this.bundles.removeTextureEntriesForAtlas(atlasIndex);
     }
   };
   #wrapBitmapToTexture(bitmap, name = "Unknown") {
@@ -19647,6 +19818,9 @@ __export(exports_mod7, {
 });
 // src/textures/mod.ts
 var exports_mod8 = {};
+__export(exports_mod8, {
+  Bundles: () => Bundles
+});
 export {
   exports_mod as Utils,
   Toodle,
@@ -19658,8 +19832,9 @@ export {
   exports_mod3 as GfxMath,
   DEFAULT_LIMITS,
   exports_mod2 as Colors,
+  Bundles,
   AssetManager
 };
 
-//# debugId=E4D2A9C0603A997464756E2164756E21
+//# debugId=9F2329B11FF4504E64756E2164756E21
 //# sourceMappingURL=mod.js.map