melonjs 19.7.1 → 19.9.0

package/build/lighting/light3d.d.ts

@@ -0,0 +1,86 @@
+import { Color } from "../math/color.ts";
+import { Vector3d } from "../math/vector3d.ts";
+import Renderable from "../renderable/renderable.js";
+/**
+ * Options accepted by the {@link Light3d} constructor.
+ * @category Lighting
+ */
+export interface Light3dOptions {
+    /**
+     * light type. `"directional"` (a sun — shaded) and `"ambient"` (a flat fill
+     * added to every lit pixel) are used today; `"point"` is reserved.
+     */
+    type?: "directional" | "ambient" | "point";
+    /** world-space direction the light travels along (directional lights). */
+    direction?: [number, number, number];
+    /** world-space position (point lights — reserved for a future release). */
+    position?: [number, number, number];
+    /**
+     * light color — a {@link Color}, a CSS color string, or an `[r, g, b]`
+     * array with components in `0..1` (the glTF convention). Defaults to white.
+     */
+    color?: Color | string | [number, number, number];
+    /** scalar multiplier on the light's contribution. Defaults to `1`. */
+    intensity?: number;
+}
+/**
+ * A 3D light source for the mesh lighting path — the 3D counterpart of
+ * {@link Light2d}. Like `Light2d`, a `Light3d` is a world {@link Renderable}:
+ * add it to a container with `app.world.addChild(light)` and it auto-registers
+ * with the active {@link Stage}, so any lit mesh in that scene is shaded by it.
+ * Remove it from the world to turn it off. A light draws nothing itself.
+ *
+ * Two types are used today:
+ * - **`"directional"`** — a sun: a world-space `direction`, no falloff. Shaded
+ *   via half-Lambert diffuse.
+ * - **`"ambient"`** — a flat fill added to every lit pixel (the dark side of a
+ *   mesh never goes fully black). `direction` / `position` are ignored.
+ *
+ * `"point"` is reserved for a future release. Fields are public and mutable, so
+ * a light can be animated at runtime (e.g. a day/night cycle rotating
+ * `direction`, or fading `intensity`).
+ * @category Lighting
+ * @example
+ * import { Light3d } from "melonjs";
+ *
+ * // a sun + a soft ambient fill, added to the world like any renderable
+ * const sun = new Light3d({ direction: [0.3, 1, 0.2], color: "#fff" });
+ * app.world.addChild(sun);
+ * app.world.addChild(new Light3d({ type: "ambient", intensity: 0.3 }));
+ *
+ * // animate the sun in-game (direction is the way light travels)
+ * sun.direction.set(Math.sin(t), 1, Math.cos(t)).normalize();
+ */
+export declare class Light3d extends Renderable {
+    /** `"directional"` / `"ambient"` (shaded) or `"point"` (reserved). */
+    type: "directional" | "ambient" | "point";
+    /** world-space travel direction (directional lights); kept normalized. */
+    direction: Vector3d;
+    /** world-space position (point lights — reserved). */
+    position: Vector3d;
+    /** the light color. */
+    color: Color;
+    /** scalar multiplier on the light's contribution. */
+    intensity: number;
+    /**
+     * @param [options] - see {@link Light3dOptions}
+     */
+    constructor(options?: Light3dOptions);
+    /**
+     * Register with the active stage's 3D-light set on activation (when added to
+     * a rooted container), mirroring {@link Light2d}.
+     * @ignore
+     */
+    onActivateEvent(): void;
+    /**
+     * Deregister from the active stage when removed from the world.
+     * @ignore
+     */
+    onDeactivateEvent(): void;
+    /**
+     * A light has no visual representation.
+     * @ignore
+     */
+    draw(): void;
+}
+//# sourceMappingURL=light3d.d.ts.map

