melonjs 20.3.0 → 20.4.0

package/build/loader/loader.d.ts

@@ -1,11 +1,6 @@
-/**
- * enable the nocache mechanism
- * @ignore
- */
-export function setNocache(enable?: boolean): void;
+
 /**
  * Sets the options for the loader.
- * @memberof loader
  * @param {Object} options - The options to set.
  * @param {string} [options.crossOrigin] - The crossOrigin attribute to configure the CORS requests for Image and Video data element.
  * @param {boolean} [options.nocache] - Enable or disable the nocache mechanism.
@@ -29,8 +24,6 @@ export function setOptions(options: {
 /**
  * change the default baseURL for the given asset type.<br>
  * (this will prepend the asset URL and must finish with a '/')
- * @name setBaseURL
- * @memberof loader
  * @public
  * @param {string} type  - "*", "audio", "video", "binary", "image", "json", "js", "tmx", "tsx", "fontface", "aseprite", "shader", "obj", "mtl", "gltf", "glb"
  * @param {string} [url="./"] - default base URL
@@ -45,7 +38,6 @@ export function setBaseURL(type: string, url?: string): void;
 /**
  * an asset definition to be used with the loader
  * @typedef {object} Asset
- * @memberof loader
  * @property {string} name - name of the asset
  * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tsx"|"fontface"|"video"|"aseprite"|"shader"|"obj"|"mtl"|"gltf"|"glb"). JSON-serialised Tiled maps and tilesets (`.tmj` / `.tsj`) load under `"tmx"` / `"tsx"` — those are file extensions, not asset types.
  * @property {string|string[]} [src]  - path and/or file name of the resource (for audio assets only the path is required).
@@ -99,7 +91,6 @@ export function setBaseURL(type: string, url?: string): void;
  */
 /**
  * specify a parser/preload function for the given asset type
- * @memberof loader
  * @param {string} type - asset type
  * @param {function} parserFn - parser function
  * @see {@link Asset.type}
@@ -122,7 +113,6 @@ export function setBaseURL(type: string, url?: string): void;
 export function setParser(type: string, parserFn: Function): void;
 /**
  * set all the specified game assets to be preloaded.
- * @memberof loader
  * @param {Asset[]} assets - list of assets to load
  * @param {Function} [onloadcb=loader.onload] - function to be called when all resources are loaded
  * @param {boolean} [switchToLoadState=true] - automatically switch to the loading screen
@@ -174,7 +164,6 @@ export function setParser(type: string, parserFn: Function): void;
 export function preload(assets: Asset[], onloadcb?: Function, switchToLoadState?: boolean): Promise<void>;
 /**
  * retry loading assets after a loading failure
- * @memberof loader
  * @param {string} src - src of asset to reload
  * @example
  *  event.on(
@@ -191,7 +180,6 @@ export function preload(assets: Asset[], onloadcb?: Function, switchToLoadState?
 export function reload(src: string): void;
 /**
  * Load a single asset (to be used if you need to load additional asset(s) during the game)
- * @memberof loader
  * @param {Asset} asset
  * @param {Function} [onload] - function to be called when the asset is loaded
  * @param {Function} [onerror] - function to be called in case of error
@@ -227,7 +215,6 @@ export function reload(src: string): void;
 export function load(asset: Asset, onload?: Function, onerror?: Function): number | Promise<void>;
 /**
  * unload the specified asset to free memory
- * @memberof loader
  * @param {Asset} asset
  * @returns {boolean} true if unloaded
  * @example me.loader.unload({name: "avatar",  type:"image"});
@@ -236,14 +223,12 @@ export function load(asset: Asset, onload?: Function, onerror?: Function): numbe
 export function unload(asset: Asset): boolean;
 /**
  * unload all resources to free memory
- * @memberof loader
  * @example me.loader.unloadAll();
  * @category Assets
  */
 export function unloadAll(): void;
 /**
  * return the specified TMX/TSX object
- * @memberof loader
  * @param {string} elt - name of the tmx/tsx element ("map1");
  * @returns {object} requested element or null if not found
  * @category Assets
@@ -251,7 +236,6 @@ export function unloadAll(): void;
 export function getTMX(elt: string): object;
 /**
  * return the specified Binary object
- * @memberof loader
  * @param {string} elt - name of the binary object ("ymTrack");
  * @returns {object} requested element or null if not found
  * @category Assets
@@ -259,7 +243,6 @@ export function getTMX(elt: string): object;
 export function getBinary(elt: string): object;
 /**
  * return the specified Image Object
- * @memberof loader
  * @param {string} image - name of the Image element ("tileset-platformer");
  * @returns {HTMLImageElement|CompressedImage|null} requested element or null if not found
  * @category Assets
@@ -267,7 +250,6 @@ export function getBinary(elt: string): object;
 export function getImage(image: string): HTMLImageElement | CompressedImage | null;
 /**
  * return the specified JSON Object
- * @memberof loader
  * @param {string} elt - name of the json file
  * @returns {JSON}
  * @category Assets
@@ -275,7 +257,6 @@ export function getImage(image: string): HTMLImageElement | CompressedImage | nu
 export function getJSON(elt: string): JSON;
 /**
  * return the specified OBJ model data
- * @memberof loader
  * @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
@@ -336,7 +317,6 @@ export function getOBJ(elt: string): object;
  * 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).
- * @memberof loader
  * @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
@@ -387,7 +367,6 @@ export function getGLTF(elt: string): GLTFData | null;
  * 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.
- * @memberof loader
  * @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
@@ -420,7 +399,6 @@ export function getGLTF(elt: string): GLTFData | null;
 export function getShader(elt: string): ShaderEffect | GLShader | null;
 /**
  * return the specified MTL material data
- * @memberof loader
  * @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
@@ -451,7 +429,6 @@ export function getShader(elt: string): ShaderEffect | GLShader | null;
 export function getMTL(elt: string): object;
 /**
  * return the specified Video Object
- * @memberof loader
  * @param {string} elt - name of the video file
  * @returns {HTMLVideoElement}
  * @category Assets
@@ -459,7 +436,6 @@ export function getMTL(elt: string): object;
 export function getVideo(elt: string): HTMLVideoElement;
 /**
  * return the specified FontFace Object
- * @memberof loader
  * @param {string} elt - name of the font file
  * @returns {FontFace}
  * @category Assets
@@ -482,14 +458,15 @@ export const baseURL: {
  * The "anonymous" keyword means that there will be no exchange of user credentials via cookies,
  * client-side SSL certificates or HTTP authentication as described in the Terminology section of the CORS specification.<br>
  * @type {string}
- * @name crossOrigin
- * @memberof loader
  * @default undefined
  * @see {@link setOptions}
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_settings_attributes}
+ * @deprecated since 20.4.0, read-only — set it with
+ * {@link setOptions}. This is a module binding, so assigning to it throws a
+ * `TypeError`; the example below never worked.
  * @example
  *  // allow for cross-origin texture loading
- * me.loader.crossOrigin = "anonymous";
+ * me.loader.setOptions({ crossOrigin: "anonymous" });
  *
  * // set all resources to be loaded
  * me.loader.preload(game.resources, () => this.loaded());
@@ -500,14 +477,15 @@ export let crossOrigin: string;
  * authorization headers or TLS client certificates. Setting withCredentials has no effect on same-site requests.
  * @public
  * @type {boolean}
- * @name withCredentials
  * @see {@link setOptions}
  * @default false
- * @memberof loader
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials}
+ * @deprecated since 20.4.0, read-only — set it with
+ * {@link setOptions}. This is a module binding, so assigning to it throws a
+ * `TypeError`; the example below never worked.
  * @example
- *  // enable withCredentials
- * me.loader.withCredentials = true;
+ *  // enable withCredentials, for assets behind a session cookie or login
+ * me.loader.setOptions({ withCredentials: true });
  *
  * // set all resources to be loaded
  * me.loader.preload(game.resources, () => this.loaded());
@@ -516,7 +494,38 @@ export let withCredentials: boolean;
 /**
  * an asset definition to be used with the loader
  */
