melonjs 20.7.0 → 20.9.0

package/build/level/tiled/renderer/TMXIsometricRenderer.d.ts

@@ -1,3 +1,7 @@
+/**
+ * additional import for TypeScript
+ * @import TMXTileMap from "../TMXTileMap.js";
+ */
 /**
  * an Isometric Map Renderer
  * @category Tilemap
@@ -12,4 +16,5 @@ export default class TMXIsometricRenderer extends TMXRenderer {
     originX: number;
 }
 import TMXRenderer from "./TMXRenderer.js";
+import type TMXTileMap from "../TMXTileMap.js";
 //# sourceMappingURL=TMXIsometricRenderer.d.ts.map

package/build/level/tiled/renderer/TMXIsometricRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXIsometricRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXIsometricRenderer.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAQpB;IAHA,mBAAoC;IACpC,oBAAsC;IACtC,gBAA0C;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,0DASC;IAED;;;;OAIG;IACH,+CAMC;IAED;;;;OAIG;IACH,+CAMC;IAED;;;;;OAKG;IACH,+BAWC;IAED;;;;OAIG;IACH,4DASC;IAED;;;;;OAKG;IACH,wFAQC;IAED;;;;OAIG;IACH,0DA8HC;CACD;wBA5PuB,kBAAkB"}
+{"version":3,"file":"TMXIsometricRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXIsometricRenderer.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAQpB;IAHA,mBAAoC;IACpC,oBAAsC;IACtC,gBAA0C;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,0DASC;IAED;;;;OAIG;IACH,+CAMC;IAED;;;;OAIG;IACH,+CAMC;IAED;;;;;OAKG;IACH,+BAWC;IAED;;;;OAIG;IACH,4DASC;IAED;;;;;OAKG;IACH,wFAQC;IAED;;;;OAIG;IACH,0DA8HC;CACD;wBAhQuB,kBAAkB;4BAIf,kBAAkB"}

package/build/level/tiled/renderer/TMXObliqueRenderer.d.ts

@@ -1,3 +1,8 @@
+/**
+ * additional import for TypeScript
+ * @import {Bounds} from "../../../physics/bounds.ts";
+ * @import TMXTileMap from "../TMXTileMap.js";
+ */
 /**
  * an Oblique Map Renderer (Tiled 1.12+)
  * Extends the orthogonal renderer with a 2D shear transform
@@ -25,13 +30,6 @@ export default class TMXObliqueRenderer extends TMXOrthogonalRenderer {
      * @type {number}
      */
     shearY: number;
-    /**
-     * return the bounding rect for this map renderer
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer
-     * @returns {Bounds}
-     */
-    getBounds(layer?: TMXLayer): Bounds;
 }
 import TMXOrthogonalRenderer from "./TMXOrthogonalRenderer.js";
-import TMXLayer from "./../TMXLayer.js";
 //# sourceMappingURL=TMXObliqueRenderer.d.ts.map

package/build/level/tiled/renderer/TMXObliqueRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXObliqueRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXObliqueRenderer.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IAOE;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEsD;IAEtE;;;OAGG;IACH,QAFU,MAAM,CAEoD;IAEpE;;;;;OAKG;IACH,MAJU,MAAM,CAIyB;IAgB1C;;;;OAIG;IACH,kBAHW,QAAQ,GACN,MAAM,CAqBlB;CAqKD;kCA1PiC,4BAA4B;qBADzC,kBAAkB"}
+{"version":3,"file":"TMXObliqueRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXObliqueRenderer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;;;;;GAKG;AACH;IAOE;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEsD;IAEtE;;;OAGG;IACH,QAFU,MAAM,CAEoD;IAEpE;;;;;OAKG;IACH,MAJU,MAAM,CAIyB;CA6M1C;kCA/PiC,4BAA4B"}

package/build/level/tiled/renderer/TMXOrthogonalRenderer.d.ts

