melonjs 20.2.0 → 20.4.0

package/build/video/texture/cache.d.ts

@@ -1,140 +1,4 @@
 export default TextureCache;
-/**
- * a basic texture cache object
- * @ignore
- */
-declare class TextureCache {
-    /**
-     * @ignore
-     */
-    constructor(renderer: any, max_size?: number);
-    renderer: any;
-    cache: ArrayMultimap;
-    tinted: Map<any, any>;
-    units: Map<any, any>;
-    slotTable: TextureSlotTable;
-    reservedUnits: Map<any, any>;
-    /**
-     * Which texture units are currently taken. This is the slot table's own
-     * occupancy set, exposed under the name it has always had — seeding or
-     * clearing it drives the allocator directly.
-     * @returns {Set<number>} the occupied units
-     * @ignore
-     */
-    get usedUnits(): Set<number>;
-    set max_size(size: number);
-    /**
-     * How many texture units this cache may hand out. Backed by the slot
-     * table's capacity, so assigning it (tests narrow it to force exhaustion,
-     * and a context restore can resolve a different device limit) re-sizes the
-     * allocator rather than leaving the two disagreeing.
-     * @returns {number} the unit count
-     * @ignore
-     */
-    get max_size(): number;
-    /**
-     * @ignore
-     */
-    clear(): void;
-    /**
-     * @ignore
-     */
-    allocateTextureUnit(): number;
-    /**
-     * Reserve a texture unit so {@link allocateTextureUnit} never hands it to a
-     * color texture — used by `ShaderEffect.setTexture` to hold high units for
-     * its extra samplers. Reference-counted, so a unit shared by several effects
-     * stays reserved until the last one releases it.
-     * @param {number} unit - the texture unit to reserve
-     * @ignore
-     */
-    reserveUnit(unit: number): void;
-    /**
-     * Release a unit previously held by {@link reserveUnit}. The unit becomes
-     * allocatable again once its last holder releases it.
-     * @param {number} unit - the texture unit to release
-     * @ignore
-     */
-    releaseUnit(unit: number): void;
-    /**
-     * Reset all texture unit assignments without clearing the texture cache.
-     * Used by multi-texture batching when the shader's sampler range is exceeded.
-     * @ignore
-     */
-    resetUnitAssignments(): void;
-    /**
-     * @ignore
-     *
-     * Frees the single `(source, repeat)` unit matching the texture's
-     * current `repeat` field — deliberately granular, so freeing one live
-     * consumer (e.g. one of two patterns with different repeats over the
-     * same image) never evicts the other's unit. When a SOURCE goes away
-     * entirely, use {@link freeAllUnits} instead — a source can hold units
-     * under several repeat modes (per-mesh `textureRepeat` overrides,
-     * #1503) that this granular free would leave pinned.
-     */
-    freeTextureUnit(texture: any): void;
-    /**
-     * @ignore
-     *
-     * Free every texture unit allocated for the texture's source, across
-     * ALL repeat modes. A single source can hold several `(source, repeat)`
-     * units — patterns with different repeats over one image, or meshes
-     * sampling one image with per-mesh `textureRepeat` overrides (#1503) —
-     * and the source going away invalidates all of them at once.
-     */
-    freeAllUnits(texture: any): void;
-    /**
-     * @ignore
-     * @param {string} [repeat] - overrides the texture's own `repeat` for the
-     * unit lookup — sampler state per use (a mesh's `textureRepeat`), so one
-     * source can be sampled with several wrap modes without mutating the
-     * shared atlas (#1503). Omit to use `texture.repeat`.
-     *
-     * Hot-path note: `getUnit` / `peekUnit` are called per-texture per-draw,
-     * so the `(source, repeat)` lookup is inlined here rather than going
-     * through a helper that allocates a `{source, repeat}` object per call.
-     */
-    getUnit(texture: any, repeat?: string): any;
-    /**
-     * @ignore
-     * return every texture unit allocated for the given texture's source,
-     * across ALL repeat modes — the unload-time counterpart of the per-use
-     * `getUnit(texture, repeat)` override (#1503): a single source can hold
-     * one unit per wrap mode it was sampled with, and per-repeat `peekUnit`
-     * lookups would only ever find the one matching the texture's current
-     * `repeat` field. Not a hot path (allocates the result array).
-     */
-    peekAllUnits(texture: any): any[];
-    /**
-     * @ignore
-     * return the texture unit for the given texture, or -1 if not allocated
-     * @param {string} [repeat] - same per-use wrap override as {@link getUnit}
-     */
-    peekUnit(texture: any, repeat?: string): any;
-    /**
-     * @ignore
-     * cache the textureAltas for the given image
-     */
-    set(image: any, textureAtlas: any): void;
-    /**
-     * @ignore
-     */
-    has(image: any): boolean;
-    /**
-     * @ignore
-     * return the textureAltas for the given image
-     */
-    get(image: any, atlas: any): any;
-    /**
-     * @ignore
-     */
-    delete(image: any): void;
-    /**
-     * @ignore
-     */
-    tint(src: any, color: any): any;
-}
 import { ArrayMultimap } from "../../utils/array-multimap.js";
 import { TextureSlotTable } from "../gpu/textureslots.js";
 //# sourceMappingURL=cache.d.ts.map