-export type Asset = object;
+export type Asset = {
+    /**
+     * - name of the asset
+     */
+    name: string;
+    /**
+     * - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tsx"|"fontface"|"video"|"aseprite"|"shader"|"obj"|"mtl"|"gltf"|"glb"). JSON-serialised Tiled maps and tilesets (`.tmj` / `.tsj`) load under `"tmx"` / `"tsx"` — those are file extensions, not asset types.
+     */
+    type: string;
+    /**
+     * - path and/or file name of the resource (for audio assets only the path is required).
+     * For image assets, an array of sources can be provided as a fallback chain (e.g. compressed texture formats by priority, with a PNG fallback).
+     * The loader will try each source in order and use the first one that loads successfully.
+     */
+    src?: string | string[];
+    /**
+     * - inline content if not provided through a src url: TMX data for "tmx" assets, GLSL source (the ShaderEffect fragment-body convention) for "shader" assets
+     */
+    data?: string;
+    /**
+     * - Set to true to not to wait for large audio or video file to be downloaded before playing.
+     */
+    stream?: boolean;
+    /**
+     * - Set to true to automatically start playing audio or video when loaded or added to a scene (using autoplay might require user iteraction to enable it)
+     */
+    autoplay?: boolean;
+    /**
+     * - Set to true to automatically loop the audio or video when playing
+     */
+    loop?: boolean;
+};
 /**
  * a parsed glTF/GLB scene descriptor, as returned by {@link loader.getGLTF}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"AAuFA;;;GAGG;AACH,mDAEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAdG;IAAyB,WAAW;IACV,OAAO;IACP,eAAe;CACzC,QAqBF;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,QACN,MAAM,QA6BhB;AAkGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAnBW,MAAM,4BA6BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,gCAhDW,KAAK,EAAE,2CAEP,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAoFzB;AAED;;;;;;;;;;;;;;;IAeI;AACJ,4BAbW,MAAM,QAqChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,4BAhCW,KAAK,0CAGH,MAAM,GAAC,OAAO,CAAC,IAAI,CAAC,CAqGhC;AAED;;;;;;;GAOG;AACH,8BALW,KAAK,GACH,OAAO,CA6HnB;AAED;;;;;GAKG;AACH,kCAyGC;AAED;;;;;;GAMG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,+BA7BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAkCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AA9kCD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAbU,MAAM,CAaO;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,4BAbU,OAAO,CAakB;;;;oBAgLtB,MAAM;;;;;;;;WA0qBL,MAAM,EAAE;;;;aACR,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;;;;YAClJ,MAAM,EAAE;;;;YACR;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAA;KAAC;;;;WAC9B,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"AAyFA;;;;GAIG;AACH,mDAEC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,oCAdG;IAAyB,WAAW;IACV,OAAO;IACP,eAAe;CACzC,QAqBF;AAED;;;;;;;;;;;;GAYG;AACH,iCATW,MAAM,QACN,MAAM,QA6BhB;AAuGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,gCAnBW,MAAM,4BA6BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,gCAhDW,KAAK,EAAE,2CAEP,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAoFzB;AAED;;;;;;;;;;;;;;IAcI;AACJ,4BAbW,MAAM,QAqChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,4BAhCW,KAAK,0CAGH,MAAM,GAAC,OAAO,CAAC,IAAI,CAAC,CAqGhC;AAED;;;;;;GAMG;AACH,8BALW,KAAK,GACH,OAAO,CA6HnB;AAED;;;;GAIG;AACH,kCAyGC;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;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;AAlkCD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAdU,MAAM,CAcO;AAEvB;;;;;;;;;;;;;;;;;GAiBG;AACH,4BAdU,OAAO,CAckB;;;;;;;;UAoLrB,MAAM;;;;UACN,MAAM;;;;;;UACN,MAAM,GAAC,MAAM,EAAE;;;;WAGf,MAAM;;;;aACN,OAAO;;;;eACP,OAAO;;;;WACP,OAAO;;;;;;;;;WAqpBP,MAAM,EAAE;;;;aACR,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;;;;YAClJ,MAAM,EAAE;;;;YACR;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAA;KAAC;;;;WAC9B,MAAM,EAAE;;;;gBACR,MAAM,EAAE"}

package/build/loader/loadingscreen.d.ts

@@ -1,36 +1,3 @@
 export default DefaultLoadingScreen;
-/**
- * a default loading screen
- * @ignore
- */
-declare class DefaultLoadingScreen extends Stage {
-    /**
-     * Pin the loading screen to a Camera2d regardless of the
-     * application's `cameraClass` setting. The loader must render
-     * correctly even when the host app opts in to Camera3d globally
-     * — a perspective camera applied to a 2D progress bar would
-     * stretch / clip the bar based on its depth.
-     */
-    constructor();
-    /**
-     * @ignore
-     */
-    progressBar: null;
-    /**
-     * @ignore
-     */
-    logoSprite: null;
-    /**
-     * call when the loader is resetted
-     * @ignore
-     */
-    onResetEvent(app: any): void;
-    /**
-     * Called by engine before deleting the object
-     * @ignore
-     */
-    onDestroyEvent(): void;
-    #private;
-}
 import Stage from "./../state/stage.ts";
 //# sourceMappingURL=loadingscreen.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"loadingscreen.d.ts","sourceRoot":"","sources":["../../src/loader/loadingscreen.js"],"names":[],"mappings":";AA6EA;;;GAGG;AACH;IAuBC;;;;;;OAMG;IACH,cAEC;IA/BD;;OAEG;IACH,kBAAmB;IAEnB;;OAEG;IACH,iBAAkB;IAyBlB;;;OAGG;IACH,6BAiCC;IAiCD;;;OAGG;IACH,uBAOC;;CACD;kBAlMiB,qBAAqB"}