@@ -1,3 +1,7 @@
+/**
+ * additional import for TypeScript
+ * @import TMXTileMap from "../TMXTileMap.js";
+ */
 /**
  * an Orthogonal Map Renderer
  * @category Tilemap
@@ -9,4 +13,5 @@ export default class TMXOrthogonalRenderer extends TMXRenderer {
     constructor(map: TMXTileMap);
 }
 import TMXRenderer from "./TMXRenderer.js";
+import type TMXTileMap from "../TMXTileMap.js";
 //# sourceMappingURL=TMXOrthogonalRenderer.d.ts.map

package/build/level/tiled/renderer/TMXOrthogonalRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXOrthogonalRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXOrthogonalRenderer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAIpB;IAED;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,+CAGC;IAED;;;;OAIG;IACH,+CAGC;IAED;;;;OAIG;IACH,4DASC;IAED;;;;;OAKG;IACH,wFAQC;IAED;;;;OAIG;IACH,0DA6EC;CACD;wBA9JuB,kBAAkB"}
+{"version":3,"file":"TMXOrthogonalRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXOrthogonalRenderer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAIpB;IAED;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,+CAGC;IAED;;;;OAIG;IACH,+CAGC;IAED;;;;OAIG;IACH,4DASC;IAED;;;;;OAKG;IACH,wFAQC;IAED;;;;OAIG;IACH,0DA6EC;CACD;wBAlKuB,kBAAkB;4BAIf,kBAAkB"}

package/build/level/tiled/renderer/TMXRenderer.d.ts

@@ -1,3 +1,13 @@
+/**
+ * additional import for TypeScript
+ * @import CanvasRenderer from "../../../video/canvas/canvas_renderer.js";
+ * @import {Rect} from "../../../geometries/rectangle.ts";
+ * @import TMXTileMap from "../TMXTileMap.js";
+ * @import Tile from "../TMXTile.js";
+ * @import {Vector2d} from "../../../math/vector2d.ts";
+ * @import WebGLRenderer from "../../../video/webgl/webgl_renderer.js";
+ * @import Renderer from "../../../video/renderer.js";
+ */
 /**
  * The map renderer base class
  * @category Tilemap
@@ -51,20 +61,25 @@ export default class TMXRenderer {
     adjustPosition(obj: object): void;
     /**
      * draw the given tile at the specified layer
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {Renderer} renderer - a renderer object
      * @param {number} x - X coordinate where to draw the tile
      * @param {number} y - Y coordinate where to draw the tile
      * @param {Tile} tile - the tile object to draw
      */
-    drawTile(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, tile: Tile): void;
+    drawTile(renderer: Renderer, x: number, y: number, tile: Tile): void;
     /**
      * draw the given TMX Layer for the given area
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {Renderer} renderer - a renderer object
      * @param {TMXLayer} layer - a TMX Layer object
      * @param {Rect} rect - the area of the layer to draw
      */
-    drawTileLayer(renderer: CanvasRenderer | WebGLRenderer, layer: TMXLayer, rect: Rect): void;
+    drawTileLayer(renderer: Renderer, layer: TMXLayer, rect: Rect): void;
 }
 import { Bounds } from "./../../../physics/bounds.ts";
+import type TMXTileMap from "../TMXTileMap.js";
 import TMXLayer from "./../TMXLayer.js";
+import type { Vector2d } from "../../../math/vector2d.ts";
+import type Renderer from "../../../video/renderer.js";
+import type Tile from "../TMXTile.js";
+import type { Rect } from "../../../geometries/rectangle.ts";
 //# sourceMappingURL=TMXRenderer.d.ts.map

package/build/level/tiled/renderer/TMXRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXRenderer.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACC;;;;;OAKG;IACH,kBALW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,EAQhB;IALA,aAAgB;IAChB,aAAgB;IAChB,kBAA0B;IAC1B,mBAA4B;IAC5B,eAA0B;IAG3B;;;;OAIG;IACH,qBAHW,UAAU,GAAC,QAAQ,GACjB,OAAO,CAanB;IAED;;;;OAIG;IACH,kBAHW,QAAQ,GACN,MAAM,CAWlB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,KACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAIpB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,OACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAIpB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAShB;IAED;;;;;;OAMG;IAEH,mBANW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,QACN,IAAI,QAGkB;IAEjC;;;;;OAKG;IAEH,wBALW,cAAc,GAAC,aAAa,SAC5B,QAAQ,QACR,IAAI,QAGwB;CACvC;uBA9GkC,8BAA8B;qBAC5C,kBAAkB"}
+{"version":3,"file":"TMXRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXRenderer.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;;;GAGG;AACH;IACC;;;;;OAKG;IACH,kBALW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,EAQhB;IALA,aAAgB;IAChB,aAAgB;IAChB,kBAA0B;IAC1B,mBAA4B;IAC5B,eAA0B;IAG3B;;;;OAIG;IACH,qBAHW,UAAU,GAAC,QAAQ,GACjB,OAAO,CAanB;IAED;;;;OAIG;IACH,kBAHW,QAAQ,GACN,MAAM,CAWlB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,KACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAIpB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,OACN,MAAM,MACN,QAAQ,GACN,QAAQ,CAIpB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAShB;IAED;;;;;;OAMG;IAEH,mBANW,QAAQ,KACR,MAAM,KACN,MAAM,QACN,IAAI,QAGkB;IAEjC;;;;;OAKG;IAEH,wBALW,QAAQ,SACR,QAAQ,QACR,IAAI,QAGwB;CACvC;uBAxHkC,8BAA8B;4BAOtC,kBAAkB;qBANxB,kBAAkB;8BAQZ,2BAA2B;0BAE7B,4BAA4B;sBAHhC,eAAe;0BAFb,kCAAkC"}