package/build/video/texture/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAgBA;;;GAGG;AACH;IACC;;OAEG;IACH,8CAgDC;IA9CA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IAOtB,4BAeE;IAMF,6BAA8B;IAI/B;;;;;;OAMG;IACH,iBAHa,GAAG,CAAC,MAAM,CAAC,CAKvB;IAcD,mBAPa,MAAM,EASlB;IAdD;;;;;;;OAOG;IACH,gBAHa,MAAM,CAKlB;IAMD;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,QAUhB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;;;;OAUG;IACH,oCAaC;IAED;;;;;;;;OAQG;IACH,iCASC;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;OAQG;IACH,kCAIC;IAED;;;;OAIG;IACH,gCAFW,MAAM,OAShB;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAmCC;IAED;;OAEG;IACH,yBAkBC;IAED;;OAEG;IACH,gCAcC;CACD;8BApW6B,+BAA+B;iCAE5B,wBAAwB"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAgBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,8CAgDC;IA9CA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IAOtB,4BAeE;IAMF,6BAA8B;IAI/B;;;;;;;OAOG;IACH,iBAJa,GAAG,CAAC,MAAM,CAAC,CAMvB;IAeD,mBARa,MAAM,EAUlB;IAfD;;;;;;;;OAQG;IACH,gBAJa,MAAM,CAMlB;IAMD;;;OAGG;IACH,cAKC;IAED;;;OAGG;IACH,8BAIC;IAED;;;;;;;;OAQG;IACH,kBAJW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,QAWhB;IAED;;;;;OAKG;IACH,6BAIC;IAED;;;;;;;;;;;OAWG;IACH,oCAaC;IAED;;;;;;;;;OASG;IACH,iCASC;IAED;;;;;;;;;;;OAWG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;;OASG;IACH,kCAIC;IAED;;;;;OAKG;IACH,gCAFW,MAAM,OAShB;IAED;;;;OAIG;IACH,yCAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,iCAmCC;IAED;;;OAGG;IACH,yBAkBC;IAED;;;OAGG;IACH,gCAcC;CACD;8BAvX6B,+BAA+B;iCAE5B,wBAAwB"}

package/build/video/texture/frametexture.d.ts

@@ -1,73 +1,3 @@
-/**
- * A GPU-resident texture holding a captured frame — the value returned by
- * {@link WebGLRenderer#toFrameTexture}. Its backing is a live `WebGLTexture`
- * that the renderer refreshes **in place** on each capture, so a shader that
- * has bound it once (via {@link ShaderEffect#setTexture}) keeps sampling the
- * latest frame with no re-bind.
- *
- * Not part of the public class surface: obtain instances from
- * `renderer.toFrameTexture()` and treat them as opaque {@link Texture2d}
- * values. The `isGPUResident` flag is the discriminant `setTexture` uses to
- * take its live-bind path (bind the existing handle) instead of uploading a
- * static copy.
- * @augments Texture2d
- * @ignore
- */
-export class FrameTexture extends Texture2d {
-    /**
-     * @param {WebGLRenderer} renderer - the owning renderer (for the GL context)
-     * @param {number} width - capture width in pixels
-     * @param {number} height - capture height in pixels
-     */
-    constructor(renderer: WebGLRenderer, width: number, height: number);
-    _renderer: WebGLRenderer;
-    /** @type {number} */
-    width: number;
-    /** @type {number} */
-    height: number;
-    /**
-     * the live backing texture, (re)filled by `renderer.toFrameTexture` and
-     * bound (never re-uploaded) by consumers
-     * @type {WebGLTexture|null}
-     */
-    glTexture: WebGLTexture | null;
-    /**
-     * marks this as a live GPU-resident source — see {@link ShaderEffect#setTexture}
-     * @type {boolean}
-     */
-    isGPUResident: boolean;
-    /**
-     * The opaque GPU-resident backing — itself.
-     * @returns {FrameTexture}
-     */
-    getTexture(): FrameTexture;
-}
-/**
- * The Canvas-renderer counterpart of {@link FrameTexture}: a captured frame
- * backed by an offscreen `<canvas>` copy of the drawing buffer, keeping the
- * `toFrameTexture` family renderer-complete. A drawable source (not
- * GPU-resident), so it flows through the normal image path; custom shaders
- * don't run under the Canvas renderer, so this exists for API parity and
- * CPU-side reuse (e.g. drawing the captured frame back onto the scene).
- * @augments Texture2d
- * @ignore
- */
-export class CanvasFrameTexture extends Texture2d {
-    /**
-     * @param {HTMLCanvasElement|OffscreenCanvas} canvas - the backing copy
-     */
-    constructor(canvas: HTMLCanvasElement | OffscreenCanvas);
-    /** @type {HTMLCanvasElement|OffscreenCanvas} */
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-    /** @type {number} */
-    width: number;
-    /** @type {number} */
-    height: number;
-    /**
-     * The backing canvas copy.
-     * @returns {HTMLCanvasElement|OffscreenCanvas}
-     */
-    getTexture(): HTMLCanvasElement | OffscreenCanvas;
-}
+
 import Texture2d from "./texture2d.ts";
 //# sourceMappingURL=frametexture.d.ts.map