+{"version":3,"file":"loadingscreen.d.ts","sourceRoot":"","sources":["../../src/loader/loadingscreen.js"],"names":[],"mappings":";AAiFA;;;;GAIG;AACH;IA2BC;;;;;;OAMG;IACH,cAEC;IAnCD;;;OAGG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,iBAAkB;IA2BlB;;;;OAIG;IACH,6BAiCC;IAkCD;;;;OAIG;IACH,uBAOC;;CACD;kBA9MiB,qBAAqB"}

package/build/loader/parsers/aseprite.d.ts

@@ -21,17 +21,4 @@ export function parseAseprite(buffer: any, imageName?: string): Promise<{
         };
     };
 }>;
-/**
- * preload an .aseprite binary file: fetches the file, parses + composites it,
- * then stores the resulting bitmap in `imgList` and the JSON sidecar in
- * `jsonList` under the same asset name — so TextureAtlas, TMXTileset, etc.
- * can resolve it via the usual getImage() / getJSON() lookups.
- * @param {loader.Asset} data - asset descriptor
- * @param {Function} [onload]
- * @param {Function} [onerror]
- * @param {Object} [settings]
- * @returns {number}
- * @ignore
- */
-export function preloadAseprite(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
 //# sourceMappingURL=aseprite.d.ts.map

package/build/loader/parsers/aseprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/aseprite.js"],"names":[],"mappings":"AA+gBA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;GAMC;AAED;;;;;;;;;;;GAWG;AACH,sCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/aseprite.js"],"names":[],"mappings":"AAqhBA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;GAMC;AAED;;;;;;;;;;;;GAYG;AACH,sCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAyBlB"}

package/build/loader/parsers/audio.d.ts

@@ -1,31 +1,2 @@
-/**
- * parse/preload an Audio file
- *
- * Unlike the other parsers this one delegates rather than doing the work
- * itself: audio assets are owned by the audio module, which decodes them
- * through its own backend and tracks them for playback. Keeping that
- * delegation here means every asset type is registered the same way — from a
- * parser of the same shape in this directory — and the loader never reaches
- * into the audio module directly, so replacing the audio backend cannot ripple
- * into the loader.
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadAudio(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
-/**
- * unload the given audio asset
- * @param {string} name - asset name
- * @returns {boolean} true if unloaded
- * @ignore
- */
-export function unloadAudio(name: string): boolean;
-/**
- * unload all audio assets
- * @ignore
- */
-export function unloadAllAudio(): void;
+
 //# sourceMappingURL=audio.d.ts.map

package/build/loader/parsers/audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/audio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;GAKG;AACH,kCAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;GAGG;AACH,uCAEC"}
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/audio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;GAMG;AACH,kCALW,MAAM,GACJ,OAAO,CAMnB;AAED;;;;GAIG;AACH,uCAEC"}

package/build/loader/parsers/binary.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a Binary file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the asset is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadBinary(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=binary.d.ts.map

package/build/loader/parsers/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/binary.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAsBlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/binary.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,oCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAuBlB"}

package/build/loader/parsers/compressed_textures/compressed_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compressed_image.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/compressed_image.js"],"names":[],"mappings":"AAmEA,yEAgDC;;;;;UA1Ga,UAAU;;;;WACV,MAAM;;;;YACN,MAAM;;;;;;;;;aAMN,sBAAsB,EAAE;;;;WACxB,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;gBACN,OAAO;;;;oBACP,OAAO"}
+{"version":3,"file":"compressed_image.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/compressed_image.js"],"names":[],"mappings":"AAwEA,yEAgDC;;;;;UA/Ga,UAAU;;;;WACV,MAAM;;;;YACN,MAAM;;;;;;;;;aAMN,sBAAsB,EAAE;;;;WACxB,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;gBACN,OAAO;;;;oBACP,OAAO"}

package/build/loader/parsers/compressed_textures/parseDDS.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a DDS compressed texture file.
- * @param {ArrayBuffer} data - the DDS file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseDDS(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseDDS.d.ts.map

package/build/loader/parsers/compressed_textures/parseDDS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDDS.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseDDS.js"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAoE3B"}
+{"version":3,"file":"parseDDS.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseDDS.js"],"names":[],"mappings":"AAsCA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAqE3B"}