package/build/level/tiled/renderer/autodetect.d.ts

@@ -1,6 +1,2 @@
 
-import TMXHexagonalRenderer from "./TMXHexagonalRenderer.js";
-import TMXIsometricRenderer from "./TMXIsometricRenderer.js";
-import TMXOrthogonalRenderer from "./TMXOrthogonalRenderer.js";
-import TMXObliqueRenderer from "./TMXObliqueRenderer.js";
 //# sourceMappingURL=autodetect.d.ts.map

package/build/level/tiled/renderer/autodetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/autodetect.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,uCAJW,UAAU,4FAyBpB;iCAjCgC,2BAA2B;iCAC3B,2BAA2B;kCAE1B,4BAA4B;+BAD/B,yBAAyB"}
+{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/autodetect.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,uCAJW,UAAU,uEAyBpB;iCAjCgC,2BAA2B;iCAC3B,2BAA2B;kCAE1B,4BAA4B"}

package/build/loader/cache.d.ts

@@ -1,3 +1,219 @@
+
+/**
+ * return the specified TMX/TSX object
+ * @param {string} elt - name of the tmx/tsx element ("map1");
+ * @returns {object} requested element or null if not found
+ * @category Assets
+ */
+export function getTMX(elt: string): object;
+/**
+ * return the specified Binary object
+ * @param {string} elt - name of the binary object ("ymTrack");
+ * @returns {object} requested element or null if not found
+ * @category Assets
+ */
+export function getBinary(elt: string): object;
+/**
+ * return the specified Image Object
+ * @param {string} image - name of the Image element ("tileset-platformer");
+ * @returns {HTMLImageElement|CompressedImage|null} requested element or null if not found
+ * @category Assets
+ */
+export function getImage(image: string): HTMLImageElement | CompressedImage | null;
+/**
+ * return the specified JSON Object
+ * @param {string} elt - name of the json file
+ * @returns {JSON}
+ * @category Assets
+ */
+export function getJSON(elt: string): JSON;
+/**
+ * return the specified OBJ model data
+ * @param {string} elt - name of the OBJ file (as specified in the preload list)
+ * @returns {object} parsed OBJ data with `vertices` (Float32Array), `uvs` (Float32Array), `indices` (Uint16Array), and `vertexCount` (number), or null if not found
+ * @category Assets
+ * @example
+ * // 1. preload the OBJ model and its texture
+ * me.loader.preload([
+ *     { name: "cube", type: "obj", src: "models/cube.obj" },
+ *     { name: "cube", type: "image", src: "models/cube_texture.png" },
+ * ], () => {
+ *     // 2. create a Mesh using the preloaded model name
+ *     const mesh = new me.Mesh(400, 300, {
+ *         model: "cube",        // references the preloaded OBJ
+ *         texture: "cube",      // references the preloaded image
+ *         width: 200,
+ *         height: 200,
+ *     });
+ *     me.game.world.addChild(mesh);
+ *
+ *     // 3. or access the raw parsed data directly
+ *     const data = me.loader.getOBJ("cube");
+ *     // data.vertices — Float32Array of x,y,z positions
+ *     // data.uvs — Float32Array of u,v texture coordinates
+ *     // data.indices — Uint16Array of triangle vertex indices
+ *     // data.vertexCount — number of unique vertices
+ *     // data.groups — usemtl material groups ({materialName, start, count} index ranges)
+ * });
+ */
+export function getOBJ(elt: string): object;
+/**
+ * return the parsed glTF/GLB scene descriptor for the given asset name.
+ *
+ * The descriptor is `{ nodes, cameras, lights, bounds, graph, animations }`:
+ * - `nodes` — one entry per mesh primitive, each carrying its accumulated
+ *   `world` transform (16 floats, column-major), `vertices`, `normals`,
+ *   `uvs`, `indices`, `vertexCount`, a decoded baseColor `image` (or `null`),
+ *   and a `doubleSided` flag.
+ * - `cameras` — glTF cameras, each with its `world` transform + perspective
+ *   parameters.
+ * - `lights` — parsed `KHR_lights_punctual` lights (`type`, `color`,
+ *   `intensity`, `range`, spot cone angles, world-space
+ *   `direction`/`position`, `name`); empty without the extension. The
+ *   level director instantiates directional, point and spot lights
+ *   automatically (see {@link level.load} options).
+ * - `bounds` — world-space `{ min, max }` (glTF units), handy for framing.
+ *
+ * Most code never needs this: a preloaded glTF/GLB auto-registers with the
+ * {@link level} director, so the whole scene loads into a container in one
+ * call via `me.level.load(name)` — exactly like a Tiled map. Reach for
+ * `getGLTF` only when you want to inspect the raw descriptor (e.g. to frame
+ * a `Camera3d` from the embedded camera).
+ * @param {string} elt - name of the glTF/GLB file (as specified in the preload list)
+ * @returns {GLTFData|null} the parsed scene descriptor, or `null` if not found
+ * @category Assets
+ * @example
+ * me.loader.preload(
+ *     [{ name: "diorama", type: "glb", src: "scenes/diorama.glb" }],
+ *     () => {
+ *         // load the whole scene into the world (view under a Camera3d)
+ *         me.level.load("diorama", { scale: 32 });
+ *
+ *         // ...or inspect the raw descriptor for custom framing
+ *         const scene = me.loader.getGLTF("diorama");
+ *         const { min, max } = scene.bounds;
+ *     },
+ * );
+ */
+export function getGLTF(elt: string): GLTFData | null;
+/**
+ * Return the precompiled `ShaderEffect` for the given "shader" asset —
+ * compiled once during preloading, ready to assign to a renderable or
+ * camera `shader` property.
+ *
+ * **This returns a SHARED instance**: the *same* `ShaderEffect` object on
+ * every call, owned by the loader (its `shared` flag is `true`). That means:
+ * - it is safe to assign to any number of renderables — none of their
+ *   cleanup paths will auto-destroy it, only {@link loader.unload} /
+ *   {@link loader.unloadAll} free it (and its GL program);
+ * - all of them share ONE set of uniform values — `setUniform` on it
+ *   affects every renderable using the shader.
+ *
+ * When a renderable needs its **own** uniform values, make a private,
+ * caller-owned copy with `ShaderEffect.clone()` — the clone's `shared` flag
+ * is reset to `false`, so it is auto-destroyed with the renderable it is
+ * assigned to, like any hand-constructed effect.
+ *
+ * A shader asset declared as a **complete program** — a
+ * `{vertex, fragment}` GLSL pair and/or a full `wgsl` module (see the
+ * example) — compiles into a raw {@link GLShader} instead, carrying one
+ * realization per GPU backend (`isWebGL` / `isWebGPU`): the type the
+ * hosted paths take directly (a `Mesh` custom shader,
+ * `renderer.customShader`, a custom batcher). Same shared-instance
+ * semantics, and `GLShader.clone()` likewise yields a caller-owned copy.
+ *
+ * Degradation is never fatal: a fragment-body asset without a body in the
+ * active renderer's language (or on Canvas) is an inert `ShaderEffect`
+ * stub, and a complete-program asset without a realization for the active
+ * backend is an inert `GLShader` — assigning either just keeps the
+ * built-in rendering. Note that shader assets require an initialized
+ * Application (`await app.init()`) — an inherent precondition of the
+ * preload flow, since the loading screen itself needs the renderer.
+ * @param {string} elt - name of the shader asset (as specified in the preload list)
+ * @returns {ShaderEffect|GLShader|null} the shared, precompiled shader, or `null` if not found
+ * @category Assets
+ * @example
+ * me.loader.preload([
+ *     // from a file (or data: URI)
+ *     { name: "waterRipple", type: "shader", src: "shaders/waterRipple.frag" },
+ *     // or inline GLSL via the `data` field
+ *     { name: "flash", type: "shader", data: `
+ *         uniform float uIntensity;
+ *         vec4 apply(vec4 color, vec2 uv) { return mix(color, vec4(1.0), uIntensity); }
+ *     ` },
+ *     // or a complete program — a {vertex, fragment} GLSL pair and/or a
+ *     // full WGSL module → one GLShader carrying both realizations; the
+ *     // active renderer hosts the one it speaks
+ *     { name: "toonMesh", type: "shader", src: {
+ *         vertex: "shaders/toon.vert",
+ *         fragment: "shaders/toon.frag",
+ *         wgsl: "shaders/toon.wgsl",
+ *     } },
+ * ], () => {
+ *     // one shared program — same uniform state for every user
+ *     mySprite.addPostEffect(me.loader.getShader("waterRipple"));
+ *     // private copy with its own uniforms (caller-owned, shared = false)
+ *     boss.addPostEffect(me.loader.getShader("flash").clone());
+ *     // a complete program hosts on a mesh, replacing the built-in shading
+ *     myMesh.addPostEffect(me.loader.getShader("toonMesh"));
+ * });
+ */
+export function getShader(elt: string): ShaderEffect | GLShader | null;
+/**
+ * return the specified MTL material data
+ * @param {string} elt - name of the MTL file (as specified in the preload list)
+ * @returns {object} map of material names to properties (`Kd`, `d`, `map_Kd`), or null if not found
+ * @category Assets
+ * @example
+ * // 1. preload OBJ + MTL + texture
+ * me.loader.preload([
+ *     { name: "fox", type: "obj", src: "models/fox.obj" },
+ *     { name: "fox", type: "mtl", src: "models/fox.mtl" },
+ *     { name: "colormap", type: "image", src: "models/colormap.png" },
+ * ], () => {
+ *     // 2. create a Mesh with material — texture, tint, opacity auto-applied
+ *     const mesh = new me.Mesh(400, 300, {
+ *         model: "fox",
+ *         material: "fox",
+ *         texture: "colormap",
+ *         width: 200,
+ *         height: 200,
+ *     });
+ *
+ *     // 3. or access the raw material data directly
+ *     const materials = me.loader.getMTL("fox");
+ *     // materials["colormap"].Kd — [r, g, b] diffuse color (0-1 range)
+ *     // materials["colormap"].d — opacity (0-1)
+ *     // materials["colormap"].Ke — [r, g, b] emissive color (glow, applied as Mesh.emissive)
+ *     // materials["colormap"].map_Kd — resolved texture URL
+ * });
+ */
+export function getMTL(elt: string): object;
+/**
+ * return the specified Video Object
+ * @param {string} elt - name of the video file
+ * @returns {HTMLVideoElement}
+ * @category Assets
+ */
+export function getVideo(elt: string): HTMLVideoElement;
+/**
+ * return the specified FontFace Object
+ * @param {string} elt - name of the font file
+ * @returns {FontFace}
+ * @category Assets
+ */
+export function getFont(elt: string): FontFace;
+/**
+ * additional imports for TypeScript
+ *
+ * Type-only, so they add no runtime edge and this module stays importable
+ * from anywhere. Without them the unions below silently degrade to `any` in
+ * the generated declarations, which `tsc` does not report.
+ * @import {CompressedImage} from "./parsers/compressed_textures/compressed_image.js";
+ * @import {GLTFData} from "./parsers/gltf.js";
+ * @import GLShader from "../video/webgl/glshader.js";
+ * @import ShaderEffect from "../video/effects/shadereffect.js";
+ */
 /**
  * where all preloaded content is cached
  */
@@ -11,4 +227,8 @@ export const objList: {};
 export const mtlList: {};
 export const gltfList: {};
 export const shaderList: {};
+import type { CompressedImage } from "./parsers/compressed_textures/compressed_image.js";
+import type { GLTFData } from "./parsers/gltf.js";
+import type ShaderEffect from "../video/effects/shadereffect.js";
+import type GLShader from "../video/webgl/glshader.js";
 //# sourceMappingURL=cache.d.ts.map

package/build/loader/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAAA;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;GAUG;AACH,+BANW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kCANW,MAAM,QACN,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;GASG;AACH,iCALW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAeD;;;;;GAKG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,+BA7BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAkCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;GAKG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAlbD;;;;;;;;;;GAUG;AAEH;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B;AAyB7B;;;;;;;;;;GAUG;AACH,2BAJU,SAAS,MAAM,EAAE,CAIyC;qCA5ElC,mDAAmD;8BAC1D,mBAAmB;8BAEjB,kCAAkC;0BADtC,4BAA4B"}