package/build/lighting/light3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"light3d.d.ts","sourceRoot":"","sources":["../../src/lighting/light3d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;IAC3C,0EAA0E;IAC1E,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,OAAQ,SAAQ,UAAU;IACtC,sEAAsE;IAC7D,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;IACnD,0EAA0E;IAC1E,SAAS,EAAE,QAAQ,CAAC;IACpB,sDAAsD;IACtD,QAAQ,EAAE,QAAQ,CAAC;IACnB,uBAAuB;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;gBACS,OAAO,GAAE,cAAmB;IAgDxC;;;;OAIG;IACM,eAAe;IAIxB;;;OAGG;IACM,iBAAiB;IAI1B;;;OAGG;IACM,IAAI;CACb"}

package/build/loader/cache.d.ts

@@ -9,4 +9,6 @@ export const videoList: {};
 export const fontList: {};
 export const objList: {};
 export const mtlList: {};
+export const gltfList: {};
+export const shaderList: {};
 //# 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"}
+{"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"}

package/build/loader/loader.d.ts

@@ -32,7 +32,7 @@ export function setOptions(options: {
  * @name setBaseURL
  * @memberof loader
  * @public
- * @param {string} type  - "*", "audio", "video", "binary", "image", "json", "js", "tmx", "tsx", "fontface", "aseprite"
+ * @param {string} type  - "*", "audio", "video", "binary", "image", "json", "js", "tmx", "tsx", "fontface", "aseprite", "shader"
  * @param {string} [url="./"] - default base URL
  * @example
  * // change the base URL relative address for audio assets
@@ -47,11 +47,11 @@ export function setBaseURL(type: string, url?: string): void;
  * @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"|"tmj"|"tsx"|"tsj"|"fontface"|"video"|"aseprite")
+ * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tmj"|"tsx"|"tsj"|"fontface"|"video"|"aseprite"|"shader")
  * @property {string|string[]} [src]  - 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.
- * @property {string} [data]  - TMX data if not provided through a src url
+ * @property {string} [data]  - inline content if not provided through a src url: TMX data for "tmx" assets, GLSL source (the ShaderEffect fragment-body convention) for "shader" assets
  * @property {boolean} [stream=false] - Set to true to not to wait for large audio or video file to be downloaded before playing.
  * @property {boolean} [autoplay=false] - 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)
  * @property {boolean} [loop=false] - Set to true to automatically loop the audio or video when playing
@@ -118,6 +118,9 @@ export function setParser(type: string, parserFn: Function): void;
  * @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
+ * @returns {Promise<void>} resolves once every asset has loaded (rejects on a
+ * load failure). The `onloadcb` callback is still invoked on success, so both
+ * the callback and `await` forms work — use whichever you prefer.
  * @example
  * game.assets = [
  *   // PNG tileset
@@ -154,11 +157,13 @@ export function setParser(type: string, parserFn: Function): void;
  *   me.loader.load({name: "avatar", type:"video", src: "data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZ..."};
  * ];
  * ...
- * // set all resources to be loaded
+ * // set all resources to be loaded (callback form)
  * me.loader.preload(game.assets, () => this.loaded());
+ * // ...or await it (the callback still fires too)
+ * await me.loader.preload(game.assets);
  * @category Assets
  */
-export function preload(assets: Asset[], onloadcb?: Function, switchToLoadState?: boolean): void;
+export function preload(assets: Asset[], onloadcb?: Function, switchToLoadState?: boolean): Promise<void>;
 /**
  * retry loading assets after a loading failure
  * @memberof loader
@@ -182,10 +187,15 @@ export function reload(src: string): void;
  * @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
- * @returns {number} the amount of corresponding resource to be preloaded
+ * @returns {number|Promise<void>} with `onload`/`onerror` provided, the amount
+ * of corresponding resource to be preloaded (the legacy callback form). With
+ * **both omitted**, a Promise that resolves once the asset has loaded, so you
+ * can `await loader.load(asset)` for a one-off dynamic load.
  * @example
- * // load an image asset
+ * // load an image asset (callback form)
  * me.loader.load({name: "avatar",  type:"image",  src: "data/avatar.png"}, () => this.onload(), () => this.onerror());
+ * // ...or await a single dynamic asset (no callbacks)
+ * await me.loader.load({name: "avatar", type: "image", src: "data/avatar.png"});
  * // load a compressed texture with fallback chain
  * me.loader.load({name: "terrain", type:"image", src: ["data/gfx/terrain.astc.ktx", "data/gfx/terrain.dds", "data/gfx/terrain.png"]}, () => this.onload());
  * // load a base64 image asset
@@ -206,7 +216,7 @@ export function reload(src: string): void;
  * });
  * @category Assets
  */
-export function load(asset: Asset, onload?: Function, onerror?: Function): number;
+export function load(asset: Asset, onload?: Function, onerror?: Function): number | Promise<void>;
 /**
  * unload the specified asset to free memory
  * @memberof loader
@@ -285,6 +295,110 @@ export function getJSON(elt: string): JSON;
  * });
  */
 export function getOBJ(elt: string): object;
+/**
+ * a parsed glTF/GLB scene descriptor, as returned by {@link loader.getGLTF}
+ * @typedef {object} GLTFData
+ * @property {object[]} nodes - one entry per mesh primitive (accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image`, `doubleSided`)
+ * @property {Array<{world: number[], type?: string, perspective?: {yfov?: number, aspectRatio?: number, znear?: number, zfar?: number}, orthographic?: object}>} cameras - glTF cameras, each with its `world` transform + the glTF camera parameters (`perspective` for perspective cameras, `orthographic` otherwise)
+ * @property {object[]} lights - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, world-space `direction`/`position`, `name`)
+ * @property {{min: number[], max: number[]}} bounds - world-space scene bounds in glTF units
+ */
+/**
+ * return the parsed glTF/GLB scene descriptor for the given asset name.
+ *
+ * The descriptor is `{ nodes, cameras, lights, bounds }`:
+ * - `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`, world-space `direction`/`position`); empty without the
+ *   extension. The level director instantiates directional ones automatically.
+ * - `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).
+ * @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
+ * @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 **`{vertex, fragment}` program pair** (see
+ * the example) compiles into a raw {@link GLShader} instead — the type the
+ * advanced 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.
+ *
+ * Shader assets are WebGL-only: under the Canvas renderer a fragment-body
+ * asset returns an inert `ShaderEffect` stub (same behavior as constructing
+ * one directly), and a program-pair asset returns `null` (a raw GL program
+ * has no canvas analog). Note that shader assets require `video.init()` to
+ * have been called — 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
+ * @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 {vertex, fragment} program pair → a raw GLShader
+ *     { name: "toonMesh", type: "shader", src: {
+ *         vertex: "shaders/toon.vert",
+ *         fragment: "shaders/toon.frag",
+ *     } },
+ * ], () => {
+ *     // one shared program — same uniform state for every user
+ *     mySprite.shader = me.loader.getShader("waterRipple");
+ *     // private copy with its own uniforms (caller-owned, shared = false)
+ *     boss.shader = me.loader.getShader("flash").clone();
+ *     // a program pair comes back as a GLShader, e.g. for a custom Mesh shader
+ *     renderer.drawMesh(myMesh, { shader: me.loader.getShader("toonMesh") });
+ * });
+ */
+export function getShader(elt: string): ShaderEffect | GLShader | null;
 /**
  * return the specified MTL material data
  * @memberof loader
@@ -419,4 +533,38 @@ export let onError: Function;
  * an asset definition to be used with the loader
  */
 export type Asset = object;
+/**
+ * a parsed glTF/GLB scene descriptor, as returned by {@link loader.getGLTF}
+ */
+export type GLTFData = {
+    /**
+     * - one entry per mesh primitive (accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image`, `doubleSided`)
+     */
+    nodes: object[];
+    /**
+     * - glTF cameras, each with its `world` transform + the glTF camera parameters (`perspective` for perspective cameras, `orthographic` otherwise)
+     */
+    cameras: Array<{
+        world: number[];
+        type?: string;
+        perspective?: {
+            yfov?: number;
+            aspectRatio?: number;
+            znear?: number;
+            zfar?: number;
+        };
+        orthographic?: object;
+    }>;
+    /**
+     * - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, world-space `direction`/`position`, `name`)
+     */
+    lights: object[];
+    /**
+     * - world-space scene bounds in glTF units
+     */
+    bounds: {
+        min: number[];
+        max: number[];
+    };
+};
 //# sourceMappingURL=loader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"AAmFA;;;GAGG;AACH,mDAEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAdG;IAAyB,WAAW;IACV,OAAO;IACP,eAAe;CACzC,QAqBF;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,QACN,MAAM,QAwBhB;AAiID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAnBW,MAAM,4BA6BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,gCA3CW,KAAK,EAAE,2CAEP,OAAO,QAiFjB;AAED;;;;;;;;;;;;;;;IAeI;AACJ,4BAbW,MAAM,QAqChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,4BA3BW,KAAK,0CAGH,MAAM,CA4DlB;AAED;;;;;;;GAOG;AACH,8BALW,KAAK,GACH,OAAO,CAiGnB;AAED;;;;;GAKG;AACH,kCAqFC;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAh4BD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAbU,MAAM,CAaO;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,4BAbU,OAAO,CAakB;AAyEnC;;;;;;;;;GASG;AACH,4BAAkB;AAElB;;;;;;;;;;;GAWG;AACH,gCAAsB;AAEtB;;;;;;;;;;GAUG;AACH,6BAAmB;;;;oBA4FN,MAAM"}
+{"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,QAyBhB;AAqID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,+BA1BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CA+BtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAzlCD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAbU,MAAM,CAaO;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,4BAbU,OAAO,CAakB;AA0EnC;;;;;;;;;GASG;AACH,4BAAkB;AAElB;;;;;;;;;;;GAWG;AACH,gCAAsB;AAEtB;;;;;;;;;;GAUG;AACH,6BAAmB;;;;oBAgGN,MAAM;;;;;;;;WAiqBL,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"}

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

@@ -1,3 +1,17 @@
+/**
+ * Whether `url` must be loaded over the `file:` scheme — either an absolute
+ * `file://` URL, or a relative URL resolved against a `file:` document (the
+ * case for a Cordova/Capacitor build packaged into an APK, where the app runs
+ * from `file://`). `fetch()` cannot load such URLs in several WebView contexts
+ * (it rejects with an opaque network error), whereas `XMLHttpRequest` can. The
+ * document `protocol` is injectable so the relative-URL branch is unit-testable
+ * (`location` is non-configurable in a real browser).
+ * @param {string} url
+ * @param {string} [protocol] - the hosting document's protocol
+ * @returns {boolean}
+ * @ignore
+ */
+export function isFileProtocol(url: string, protocol?: string): boolean;
 /**
  * Fetches data from the specified URL.
  * @param {string} url - The URL to fetch the data from.

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

@@ -1 +1 @@
-{"version":3,"file":"fetchdata.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fetchdata.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,+BAdW,MAAM,gBACN,MAAM,aACN,MAAM,gBAuChB"}
+{"version":3,"file":"fetchdata.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fetchdata.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAKnB;AA2DD;;;;;;;;;;;;;;;GAeG;AACH,+BAdW,MAAM,gBACN,MAAM,aACN,MAAM,gBAkDhB"}

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

@@ -0,0 +1,71 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,sCAJW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAkCpD;AAmED;;;;GAIG;AACH,+EAgCC;AAqCD;;;;;;;;;;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;AAuED;;;;;;;;;;GAUG;AACH,uCATW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CA+X3B;AAED;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6BlB"}

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

@@ -1 +1 @@
-{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AA+HA;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAyBlB"}
+{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AAgJA;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAuElB"}

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

@@ -0,0 +1,47 @@
+/**
+ * compile a shader asset's source into its shared, loader-owned instance:
+ * a fragment body (the `apply()` convention) compiles into a
+ * {@link ShaderEffect}; a full `{vertex, fragment}` program pair compiles
+ * into a raw {@link GLShader} — for the advanced paths that take one (a
+ * `Mesh` custom shader, `renderer.customShader`, a custom batcher).
+ * Program pairs are WebGL-only: under the Canvas renderer a pair asset
+ * stores `null` (with a warning) — a raw GL program has no canvas analog,
+ * unlike ShaderEffect's inert Canvas stub.
+ * @param {string|{vertex: string, fragment: string, precision?: string}} source - the fragment body, or a complete program pair
+ * @returns {ShaderEffect|GLShader|null} the compiled asset, flagged `shared`
+ * @throws if called before `video.init()` (no renderer to compile against)
+ * @ignore
+ */
+export function compileShaderAsset(source: string | {
+    vertex: string;
+    fragment: string;
+    precision?: string;
+}): ShaderEffect | GLShader | null;
+/**
+ * parse/preload a shader asset, from a `src` URL (or data: URI) or inline
+ * GLSL via the `data` field. Two source shapes are accepted:
+ *
+ * - a GLSL **fragment body** following the ShaderEffect convention (uniform
+ *   declarations + `vec4 apply(vec4, vec2)`) → compiles into a shared
+ *   {@link ShaderEffect};
+ * - a complete **program pair** — `src: {vertex: url, fragment: url}` or
+ *   `data: {vertex: glsl, fragment: glsl}` — → compiles into a shared raw
+ *   {@link GLShader}, for the advanced paths that take one (a `Mesh`
+ *   custom shader, `renderer.customShader`, a custom batcher).
+ *
+ * Always compiled AT LOAD TIME, so the GLSL compile cost lands in the
+ * loading screen and compile errors carry the asset name. `video.init()`
+ * is an inherent precondition of the preload flow (the loading screen
+ * itself needs the renderer, and a failed init throws and halts) —
+ * loading a shader without it fails with a clear error.
+ * @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 preloadShader(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+import ShaderEffect from "../../video/webgl/shadereffect.js";
+import GLShader from "../../video/webgl/glshader.js";
+//# sourceMappingURL=shader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/shader.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;GAaG;AACH,2CALW,MAAM,GAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GAC3D,YAAY,GAAC,QAAQ,GAAC,IAAI,CAuCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAqGlB;yBA1LwB,mCAAmC;qBADvC,+BAA+B"}

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

@@ -1 +1 @@
-{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/video.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAqFlB"}
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/video.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAkGlB"}

package/build/math/color.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/math/color.ts"],"names":[],"mappings":"AA0MA;;;GAGG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,cAAc,CAAe;IAErC;;;;;;OAMG;gBACS,CAAC,GAAE,KAAK,GAAG,MAAM,GAAG,MAAU,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAM;IAcrE;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,KAAK,WAER;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,KAAK,QAAA,EAEd;IAED;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,KAAK,SAAM;IASjE;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAM;IASrD;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IA8CtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAmBtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAY5C;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAS1B;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK;IAsBhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IASpB;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAYhC;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM;IAqBrB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,SAAI,EAAE,GAAG,SAAM;IAgBzB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK;IASnB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAQzB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAazB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,MAAM,EAAE,EAAE,IAAI,UAAQ;IAmD7C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,SAAM;IAUpB;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,KAAK;IAKL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAyB;IAKrC;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAa;CAGzB;AAED,eAAO,MAAM,SAAS,gKAwBpB,CAAC"}
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/math/color.ts"],"names":[],"mappings":"AA+MA;;;GAGG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,cAAc,CAAe;IAErC;;;;;;OAMG;gBACS,CAAC,GAAE,KAAK,GAAG,MAAM,GAAG,MAAU,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAM;IAcrE;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,KAAK,WAER;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,KAAK,QAAA,EAEd;IAED;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,KAAK,SAAM;IASjE;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAM;IASrD;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IA8CtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAmBtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAY5C;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAS1B;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK;IAsBhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IASpB;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAYhC;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM;IAqBrB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,SAAI,EAAE,GAAG,SAAM;IAgBzB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK;IASnB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAQzB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAazB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,MAAM,EAAE,EAAE,IAAI,UAAQ;IAmD7C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,SAAM;IAUpB;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,KAAK;IAKL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAyB;IAKrC;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAa;CAGzB;AAED,eAAO,MAAM,SAAS,gKAwBpB,CAAC"}

package/build/math/math.d.ts

@@ -149,8 +149,8 @@ export declare function lerp(a: number, b: number, t: number): number;
  * After total elapsed time `t_total` (in seconds), the result
  * satisfies
  * `result = current + (target - current) * (1 - exp(-lambda * t_total))`
- * regardless of how `t_total` was split across `dt` calls. Same
- * algorithm as `THREE.MathUtils.damp` in Three.js.
+ * regardless of how `t_total` was split across `dt` calls — the standard
+ * frame-rate-independent exponential `damp` formulation.
  *
  * `lambda` is the decay rate in `1/seconds` — higher = snappier
  * convergence. A rule of thumb: `lambda = 5` reaches ≈ 99% of the

package/build/math/matrix2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix2d.d.ts","sourceRoot":"","sources":["../../src/math/matrix2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,KAAK,cAAc,GAChB,CAAC,QAAQ,CAAC,GACV,CAAC,QAAQ,CAAC,GACV,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACxE,CAAC,SAAS,CAAC,GACX,EAAE,CAAC;AAcN;;;;;GAKG;AACH,qBAAa,QAAQ;IACpB;;OAEG;IACH,GAAG,EAAE,YAAY,CAAC;IAElB;;;OAGG;gBACS,GAAG,KAAK,EAAE,cAAc;IAKpC;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;;;OAKG;IACH,QAAQ;IAKR;;;;OAIG;IACH,YAAY,CACX,GAAG,MAAM,EACN,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IA2B5E;;;;;;;;;OASG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAuB1E;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,QAAQ;IAKhB;;;;OAIG;IACH,SAAS,CAAC,CAAC,EAAE,QAAQ;IAerB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,QAAQ;IAwBpB;;;OAGG;IACH,SAAS;IAgBT;;;OAGG;IACH,MAAM;IAkCN;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK;IAgBpC;;;;OAIG;IACH,YAAY,CAAC,CAAC,EAAE,QAAQ;IAexB;;;;;OAKG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI;IActB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAIlB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAsBpB;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ;IACzC,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ;IAmBrC;;;OAGG;IACH,UAAU;IAiBV;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAclB;;;OAGG;IACH,KAAK;IAIL;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;CAOR;AAED,eAAO,MAAM,YAAY,4DAWxB,CAAC"}
+{"version":3,"file":"matrix2d.d.ts","sourceRoot":"","sources":["../../src/math/matrix2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,KAAK,cAAc,GAChB,CAAC,QAAQ,CAAC,GACV,CAAC,QAAQ,CAAC,GACV,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACxE,CAAC,SAAS,CAAC,GACX,EAAE,CAAC;AAcN;;;;;GAKG;AACH,qBAAa,QAAQ;IACpB;;OAEG;IACH,GAAG,EAAE,YAAY,CAAC;IAElB;;;OAGG;gBACS,GAAG,KAAK,EAAE,cAAc;IAKpC;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;OAGG;IACH,IAAI,EAAE,WAEL;IAED;;;;;OAKG;IACH,QAAQ;IAKR;;;;OAIG;IACH,YAAY,CACX,GAAG,MAAM,EACN,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChD,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IA8B5E;;;;;;;;;OASG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAuB1E;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,QAAQ;IAKhB;;;;OAIG;IACH,SAAS,CAAC,CAAC,EAAE,QAAQ;IAerB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,QAAQ;IAwBpB;;;OAGG;IACH,SAAS;IAgBT;;;OAGG;IACH,MAAM;IAkCN;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK;IAgBpC;;;;OAIG;IACH,YAAY,CAAC,CAAC,EAAE,QAAQ;IAexB;;;;;OAKG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI;IActB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAIlB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAsBpB;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ;IACzC,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ;IAmBrC;;;OAGG;IACH,UAAU;IAiBV;;;;OAIG;IACH,MAAM,CAAC,CAAC,EAAE,QAAQ;IAclB;;;OAGG;IACH,KAAK;IAIL;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,QAAQ;CAOR;AAED,eAAO,MAAM,YAAY,4DAWxB,CAAC"}