package/build/loader/parsers/compressed_textures/parseKTX.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a KTX v1 compressed texture file.
- * @param {ArrayBuffer} data - the KTX file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseKTX(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseKTX.d.ts.map

package/build/loader/parsers/compressed_textures/parseKTX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseKTX.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CA+E3B"}
+{"version":3,"file":"parseKTX.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAgF3B"}

package/build/loader/parsers/compressed_textures/parseKTX2.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a KTX v2 compressed texture file.
- * @param {ArrayBuffer} data - the KTX2 file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseKTX2(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseKTX2.d.ts.map

package/build/loader/parsers/compressed_textures/parseKTX2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseKTX2.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX2.js"],"names":[],"mappings":"AAsEA;;;;;GAKG;AACH,gCAJW,WAAW,GACT,eAAe,CA0E3B"}
+{"version":3,"file":"parseKTX2.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX2.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,gCALW,WAAW,GACT,eAAe,CA2E3B"}

package/build/loader/parsers/compressed_textures/parsePKM.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a PKM compressed texture file.
- * @param {ArrayBuffer} data - the raw PKM file data
- * @returns {CompressedImage} a compressed texture object
- * @ignore
- */
-export function parsePKM(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parsePKM.d.ts.map

package/build/loader/parsers/compressed_textures/parsePKM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsePKM.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePKM.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAiD3B"}
+{"version":3,"file":"parsePKM.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePKM.js"],"names":[],"mappings":"AA0CA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAkD3B"}

package/build/loader/parsers/compressed_textures/parsePVR.d.ts

@@ -1,8 +1,2 @@
-/**
- * parse a PVR v3 compressed texture file
- * @param {ArrayBuffer} data - the PVR file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parsePVR(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parsePVR.d.ts.map

package/build/loader/parsers/compressed_textures/parsePVR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsePVR.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePVR.js"],"names":[],"mappings":"AAmEA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAqD3B"}
+{"version":3,"file":"parsePVR.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePVR.js"],"names":[],"mappings":"AAmEA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAsD3B"}

package/build/loader/parsers/fontface.d.ts

@@ -1,14 +1,2 @@
-/**
- * parse/preload a font face
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the asset is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- * @example
- * preloadFontFace([
- *     { name: "'kenpixel'", type: "fontface", src: "data/font/kenvector_future.woff2" }
- * ]);
- */
-export function preloadFontFace(data: loader.Asset, onload?: Function, onerror?: Function): number;
+
 //# sourceMappingURL=fontface.d.ts.map

package/build/loader/parsers/fontface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fontface.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fontface.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,sCAVW,MAAM,CAAC,KAAK,0CAGV,MAAM,CA+DlB"}
+{"version":3,"file":"fontface.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fontface.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sCAXW,MAAM,CAAC,KAAK,0CAGV,MAAM,CAgElB"}

package/build/loader/parsers/gltf.d.ts

@@ -1,71 +1,2 @@
-/**
- * Split a GLB binary container into its JSON description and binary buffer.
- * @param {ArrayBuffer} arrayBuffer
- * @returns {{ json: object, bin: Uint8Array | null }}
- * @ignore
- */
-export function parseGLB(arrayBuffer: ArrayBuffer): {
-    json: object;
-    bin: Uint8Array | null;
-};
-/**
- * Read an accessor into a flat TypedArray (stride-aware, non-interleaved
- * fast-path covered as a subset).
- * @ignore
- */
-export function readAccessor(json: any, buffers: any, accessorIndex: any): any;
-/**
- * Compose a column-major 4x4 local matrix from translation / rotation
- * (quaternion) / scale arrays — the glTF TRS convention — writing into `out`.
- * In-place so the per-frame animation pose path allocates nothing.
- * @param {number[]} out - 16-element destination (returned)
- * @param {number[]} translation - [tx, ty, tz]
- * @param {number[]} rotation - quaternion [qx, qy, qz, qw]
- * @param {number[]} scale - [sx, sy, sz]
- * @returns {number[]} `out`
- * @ignore
- */
-export function composeTRSInto(out: number[], translation: number[], rotation: number[], scale: number[]): number[];
-/**
- * Allocating form of {@link composeTRSInto} — returns a fresh 16-element array.
- * @param {number[]} translation - [tx, ty, tz]
- * @param {number[]} rotation - quaternion [qx, qy, qz, qw]
- * @param {number[]} scale - [sx, sy, sz]
- * @returns {number[]} 16-element column-major matrix
- * @ignore
- */
-export function composeTRS(translation: number[], rotation: number[], scale: number[]): number[];
-/** Compose a node's local matrix from its `matrix` or TRS fields. @ignore */
-export function nodeLocalMatrix(node: any): any;
-/**
- * Column-major 4x4 multiply `a * b`, writing into `out`. `out` must NOT alias
- * `a` or `b` (results are written as they're computed). In-place so the
- * per-frame pose path allocates nothing.
- * @ignore
- */
-export function multiplyMatrixInto(out: any, a: any, b: any): any;
-/** Allocating form of {@link multiplyMatrixInto}: `a * b` → fresh array. @ignore */
-export function multiplyMatrix(a: any, b: any): any;
-/**
- * Parse a glTF/GLB ArrayBuffer into a flat, instantiable scene descriptor.
- * @param {ArrayBuffer} arrayBuffer - the .glb / .gltf bytes
- * @param {string} [baseURI] - the asset's own URL, used to resolve external
- * `.bin` buffers and image files referenced by relative `uri`. Omit for a fully
- * self-contained GLB (embedded buffers + data-URI / bufferView images).
- * @param {object} [settings] - loader settings forwarded to `fetchData` for
- * external resources (crossOrigin / withCredentials / nocache).
- * @returns {Promise<object>} `{ nodes, cameras, lights, bounds, graph, animations }`
- * @ignore
- */
-export function parseGLTF(arrayBuffer: ArrayBuffer, baseURI?: string, settings?: object): Promise<object>;
-/**
- * parse/preload a glTF/GLB file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadGLTF(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=gltf.d.ts.map

package/build/loader/parsers/gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,sCAJW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAkCpD;AAmED;;;;GAIG;AACH,+EAgCC;AA0KD;;;;;;;;;;GAUG;AACH,oCAPW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB;AAED;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAKpB;AAED,6EAA6E;AAC7E,gDASC;AAiED;;;;;GAKG;AACH,kEAWC;AAED,oFAAoF;AACpF,oDAEC;AA8HD;;;;;;;;;;GAUG;AACH,uCATW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CAqa3B;AAED;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AA2CA;;;;;;GAMG;AACH,sCALW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAmCpD;AAsED;;;;;GAKG;AACH,+EAgCC;AA8KD;;;;;;;;;;;GAWG;AACH,oCARW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAqCpB;AAED;;;;;;;;GAQG;AACH,wCAPW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAMpB;AAED;;;;GAIG;AACH,gDASC;AAsED;;;;;;GAMG;AACH,kEAWC;AAED;;;;GAIG;AACH,oDAEC;AAmID;;;;;;;;;;;GAWG;AACH,uCAVW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CAsa3B;AAED;;;;;;;;;GASG;AACH,kCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA8BlB"}

package/build/loader/parsers/image.d.ts

@@ -1,23 +1,2 @@
-/**
- * parse/preload an image
- * @param {loader.Asset} img
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- * @example
- * preloadImages([
- *     { name : 'image1', src : 'images/image1.png'},
- *     { name : 'image2', src : 'images/image2.png'},
- *     { name : 'image3', src : 'images/image3.png'},
- *     // compressed texture with fallback chain
- *     { name : 'image4', src : [
- *         'images/image4.astc.ktx',  // try ASTC first
- *         'images/image4.dds',       // then S3TC via DDS
- *         'images/image4.png'        // fallback to PNG
- *     ]}
- * ]);
- */
-export function preloadImage(img: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=image.d.ts.map

package/build/loader/parsers/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/image.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kCAnBW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA4ClB"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/image.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kCApBW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6ClB"}

package/build/loader/parsers/json.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a JSON files
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadJSON(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=json.d.ts.map

package/build/loader/parsers/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/json.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/json.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,kCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAyBlB"}

package/build/loader/parsers/mtl.d.ts

@@ -1,29 +1,2 @@
-/**
- * Parse a Wavefront MTL file into material data.
- * Supports: `newmtl`, `Kd` (diffuse color), `Ke` (emissive color), `Ks`/`Ns`
- * (specular color and exponent), `Pr`/`Pm` (the PBR roughness/metalness
- * extension, approximated onto the specular terms when `Ks`/`Ns` are absent),
- * `map_Kd` (diffuse texture), `map_d` (alpha map), `d`/`Tr`
- * (opacity/transparency).
- *
- * Limitations:
- * - Ambient (`Ka`), optical density (`Ni`) and illumination model (`illum`) are parsed but ignored
- * - Normal maps (`map_bump`, `bump`), specular maps (`map_Ks`), and other texture maps are not supported
- *
- * @param {string} text - raw MTL file contents
- * @param {string} basePath - base URL path for resolving texture references
- * @returns {object} map of material names to their properties
- * @ignore
- */
-export function parseMTL(text: string, basePath: string): object;
-/**
- * Parse/preload a Wavefront MTL material file.
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadMTL(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=mtl.d.ts.map