package/build/video/texture/frametexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../src/video/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,SACb,MAAM,UACN,MAAM,EAoBhB;IAhBA,yBAAyB;IACzB,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB;;;;OAIG;IACH,WAFU,YAAY,GAAC,IAAI,CAEN;IACrB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAG1B;;;OAGG;IACH,cAFa,YAAY,CAIxB;CAaD;AAED;;;;;;;;;GASG;AACH;IACC;;OAEG;IACH,oBAFW,iBAAiB,GAAC,eAAe,EAU3C;IANA,gDAAgD;IAChD,QADW,iBAAiB,GAAC,eAAe,CACxB;IACpB,qBAAqB;IACrB,OADW,MAAM,CACQ;IACzB,qBAAqB;IACrB,QADW,MAAM,CACU;IAG5B;;;OAGG;IACH,cAFa,iBAAiB,GAAC,eAAe,CAI7C;CACD;sBA/FqB,gBAAgB"}
+{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../src/video/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,SACb,MAAM,UACN,MAAM,EAwBhB;IApBA;;;OAGG;IACH,yBAAyB;IACzB,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB;;;;OAIG;IACH,WAFU,YAAY,GAAC,IAAI,CAEN;IACrB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAG1B;;;OAGG;IACH,cAFa,YAAY,CAIxB;CAaD;AAED;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,oBAFW,iBAAiB,GAAC,eAAe,EAU3C;IANA,gDAAgD;IAChD,QADW,iBAAiB,GAAC,eAAe,CACxB;IACpB,qBAAqB;IACrB,OADW,MAAM,CACQ;IACzB,qBAAqB;IACrB,QADW,MAAM,CACU;IAG5B;;;OAGG;IACH,cAFa,iBAAiB,GAAC,eAAe,CAI7C;CACD;sBArGqB,gBAAgB"}

package/build/video/texture/noise_texture2d.d.ts

@@ -98,15 +98,6 @@ declare class NoiseTexture2d extends Texture2d {
     speed: number;
     /** the current animation time (third sampling axis) @type {number} */
     time: number;
-    /** the baked output canvas (reused across re-bakes) @type {HTMLCanvasElement|null} @ignore */
-    _canvas: HTMLCanvasElement | null;
-    /** reused ImageData scratch (avoids a per-bake allocation) @type {ImageData|null} @ignore */
-    _imageData: ImageData | null;
-    /** reused height-field scratch (avoids a per-bake allocation) @type {Float32Array|null} @ignore */
-    _heights: Float32Array | null;
-    /** content revision, bumped on every bake and stamped on the canvas so
-     * the renderer re-uploads the GPU texture when it changes @type {number} @ignore */
-    _version: number;
     /**
      * The current content revision, bumped on every {@link NoiseTexture2d#bake}.
      * Also stamped on the baked canvas (`getTexture().version`) so the renderer
@@ -132,40 +123,6 @@ declare class NoiseTexture2d extends Texture2d {
      * @returns {NoiseTexture2d} this texture for chaining
      */
     update(dt: number): NoiseTexture2d;
-    /**
-     * Raw noise sample at a texture pixel (2D, or 3D when animated). The time
-     * axis is divided by the noise frequency so that, after `getNoise3d` scales
-     * all coords by frequency, the field evolves at `speed` noise-units/second —
-     * decoupled from the spatial frequency (otherwise low-frequency textures
-     * would animate imperceptibly slowly).
-     * @ignore
-     */
-    _rawNoise(x: any, y: any): number;
-    /**
-     * x-axis seamless blend: in the right skirt band, cross-fade toward the
-     * wrapped (period-shifted) sample so the left and right edges meet.
-     * @ignore
-     */
-    _blendX(x: any, y: any, w: any, sk: any): any;
-    /**
-     * Sample the noise into a `[0, 1]` height field. When `seamless`, a skirt
-     * cross-fade near the far edges blends opposite edges so the texture tiles
-     * with a much-reduced seam.
-     * @returns {Float32Array} the per-pixel height field (length `width*height`)
-     * @ignore
-     */
-    _buildHeightField(): Float32Array;
-    /** @ignore */
-    _writeGrayscale(data: any, heights: any): void;
-    /** @ignore */
-    _writeColorRamp(data: any, heights: any): void;
-    /**
-     * Encode the height field as a tangent-space normal map (RGB), with screen-Y
-     * flipped to normal-map Y-up so it round-trips through the lit shader's
-     * `rgb * 2 - 1` decode. Neighbor samples wrap when `seamless`.
-     * @ignore
-     */
-    _writeNormalMap(data: any, heights: any): void;
     /**
      * @returns {HTMLCanvasElement} the baked texture canvas
      */

package/build/video/texture/noise_texture2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noise_texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/noise_texture2d.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAhBG;QAA0B,KAAK;QACL,MAAM;QACP,KAAK;QAEH,QAAQ;QACT,kBAAkB;QAEjB,MAAM;QACN,WAAW;QACZ,YAAY;QACV,SAAS;QACV,QAAQ;QAET,KAAK;KAEjC,EA4CA;IAxCA,mDAAmD;IACnD,OADyC,MAAM,CACb;IAClC,oDAAoD;IACpD,QAD0C,MAAM,CACZ;IACpC,0DAA0D;IAC1D,OADiD,KAAK,CAEiB;IACvE,gDAAgD;IAChD,UADqC,OAAO,CACF;IAC1C,2EAA2E;IAC3E,oBADiE,MAAM,CAItE;IACD,6CAA6C;IAC7C,QADkC,OAAO,CACH;IACtC,qEAAqE;IACrE,aAD0D,OAAO,CACjB;IAChD,yDAAyD;IACzD,cAD+C,MAAM,CACL;IAChD,2EAA2E;IAC3E,WAD0D,QAAQ,GAAC,IAAI,CAC5B;IAC3C,4EAA4E;IAC5E,UADiE,OAAO,CAC9B;IAC1C,iEAAiE;IACjE,OADuD,MAAM,CAC7B;IAChC,sEAAsE;IACtE,MAD4D,MAAM,CACrD;IAEb,8FAA8F;IAC9F,SAD4D,iBAAiB,GAAC,IAAI,CAC/D;IACnB,6FAA6F;IAC7F,YADmE,SAAS,GAAC,IAAI,CAC3D;IACtB,mGAAmG;IACnG,UADsE,YAAY,GAAC,IAAI,CACnE;IACpB;wFACoF;IACpF,UADkE,MAAM,CACvD;IAKlB;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,QAFa,cAAc,CAiC1B;IAED;;;;;;;;;OASG;IACH,WAHW,MAAM,GACJ,cAAc,CAQ1B;IAED;;;;;;;OAOG;IACH,kCAMC;IAED;;;;OAIG;IACH,8CAOC;IAED;;;;;;OAMG;IACH,qBAHa,YAAY,CA2CxB;IAED,cAAc;IACd,+CASC;IAED,cAAc;IACd,+CAWC;IAED;;;;;OAKG;IACH,+CA+BC;IAED;;OAEG;IACH,cAFa,iBAAiB,CAI7B;CAcD;sBA5VqB,gBAAgB;sBAFhB,qBAAqB"}
+{"version":3,"file":"noise_texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/noise_texture2d.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAhBG;QAA0B,KAAK;QACL,MAAM;QACP,KAAK;QAEH,QAAQ;QACT,kBAAkB;QAEjB,MAAM;QACN,WAAW;QACZ,YAAY;QACV,SAAS;QACV,QAAQ;QAET,KAAK;KAEjC,EAwDA;IApDA,mDAAmD;IACnD,OADyC,MAAM,CACb;IAClC,oDAAoD;IACpD,QAD0C,MAAM,CACZ;IACpC,0DAA0D;IAC1D,OADiD,KAAK,CAEiB;IACvE,gDAAgD;IAChD,UADqC,OAAO,CACF;IAC1C,2EAA2E;IAC3E,oBADiE,MAAM,CAItE;IACD,6CAA6C;IAC7C,QADkC,OAAO,CACH;IACtC,qEAAqE;IACrE,aAD0D,OAAO,CACjB;IAChD,yDAAyD;IACzD,cAD+C,MAAM,CACL;IAChD,2EAA2E;IAC3E,WAD0D,QAAQ,GAAC,IAAI,CAC5B;IAC3C,4EAA4E;IAC5E,UADiE,OAAO,CAC9B;IAC1C,iEAAiE;IACjE,OADuD,MAAM,CAC7B;IAChC,sEAAsE;IACtE,MAD4D,MAAM,CACrD;IAEb;;;;OAIG;IACH,SAJ2D,iBAAiB,GAAC,IAAI,CAI9D;IACnB;;;;OAIG;IACH,YAJkE,SAAS,GAAC,IAAI,CAI1D;IACtB;;;;OAIG;IACH,UAJqE,YAAY,GAAC,IAAI,CAIlE;IACpB;wFACoF;IACpF,UADkE,MAAM,CACvD;IAKlB;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,QAFa,cAAc,CAiC1B;IAED;;;;;;;;;OASG;IACH,WAHW,MAAM,GACJ,cAAc,CAQ1B;IAED;;;;;;;;OAQG;IACH,kCAMC;IAED;;;;;OAKG;IACH,8CAOC;IAED;;;;;;;OAOG;IACH,qBAJa,YAAY,CA4CxB;IAED;;;OAGG;IACH,+CASC;IAED;;;OAGG;IACH,+CAWC;IAED;;;;;;OAMG;IACH,+CA+BC;IAED;;OAEG;IACH,cAFa,iBAAiB,CAI7B;CAcD;sBAlXqB,gBAAgB;sBAFhB,qBAAqB"}

package/build/video/texture/parser/aseprite.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseAseprite(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=aseprite.d.ts.map

package/build/video/texture/parser/aseprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAsFlB"}
+{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,oCANW,MAAM,gBACN,YAAY,GACV,MAAM,CAuFlB"}

package/build/video/texture/parser/spritesheet.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseSpriteSheet(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=spritesheet.d.ts.map

package/build/video/texture/parser/spritesheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spritesheet.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/spritesheet.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,uCALW,MAAM,gBACN,YAAY,GACV,MAAM,CA2ElB"}
+{"version":3,"file":"spritesheet.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/spritesheet.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uCANW,MAAM,gBACN,YAAY,GACV,MAAM,CA4ElB"}

package/build/video/texture/parser/texturepacker.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseTexturePacker(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=texturepacker.d.ts.map

package/build/video/texture/parser/texturepacker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texturepacker.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/texturepacker.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,yCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAwDlB"}
+{"version":3,"file":"texturepacker.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/texturepacker.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,yCANW,MAAM,gBACN,YAAY,GACV,MAAM,CAyDlB"}

package/build/video/texture/resource.d.ts

@@ -52,13 +52,6 @@ export class TextureResource {
     filter: number | undefined;
     sources: Map<string, this>;
     activeAtlas: string;
-    /**
-     * Returns the upload "source" the batcher hands to `createTexture2D`.
-     * For a resource this is the resource itself — `createTexture2D`
-     * dispatches to `resource.upload(context, target)`.
-     * @ignore
-     */
-    getTexture(): this;
     /**
      * Issue the backend-specific upload call (`gl.texImage2D` on WebGL,
      * the WebGPU equivalent once that renderer lands) that places this
@@ -115,7 +108,5 @@ export class BufferTextureResource extends TextureResource {
     data: ArrayBufferView;
     /** @type {string} */
     format: string;
-    /** @ignore */
-    upload(context: any, target: any): void;
 }
 //# sourceMappingURL=resource.d.ts.map

package/build/video/texture/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/video/texture/resource.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;;;;;OAQG;IACH,qEAPG;QAAwB,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;KAElC,EAsBA;IAdA,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,sBAAsB;IACtB,oBADW,OAAO,CAC0B;IAC5C,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,+BAA+B;IAC/B,QADW,MAAM,GAAC,SAAS,CACP;IAGpB,2BAA2C;IAC3C,oBAA4B;IAG7B;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IAEH,gBANW,qBAAqB,GAAC,sBAAsB,UAE5C,MAAM,QAMhB;CACD;AAED;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,eAAe,WAIvB;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;QACI,MAAM;KAM5C,EAOA;IAJA,8BAA8B;IAC9B,MADW,eAAe,CACV;IAChB,qBAAqB;IACrB,QADW,MAAM,CACsB;IAGxC,cAAc;IACd,wCAoCC;CACD"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/video/texture/resource.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;;;;;OAQG;IACH,qEAPG;QAAwB,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;KAElC,EAsBA;IAdA,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,sBAAsB;IACtB,oBADW,OAAO,CAC0B;IAC5C,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,+BAA+B;IAC/B,QADW,MAAM,GAAC,SAAS,CACP;IAGpB,2BAA2C;IAC3C,oBAA4B;IAG7B;;;;;;OAMG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IAEH,gBANW,qBAAqB,GAAC,sBAAsB,UAE5C,MAAM,QAMhB;CACD;AAED;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,eAAe,WAIvB;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;QACI,MAAM;KAM5C,EAOA;IAJA,8BAA8B;IAC9B,MADW,eAAe,CACV;IAChB,qBAAqB;IACrB,QADW,MAAM,CACsB;IAGxC;;;OAGG;IACH,wCAoCC;CACD"}

package/build/video/texture/texture2d.d.ts

@@ -1,8 +1,3 @@
-/**
- * Compile-time-only brand key; no runtime value can hold it.
- * @ignore
- */
-declare const gpuResidentBrand: unique symbol;
 /**
  * An opaque, GPU-resident texture backing — the source a GPU-resident
  * {@link Texture2d} resolves to (for example the framebuffer copy
@@ -17,11 +12,6 @@ declare const gpuResidentBrand: unique symbol;
  * {@link Texture2dSource} (and {@link Texture2d#getTexture}) honestly typed.
  */
 export interface GPUResidentTexture {
-    /**
-     * Phantom nominal brand — never present at runtime.
-     * @ignore
-     */
-    readonly [gpuResidentBrand]: true;
 }
 /**
  * The backing source a {@link Texture2d} resolves to through
@@ -79,5 +69,4 @@ export default abstract class Texture2d {
      */
     destroy(): void;
 }
-export {};
 //# sourceMappingURL=texture2d.d.ts.map

package/build/video/texture/texture2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/texture2d.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,SAAS;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,IAAI,eAAe;IAEtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}
+{"version":3,"file":"texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/texture2d.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;CAOlC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,SAAS;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,IAAI,eAAe;IAEtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/build/video/utils/autodetect.d.ts

@@ -1,8 +1,4 @@
-/**
- * Auto-detect the best renderer to use
- * @ignore
- */
-export function autoDetectRenderer(options: any): CanvasRenderer | WebGLRenderer;
+
 import CanvasRenderer from "../canvas/canvas_renderer";
 import WebGLRenderer from "../webgl/webgl_renderer";
 //# sourceMappingURL=autodetect.d.ts.map

package/build/video/utils/autodetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,iFAeC;2BApD0B,2BAA2B;0BAC5B,yBAAyB"}
+{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,iFAeC;2BArD0B,2BAA2B;0BAC5B,yBAAyB"}

package/build/video/webgl/batchers/batcher.d.ts

@@ -115,62 +115,7 @@ export class WebGLBatcher extends Batcher {
      * @type {boolean}
      */
     useIndexBuffer: boolean | undefined;
-    /**
-     * the GL vertex buffer object (own buffer for indexed batchers, null for shared)
-     * @type {WebGLBuffer|null}
-     * @ignore
-     */
-    glVertexBuffer: WebGLBuffer | null | undefined;
-    /**
-     * the dynamic index buffer (only for indexed batchers)
-     * @type {WebGLIndexBuffer|null}
-     * @ignore
-     */
-    indexBuffer: WebGLIndexBuffer | null | undefined;
-    /**
-     * The GL buffer this batcher uploads its vertex data into: its own
-     * buffer for indexed (mesh-family) batchers, otherwise the renderer's
-     * shared one.
-     * @type {WebGLBuffer}
-     * @ignore
-     */
-    get uploadBuffer(): WebGLBuffer;
-    /**
-     * (Re)build this batcher's {@link WebGLVertexState} — the frozen vertex
-     * buffer layout (`attributes` + `stride`) realized as a GL vertex array
-     * object bound to this batcher's upload buffer and, for indexed
-     * batchers, its index buffer.
-     *
-     * Every shader hosted by this batcher must declare a prefix of that
-     * layout, in layout order (see {@link validateShaderLocations}) — the
-     * locations are frozen here at the default shader's mapping.
-     * @ignore
-     */
-    createVertexState(): void;
-    /**
-     * Validate (once per shader) that a hosted shader's attribute locations
-     * match this batcher's frozen vertex state. The engine's analogue of
-     * WebGPU's pipeline-creation validation: locations are bound in vertex
-     * source declaration order, so every shader hosted by this batcher must
-     * declare a prefix of the batcher's attribute layout, in layout order.
-     * A mismatched shader silently reads wrong vertex data — warn loudly.
-     * @ignore
-     */
-    validateShaderLocations(shader: any): void;
     validatedShaders: WeakSet<object> | undefined;
-    /**
-     * Ensure the draw about to be recorded runs on THIS batcher's program.
-     * Normally `bind()` guaranteed that, but an `ONCONTEXT_RESTORED`
-     * emission recompiles every live GLShader — each replaying its uniform
-     * snapshot on its OWN program — leaving whichever recompiled last
-     * really bound while the renderer's cache still named another. The
-     * renderer invalidates its program cache on that event, so this
-     * pointer compare re-issues `useProgram` exactly when the drift
-     * happened and costs two loads otherwise. Called by every flush path
-     * (the base and the quad override).
-     * @ignore
-     */
-    syncProgram(): void;
     /**
      * Select the shader to use for compositing
      * @see GLShader

package/build/video/webgl/batchers/batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAgBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,QA+IA;IAzIA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAoY/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IAxXC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAgBxB;;;;;;OAMG;IACH,oBAHU,WAAW,CAKpB;IAED;;;;;;;;;;OAUG;IACH,0BAiBC;IAkGD;;;;;;;;OAQG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;OAWG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAiJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBAhxB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAkBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,QAiJA;IA3IA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IA4Y/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IAhYC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;;OAKG;IACH,+CAA0B;IAE1B;;;;;OAKG;IACH,iDAAuB;IAgBxB;;;;;;;OAOG;IACH,oBAJU,WAAW,CAMpB;IAED;;;;;;;;;;;OAWG;IACH,0BAiBC;IAoGD;;;;;;;;;OASG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;;OAYG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAoJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBA7xB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts

@@ -12,20 +12,6 @@
  */
 export default class LitMeshBatcher extends MeshBatcher {
     lightBlock: UniformBlock | undefined;
-    _lightBlockProgram: any;
-    /**
-     * Point the active program's `Light3dBlock` at our uniform buffer.
-     *
-     * A block binding is program state, so it has to be re-established
-     * whenever the program changes: a context restore recompiles it, `init`
-     * re-runs on reset, and `useShader` can swap one in without a batcher
-     * transition. Comparing against the program we last bound covers all
-     * three — a pointer compare in the steady state.
-     * @ignore
-     */
-    _bindLightBlock(): void;
-    /** push the 12-float lit vertex, appending the mesh's world-space normal. @ignore */
-    _pushVertex(vertexData: any, x: any, y: any, z: any, u: any, v: any, color: any, mesh: any, i3: any): void;
 }
 import MeshBatcher from "./mesh_batcher.js";
 import UniformBlock from "../buffer/uniformblock.js";

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH;IAuBE,qCAIC;IACD,wBAA8B;IAO/B;;;;;;;;;OASG;IACH,wBAQC;IAyCD,qFAAqF;IACrF,2GAaC;CA4DD;wBApMuB,mBAAmB;yBAPlB,2BAA2B"}
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH;IA6BE,qCAIC;IACD;;;OAGG;IACH,wBAA8B;IAO/B;;;;;;;;;;OAUG;IACH,wBAQC;IAsDD;;;;OAIG;IACH,2GAaC;CA8DD;wBAlOuB,mBAAmB;yBAPlB,2BAA2B"}

package/build/video/webgl/batchers/lit_quad_batcher.d.ts

@@ -18,54 +18,8 @@
  * @category Rendering
  */
 export default class LitQuadBatcher extends QuadBatcher {
-    /**
-     * normal-map texture per color slot — keyed by the same unit index as
-     * `boundTextures`. Used by `addQuad` to detect when a normal-map slot
-     * needs (re-)uploading, mirroring the color-texture cache.
-     * @type {Array<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null>}
-     * @ignore
-     */
-    boundNormalMaps: (ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null)[] | undefined;
-    /**
-     * Per-slot content `version` of the normal map currently bound there. An
-     * animated source keeps a stable canvas reference across re-bakes but
-     * bumps its `version`, so `addQuad` compares this (not just the reference)
-     * to know when to re-bind/re-upload. `-1` = nothing bound.
-     * @type {number[]}
-     * @ignore
-     */
-    boundNormalVersions: number[] | undefined;
     normalStore: WebGLTextureStore | undefined;
-    /**
-     * Which slot in the shared pool each normal-map source currently holds.
-     * Normal maps are not in the color `TextureCache` (they are raw sources
-     * with their own GL textures), so their unit assignment is tracked here
-     * while the unit itself comes from the same allocator the colors use.
-     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, number>}
-     * @ignore
-     */
-    normalUnits: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, number> | undefined;
-    _cacheEpoch: any;
-    _lightCount: number | undefined;
-    _maxLights: number | undefined;
     lightBlock: UniformBlock | undefined;
-    _lightBlockProgram: any;
-    _onTexture2dDestroyed: ((source: any) => void) | null | undefined;
-    /**
-     * Point the active program's `Light2dBlock` at our uniform buffer.
-     *
-     * A block binding is *program* state, and the program can change under us
-     * in three ways: a context restore recompiles it, `setBatcher` can host a
-     * {@link ShaderEffect} on this batcher, and `init` re-runs on reset. Rather
-     * than hook each of those, re-bind whenever the program is not the one we
-     * last bound — a pointer compare per `bind`, and self-healing.
-     *
-     * A hosted `ShaderEffect` is a plain unlit ES 1.00 program with no light
-     * block, so `bindTo` reports failure and we simply record it, leaving the
-     * next real lit program to bind normally.
-     * @ignore
-     */
-    _bindLightBlock(): void;
     /**
      * Release the cached GL texture uploaded for the given normal-map source
      * and clear any slot bookkeeping referencing it. Safe to call for images
@@ -112,32 +66,6 @@ export default class LitQuadBatcher extends QuadBatcher {
      * @param {number} unit - GL texture unit the normal map is resolved to
      */
     bindNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
-    /**
-     * Drop a normal map's slot claim and hand the unit back to the allocator.
-     *
-     * A normal map claims its unit through `allocateTextureUnit()`, which has no
-     * key to release against — so without this the unit stayed marked used for
-     * the rest of the session and the pool drained monotonically as normal maps
-     * came and went, until something forced a full reset.
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
-     * @ignore
-     */
-    releaseNormalUnit(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): void;
-    /**
-     * Resolve a normal-map source to its slot in the shared pool, uploading and
-     * binding it if it is not already resident.
-     *
-     * A version-only bump (an animated source re-baking into the same canvas
-     * reference) re-uploads into the same GL handle and needs no flush —
-     * `version` only changes between frames, and the batch is flushed at every
-     * frame/camera boundary, so no in-flight vertex references stale content.
-     * A DIFFERENT source landing on a live slot does need the pending vertices
-     * drawn first.
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} normalMap - the source
-     * @returns {number} the slot to write into `aNormalTextureId`
-     * @ignore
-     */
-    resolveNormalUnit(normalMap: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): number;
     /**
      * Add a textured quad with optional paired normal map.
      * @param {TextureAtlas} texture - Source texture atlas

package/build/video/webgl/batchers/lit_quad_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA8DE;;;;;;OAMG;IACH,6GAAiD;IAEjD;;;;;;;OAOG;IACH,0CAAmD;IAmBnD,2CAAiD;IAEjD;;;;;;;OAOG;IACH,2GAA4B;IAC5B,iBAAoB;IAEpB,gCAAoB;IACpB,+BAA4B;IAkB5B,qCAIC;IACD,wBAA8B;IAW7B,kEAEC;IAoCH;;;;;;;;;;;;;OAaG;IACH,wBAQC;IAED;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IA8ED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAMA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAqChB;IAED;;;;;;;;;OASG;IACH,yBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IAED;;;;;;;;;;;;;OAaG;IACH,6BAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAsClB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAsIjD;CA+DD;wBA3qBuB,mBAAmB;kCADT,qBAAqB;yBAT9B,2BAA2B;kCAcrB,0BAA0B"}
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA+DE;;;;;;;OAOG;IACH,6GAAiD;IAEjD;;;;;;;;OAQG;IACH,0CAAmD;IAoBnD,2CAAiD;IAEjD;;;;;;;;OAQG;IACH,2GAA4B;IAC5B;;;OAGG;IACH,iBAAoB;IAEpB;;;OAGG;IACH,gCAAoB;IACpB;;;OAGG;IACH,+BAA4B;IAuB5B,qCAIC;IACD;;;OAGG;IACH,wBAA8B;IAW7B,kEAEC;IAsCH;;;;;;;;;;;;;;OAcG;IACH,wBAQC;IAED;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IAiFD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAMA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAqChB;IAED;;;;;;;;;;OAUG;IACH,yBAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAcxE;IAED;;;;;;;;;;;;;;OAcG;IACH,6BALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAuClB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAsIjD;CA+DD;wBA7sBuB,mBAAmB;kCADT,qBAAqB;yBAT9B,2BAA2B;kCAcrB,0BAA0B"}