melonjs 20.3.0 → 20.5.0

package/build/video/gpu/texturestore.d.ts

@@ -1,139 +1,2 @@
-/**
- * Backend-neutral texture residency.
- *
- * There are two separate questions about a texture, and conflating them is
- * what makes a GPU renderer re-upload work it already has:
- *
- * - **which slot is it in, for this draw?** — transient, per-batch, bounded by
- *   the shader's sampler count. That is {@link TextureSlotTable}.
- * - **does it exist on the GPU, and is its content current?** — persistent,
- *   per-source, bounded by disposal. That is this class.
- *
- * The WebGL backend used to answer both with one field (`boundTextures[unit]`),
- * so dropping a slot assignment destroyed the texture handle and the next draw
- * rebuilt it from scratch — a full re-upload and mip regeneration per quad,
- * once past the batching limit.
- *
- * This class owns the source → record index, the reuse-or-upload decision, and
- * the lifetime bookkeeping. It touches no GL or WebGPU API: each backend
- * supplies `onCreate` / `onUpload` / `onDestroy`, exactly as the slot table
- * takes its binding through callbacks. That keeps the decision logic identical
- * on both backends and testable without a device.
- * @ignore
- */
-export class TextureStore {
-    /**
-     * @param {object} [options] - store configuration
-     * @param {Function} [options.onCreate] - `(source, options) => handle`, allocate
-     * the backing GPU texture for a source seen for the first time
-     * @param {Function} [options.onUpload] - `(handle, source, record, options) => handle`,
-     * push the source's current content. May return a *replacement* handle when
-     * the shape changed and the old one cannot be respecified (immutable
-     * storage); returning nothing keeps the existing handle.
-     * @param {Function} [options.onDestroy] - `(handle, source)`, release the
-     * GPU texture. Called exactly once per handle.
-     * @ignore
-     */
-    constructor({ onCreate, onUpload, onDestroy }?: {
-        onCreate?: Function | undefined;
-        onUpload?: Function | undefined;
-        onDestroy?: Function | undefined;
-    });
-    /** @type {Map<object, {handle: *, version: number, generation: number}>} */
-    records: Map<object, {
-        handle: any;
-        version: number;
-        generation: number;
-    }>;
-    /**
-     * Allocate the backing GPU texture for a source seen for the first time.
-     * @param {object} source - the image/canvas/resource
-     * @param {object} options - the resolve options
-     * @returns {*} the new handle
-     * @ignore
-     */
-    onCreate(source: object, options: object): any;
-    /**
-     * Push the source's current content. May return a REPLACEMENT handle when
-     * the shape changed and the old one cannot be respecified.
-     * @param {*} handle - the existing handle
-     * @param {object} source - the image/canvas/resource
-     * @param {object} record - the resident record
-     * @param {object} options - the resolve options
-     * @returns {*} a replacement handle, or nothing to keep the existing one
-     * @ignore
-     */
-    onUpload(handle: any, source: object, record: object, options: object): any;
-    /**
-     * Release a GPU texture. Called exactly once per handle.
-     * @param {*} handle - the handle to release
-     * @param {object} source - the source it belonged to
-     * @ignore
-     */
-    onDestroy(handle: any, source: object): void;
-    generation: number;
-    /**
-     * how many sources are currently resident
-     * @returns {number} the record count
-     * @ignore
-     */
-    get size(): number;
-    /**
-     * The live record for a source, uploading only when it is genuinely needed:
-     * the source has never been seen, its content changed, its handle predates
-     * the current context, or the caller forced it.
-     *
-     * A texture that merely moved to a different slot is NOT a reason to upload
-     * — that is the whole point of separating residency from slot assignment.
-     * @param {object} source - the image/canvas/resource backing the texture
-     * @param {object} [options] - resolution options
-     * @param {number} [options.version=0] - the source's content revision; a
-     * change from the recorded value forces a re-upload
-     * @param {boolean} [options.force=false] - re-upload regardless
-     * @returns {{handle: *, version: number, generation: number, uploaded: boolean}}
-     * the record, with `uploaded` reporting whether this call did GPU work
-     * @ignore
-     */
-    getResidentRecord(source: object, options?: {
-        version?: number | undefined;
-        force?: boolean | undefined;
-    }): {
-        handle: any;
-        version: number;
-        generation: number;
-        uploaded: boolean;
-    };
-    /**
-     * The record for a source without resolving one, for callers that must not
-     * trigger GPU work (bookkeeping, debug, invalidation checks).
-     * @param {object} source - the source to look up
-     * @returns {object|undefined} the record, or `undefined`
-     * @ignore
-     */
-    peek(source: object): object | undefined;
-    /**
-     * Release the GPU texture for one source. Driven by the source going away
-     * — never by a slot being reassigned, which is exactly the coupling this
-     * class exists to break.
-     * @param {object} source - the disposed source
-     * @returns {boolean} whether a record was held
-     * @ignore
-     */
-    destroyTexture(source: object): boolean;
-    /**
-     * Drop every record and bump the generation. Called on context or device
-     * loss.
-     *
-     * This CLEARS the store in place — callers must never respond to a restore
-     * by constructing a replacement store. Doing so orphans every handle the
-     * old one was tracking, so the *second* loss leaks everything it had
-     * accumulated since the first. Both WebGL batchers re-run `init()` on
-     * restore, which is precisely how that mistake gets made here.
-     * @param {boolean} [destroy=false] - whether to release the handles first.
-     * Leave `false` for a lost context (the GPU objects are already gone);
-     * pass `true` for an orderly teardown.
-     * @ignore
-     */
-    releaseAll(destroy?: boolean): void;
-}
+
 //# sourceMappingURL=texturestore.d.ts.map

package/build/video/gpu/texturestore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texturestore.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/texturestore.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACC;;;;;;;;;;;OAWG;IACH,gDAVG;QAA2B,QAAQ;QAER,QAAQ;QAIR,SAAS;KAEpC,EAuBF;IApBA,4EAA4E;IAC5E,SADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAChD;IAqBzB;;;;;;OAMG;IACH,iBALW,MAAM,WACN,MAAM,GACJ,GAAC,CAOb;IAED;;;;;;;;;OASG;IACH,iBAPW,GAAC,UACD,MAAM,UACN,MAAM,WACN,MAAM,GACJ,GAAC,CASb;IAED;;;;;OAKG;IACH,kBAJW,GAAC,UACD,MAAM,QAMhB;IA3CA,mBAAmB;IA6CpB;;;;OAIG;IACH,YAHa,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BATW,MAAM,YAEd;QAAyB,OAAO;QAEN,KAAK;KAC/B,GAAU;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,CAqC/E;IAED;;;;;;OAMG;IACH,aAJW,MAAM,GACJ,MAAM,GAAC,SAAS,CAK5B;IAED;;;;;;;OAOG;IACH,uBAJW,MAAM,GACJ,OAAO,CAanB;IAED;;;;;;;;;;;;;OAaG;IACH,qBALW,OAAO,QAejB;CACD"}
+{"version":3,"file":"texturestore.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/texturestore.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,gDAXG;QAA2B,QAAQ;QAER,QAAQ;QAIR,SAAS;KAEpC,EAwBF;IApBA,4EAA4E;IAC5E,SADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAChD;IAqBzB;;;;;;;OAOG;IACH,iBANW,MAAM,WACN,MAAM,GACJ,GAAC,CAQb;IAED;;;;;;;;;;OAUG;IACH,iBARW,GAAC,UACD,MAAM,UACN,MAAM,WACN,MAAM,GACJ,GAAC,CAUb;IAED;;;;;;OAMG;IACH,kBALW,GAAC,UACD,MAAM,QAOhB;IA9CA,mBAAmB;IAgDpB;;;;;OAKG;IACH,YAJa,MAAM,CAMlB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAVW,MAAM,YAEd;QAAyB,OAAO;QAEN,KAAK;KAC/B,GAAU;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,CAsC/E;IAED;;;;;;;OAOG;IACH,aALW,MAAM,GACJ,MAAM,GAAC,SAAS,CAM5B;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,qBANW,OAAO,QAgBjB;CACD"}

package/build/video/gpu/topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uFAMQ,CAAC;AAgBzC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE9D"}
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uFAMQ,CAAC;AAiBzC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE9D"}

package/build/video/gpu/vertexformat.d.ts

@@ -18,11 +18,6 @@
  * import it without pulling in the WebGL layer.
  * @see {@link Batcher#addAttribute}
  */
-/**
- * The scalar component type underlying a {@link VertexFormat}.
- * @ignore
- */
-export type VertexScalar = "float32" | "uint8" | "sint8" | "unorm8" | "snorm8" | "uint16" | "sint16" | "unorm16" | "snorm16" | "uint32" | "sint32";
 /**
  * A vertex attribute format: component type and count.
  *
@@ -33,29 +28,6 @@ export type VertexScalar = "float32" | "uint8" | "sint8" | "unorm8" | "snorm8" |
  * indefinitely.
  */
 export type VertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | "uint8" | "uint8x2" | "uint8x4" | "sint8" | "sint8x2" | "sint8x4" | "unorm8" | "unorm8x2" | "unorm8x4" | "snorm8" | "snorm8x2" | "snorm8x4" | "uint16" | "uint16x2" | "uint16x4" | "sint16" | "sint16x2" | "sint16x4" | "unorm16" | "unorm16x2" | "unorm16x4" | "snorm16" | "snorm16x2" | "snorm16x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4";
-/**
- * What a {@link VertexFormat} resolves to.
- * @ignore
- */
-export interface VertexFormatInfo {
-    /** number of components (1, 2, 3 or 4) */
-    components: 1 | 2 | 3 | 4;
-    /** total size of the attribute in bytes */
-    bytes: number;
-    /** whether integer values are scaled into `[0, 1]` / `[-1, 1]` when read by a shader */
-    normalized: boolean;
-    /** the underlying scalar type */
-    scalar: VertexScalar;
-}
-/**
- * Every supported format, resolved.
- *
- * `bytes` is computed as `components × scalar size`, which is the same
- * arithmetic the GL-enum path has always used — so a layout expressed either
- * way produces an identical stride.
- * @ignore
- */
-export declare const VERTEX_FORMATS: Record<VertexFormat, VertexFormatInfo>;
 /**
  * Whether a value is a supported vertex format name.
  * @param value - the value to test

package/build/video/gpu/vertexformat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/vertexformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAErB,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GAEX,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GAET,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAEd;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,0CAA0C;IAC1C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,UAAU,EAAE,OAAO,CAAC;IACpB,iCAAiC;IACjC,MAAM,EAAE,YAAY,CAAC;CACrB;AA0DD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,gBAAgB,CA0CjE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAS1E"}
+{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/vertexformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoBH;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAErB,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GAEX,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GAET,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAkId;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAS1E"}

package/build/video/gradient.d.ts

@@ -9,55 +9,7 @@ export class Gradient {
      * @param {number[]} coords - gradient coordinates [x0, y0, x1, y1] for linear, [x0, y0, r0, x1, y1, r1] for radial
      */
     constructor(type: "linear" | "radial", coords: number[]);
-    /**
-     * gradient type
-     * @type {"linear"|"radial"}
-     */
-    /** @ignore */
-    _id: number;
     type: "linear" | "radial";
-    /**
-     * gradient coordinates
-     * @type {number[]}
-     * @ignore
-     */
-    coords: number[];
-    /**
-     * color stops
-     * @type {Array<{offset: number, color: string}>}
-     * @ignore
-     */
-    colorStops: Array<{
-        offset: number;
-        color: string;
-    }>;
-    /**
-     * cached canvas gradient (for Canvas renderer)
-     * @type {CanvasGradient|undefined}
-     * @ignore
-     */
-    _canvasGradient: CanvasGradient | undefined;
-    /**
-     * cached gradient render target (for WebGL renderer)
-     * @type {CanvasRenderTarget|undefined}
-     * @ignore
-     */
-    _renderTarget: CanvasRenderTarget | undefined;
-    /**
-     * whether the gradient needs to be regenerated
-     * @type {boolean}
-     * @ignore
-     */
-    _dirty: boolean;
-    /**
-     * cached parsed Color objects for sampling (lazily built)
-     * @type {{offset: number, color: Color}[]|null}
-     * @ignore
-     */
-    _parsedStops: {
-        offset: number;
-        color: Color;
-    }[] | null;
     /**
      * Add a color stop to the gradient.
      * @param {number} offset - value between 0.0 and 1.0
@@ -70,33 +22,24 @@ export class Gradient {
      */
     addColorStop(offset: number, color: Color | string): Gradient;
     /**
-     * Get or create a native CanvasGradient for use with a 2D context.
+     * Get or create a native `CanvasGradient` for use with a 2D context.
+     *
+     * This is the one to reach for when baking a gradient into your own
+     * canvas — it hands back a value for `ctx.fillStyle` and touches no
+     * shared state, so two callers cannot clobber each other.
+     *
+     * The result is cached and reused until a stop changes.
      * @param {CanvasRenderingContext2D} context - the 2D context to create the gradient on
-     * @returns {CanvasGradient}
-     * @ignore
+     * @returns {CanvasGradient} a native gradient bound to that context
+     * @example
+     * // bake a gradient into a standalone canvas
+     * const c = document.createElement("canvas");
+     * c.width = 64; c.height = 64;
+     * const ctx = c.getContext("2d");
+     * ctx.fillStyle = myGradient.toCanvasGradient(ctx);
+     * ctx.fillRect(0, 0, 64, 64);
      */
     toCanvasGradient(context: CanvasRenderingContext2D): CanvasGradient;
-    /**
-     * Render the gradient into the fixed-resolution shared bake target for
-     * the given draw rect. Uses the original gradient coordinates so the
-     * result matches Canvas 2D behavior. Rects larger than the bake target
-     * are rasterized scaled-down; the destination quad stretches them back,
-     * which is visually equivalent (linear stop interpolation × linear
-     * texture filtering). The returned `width`/`height` describe the region
-     * of the canvas the caller must use as the drawImage SOURCE rect.
-     * @param {CanvasRenderer|WebGLRenderer} renderer - the active renderer (used to invalidate the GPU texture)
-     * @param {number} x - draw rect x
-     * @param {number} y - draw rect y
-     * @param {number} width - draw rect width
-     * @param {number} height - draw rect height
-     * @returns {{canvas: HTMLCanvasElement|OffscreenCanvas, width: number, height: number}} the shared gradient canvas + the used source-rect size
-     * @ignore
-     */
-    toCanvas(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, width: number, height: number): {
-        canvas: HTMLCanvasElement | OffscreenCanvas;
-        width: number;
-        height: number;
-    };
     /**
      * Get the interpolated color at a given position along the gradient.
      * Useful for procedural effects like trails that need per-segment colors.
@@ -110,11 +53,6 @@ export class Gradient {
      * gradient.getColorAt(0.5, myColor); // myColor is now purple
      */
     getColorAt(position: number, out: Color): Color;
-    /**
-     * Build the parsed Color cache from colorStops strings.
-     * @ignore
-     */
-    _buildParsedStops(): void;
     /**
      * Release pooled resources held by this gradient.
      */

package/build/video/gradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EAqDlB;IAlDA;;;OAGG;IACH,cAAc;IACd,YAA2B;IAE3B,0BAAgB;IAEhB;;;;OAIG;IACH,QAHU,MAAM,EAAE,CAGE;IAEpB;;;;OAIG;IACH,YAHU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAG5B;IAEpB;;;;OAIG;IACH,iBAHU,cAAc,GAAC,SAAS,CAGF;IAEhC;;;;OAIG;IACH,eAHU,kBAAkB,GAAC,SAAS,CAGR;IAE9B;;;;OAIG;IACH,QAHU,OAAO,CAGC;IAElB;;;;OAIG;IACH,cAHU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAGvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;OAKG;IACH,0BAJW,wBAAwB,GACtB,cAAc,CAiC1B;IAED;;;;;;;;;;;;;;;OAeG;IACH,mBARW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ;QAAC,MAAM,EAAE,iBAAiB,GAAC,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAwFtF;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;OAGG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;+BA1V8B,sCAAsC;2BAF7C,kBAAkB"}
+{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AAmCA;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EA8DlB;IA3DA;;;OAGG;IACH;;;OAGG;IACH,YAA2B;IAE3B,0BAAgB;IAEhB;;;;;OAKG;IACH,QAJU,MAAM,EAAE,CAIE;IAEpB;;;;;OAKG;IACH,YAJU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAI5B;IAEpB;;;;;OAKG;IACH,iBAJU,cAAc,GAAC,SAAS,CAIF;IAEhC;;;;;OAKG;IACH,eAJU,kBAAkB,GAAC,SAAS,CAIR;IAE9B;;;;;OAKG;IACH,QAJU,OAAO,CAIC;IAElB;;;;;OAKG;IACH,cAJU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAIvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0BAVW,wBAAwB,GACtB,cAAc,CAuC1B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBATW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ;QAAC,MAAM,EAAE,iBAAiB,GAAC,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAyFtF;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;;OAIG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;+BAvX8B,sCAAsC;2BAF7C,kBAAkB"}

package/build/video/renderer.d.ts

@@ -1,15 +1,3 @@
-/**
- * @import RenderTargetPool from "./rendertarget/render_target_pool.js";
- */
-/**
- * @import {Rect} from "./../geometries/rectangle.ts";
- * @import {RoundRect} from "./../geometries/roundrect.ts";
- * @import {Polygon} from "../geometries/polygon.ts";
- * @import {Line} from "./../geometries/line.ts";
- * @import {Ellipse} from "./../geometries/ellipse.ts";
- * @import {Bounds} from "./../physics/bounds.ts";
- * @import {default as Texture2d} from "./texture/texture2d.ts";
- */
 /**
  * a base renderer object
  * @category Rendering
@@ -49,7 +37,6 @@ declare class Renderer {
     constructor(options?: ApplicationSettings);
     /**
      * The renderer renderTarget
-     * @name renderTarget
      * @type {CanvasRenderTarget}
      */
     renderTarget: CanvasRenderTarget;
@@ -83,21 +70,6 @@ declare class Renderer {
      * @type {string|undefined}
      */
     GPURenderer: string | undefined;
-    /**
-     * an optional custom shader to use instead of the default one.
-     * Set by a renderable's preDraw when a shader is assigned.
-     * (GPU renderers only; ignored by Canvas renderer)
-     * @type {GLShader|ShaderEffect|undefined}
-     * @ignore
-     */
-    customShader: GLShader | ShaderEffect | undefined;
-    /**
-     * The render target pool for post-effect processing (ping-pong FBOs).
-     * Initialized by GPU renderers (WebGL, WebGPU). Null on Canvas renderer.
-     * @type {RenderTargetPool|null}
-     * @ignore
-     */
-    _renderTargetPool: RenderTargetPool | null;
     /**
      * The Path2D instance used by the renderer to draw primitives
      * @type {Path2D}
@@ -200,10 +172,6 @@ declare class Renderer {
      * @default 1
      */
     lineWidth: number;
-    /**
-     * @ignore
-     */
-    maskLevel: number;
     projectionMatrix: Matrix3d;
     uvOffset: number;
     /**
@@ -273,41 +241,31 @@ declare class Renderer {
      */
     flush(): void;
     /**
-     * Hold one ground shadow ({@link Mesh#castGroundShadow}) back until the end
-     * of the mesh pass (#1515).
+     * Run the transparent pass: draw everything the CURRENT render target has
+     * queued since its last drain, back-to-front, then empty that queue.
      *
-     * A blob shadow deliberately writes no depth, so that two overlapping at
-     * one ground height blend instead of fighting. The price of that choice is
-     * that it leaves nothing in the depth buffer to defend itself with: any
-     * opaque mesh drawn afterwards simply paints over it. The ground plane is
-     * exactly that mesh whenever it sorts after the props standing on it — the
-     * common case, because a large plane's single sort key says nothing useful
-     * about where it sits relative to what stands on it.
+     * Called at the three points where the world draw is genuinely finished —
+     * `Container.draw` just before a floating child, `Camera2d.draw` once the
+     * container is down, and `Application.draw` at end of frame. Deliberately
+     * NOT on a batcher transition: anything non-mesh sorting mid-scene raises
+     * one, and every mesh still to come would then paint over what was just
+     * replayed.
      *
-     * So shadows are collected here and drawn once the opaque meshes are down.
-     * Depth *testing* stays on throughout, so a shadow is still correctly
-     * hidden behind geometry genuinely in front of it: deferring changes only
-     * who paints over whom among draws that write no depth.
-     * @param {object} quad - the shared shadow quad
-     * @param {Matrix3d} modelMatrix - where the blob sits (copied, not retained)
-     * @param {number} tint - packed ARGB tint for the draw
-     * @param {object} [instanced] - the `InstancedMesh` whose instance buffer
-     * supplies one blob per instance, for the instanced tier
-     * @ignore
-     */
-    queueGroundShadow(quad: object, modelMatrix: Matrix3d, tint: number, instanced?: object): void;
-    _shadowCount: any;
-    /**
-     * Draw every ground shadow queued since the last drain, then empty the
-     * queue (#1515). Called when the renderer leaves mesh mode, and once more
-     * at end of frame for a scene made only of meshes, which never switches
-     * away from mesh mode on its own.
+     * Only the current target's queue is touched — see
+     * {@link Renderer#transparentQueue}. A post effect binds an offscreen
+     * target part-way through a scene, and a drain fired in there must not
+     * reach the world's queued geometry; each pass drains its own on the way
+     * out.
      *
      * Inert on a backend that never queues — the Canvas renderer has no depth
-     * buffer and so no ground shadows at all.
+     * buffer, and composites through the 2D context instead.
+     */
+    flushTransparent(): void;
+    /**
+     * Run the transparent pass.
+     * @deprecated since 20.4.0, use {@link Renderer#flushTransparent}
      */
     flushGroundShadows(): void;
-    _shadowFlushing: boolean | undefined;
     /**
      * Draw a textured triangle mesh.
      * The mesh object must provide: `vertices` (Float32Array, x/y/z triplets),
@@ -374,23 +332,6 @@ declare class Renderer {
      * @returns {boolean}
      */
     hasSupportedCompressedFormats(format: number): boolean;
-    /**
-     * Begin capturing rendering to an offscreen buffer for post-effect processing.
-     * Call endPostEffect() after rendering to blit the result to the screen.
-     * No-op on Canvas renderer.
-     * @param {Renderable} renderable - the renderable with postEffects to apply
-     * @returns {boolean} false (Canvas renderer does not support post-effect processing)
-     * @ignore
-     */
-    beginPostEffect(renderable: Renderable): boolean;
-    /**
-     * End post-effect capture and blit the offscreen buffer to the screen
-     * through the renderable's post-effects.
-     * No-op on Canvas renderer.
-     * @param {Renderable} renderable - the renderable with postEffects to apply
-     * @ignore
-     */
-    endPostEffect(renderable: Renderable): void;
     /**
      * Blit a texture to the screen through a shader effect.
      * Draws a screen-aligned quad using the given texture as source
@@ -450,31 +391,9 @@ declare class Renderer {
      * set the current blend mode. Every renderer supports the same set —
      * see {@link CanvasRenderer#setBlendMode} for the list and what each does.
      * @param {string} [mode="normal"] - blend mode
-     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha
      */
     setBlendMode(mode?: string): void;
-    /**
-     * Upload the active scene lights to the lit sprite pipeline.
-     *
-     * Called once per camera per frame by `Camera2d.draw()` (after the
-     * FBO is bound, before the world tree walk fires `Sprite.draw` for
-     * any normal-mapped sprite). GPU renderers (WebGL today, WebGPU once
-     * it lands) override this to pack the lights into the lit shader's
-     * uniform buffers; the Canvas renderer cannot do per-pixel normal-map
-     * lighting and silently ignores the call. The first time a non-empty
-     * light list is passed in Canvas mode, a one-shot console warning is
-     * emitted.
-     *
-     * Stage stays renderer-agnostic by passing the raw scene data —
-     * lights iterable and ambient color — and letting the renderer
-     * decide how to encode them.
-     * @param {Iterable<object>} [lights] - active `Light2d` instances; falsy/empty no-ops
-     * @param {object} [ambient] - ambient lighting color (0..255 RGB)
-     * @param {number} [translateX=0] - world-to-screen X translate (matches `Camera2d.draw()`)
-     * @param {number} [translateY=0] - world-to-screen Y translate
-     */
-    setLightUniforms(lights?: Iterable<object>, ambient?: object, translateX?: number, translateY?: number): void;
-    _litPipelineWarned: boolean | undefined;
+    setLightUniforms(lights: any, ambient: any, translateX: any, translateY: any): void;
     /**
      * Render a `Light2d` instance.
      *
@@ -748,7 +667,7 @@ declare class Renderer {
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
-    setMask(): void;
+    setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask

package/build/video/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/video/renderer.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;GAGG;AACH;IA2dC;;;;;;;;;;;;OAYG;IACH,2BANW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAI7C;IAED;;;;;;;;;;;;OAYG;IACH,wBAFa,iBAAiB,GAAC,eAAe,CAgB7C;IAtgBD;;OAEG;IACH,sBAFW,mBAAmB,EA4N7B;IAzNA;;;;OAIG;IACH,cAFU,kBAAkB,CAS3B;IAED;;;;OAIG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,oBAFU,MAAM,CAE6C;IAE7D;;;;OAIG;IACH,YAHU,QAAQ,CAGsD;IAExE;;;;OAIG;IACH,gBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,aAFU,MAAM,GAAC,SAAS,CAEE;IAE5B;;;;;;OAMG;IACH,cAHU,QAAQ,GAAC,YAAY,GAAC,SAAS,CAGZ;IAE7B;;;;;OAKG;IACH,mBAHU,gBAAgB,GAAC,IAAI,CAGF;IAE7B;;;OAGG;IACH,QAFU,MAAM,CAEU;IAE1B;;;;;;;;;;OAUG;IACH,MAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,SAAS,CAEG;IAElC;;;;;;;;OAQG;IACH,0BAHU,OAAO,CAGoB;IAErC;;;;;;OAMG;IACH,sBAHU,OAAO,CAGgB;IAEjC;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGc;IAE/B;;;;;;;;;;;;;OAaG;IACH,gBAHU,MAAM,GAAC,MAAM,GAAC,IAAI,CAGF;IAE1B;;;;;;;OAOG;IACH,qBAHU,OAAO,CAGe;IAEhC;;;;;OAKG;IACH,iBAFU,KAAK,CAOd;IAED;;;;OAIG;IACH,aAFU,WAAW,CAEe;IAGpC,oBAAiD;IACjD,mBAA+C;IAC/C,4CAAqD;IAErD;;;;;;;;;OASG;IACH,WAHU,MAAM,CAGE;IAElB;;OAEG;IACH,kBAAkB;IAGlB,2BAAsC;IAGtC,iBAAiB;IAEjB;;;;;;;;OAQG;IACH,kBAFU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAEjD;IAE5B;;;;;;;OAOG;IACH,kBAFU,MAAM,CAES;IAU1B,4BANU,MAAM,EAQf;IATD;;OAEG;IACH,wBAFU,MAAM,CAIf;IAoBD,wBAPU,MAAM,EASf;IAhBD;;;;;;;;;OASG;IACH,oBAHU,MAAM,CAKf;IAcD,kBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAcD,iBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAMD;;;;;;;;OAQG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAPW,MAAM,eACN,QAAQ,QACR,MAAM,cACN,MAAM,QAqBhB;IADA,kBAA0B;IAG3B;;;;;;;;OAQG;IACH,2BAmDC;IAxCA,qCAA2B;IA0C5B;;;;;;;;;;;;;;;;;OAiBG;IAEH,eAJW,IAAI,gBACJ,QAAQ,QAGW;IAE9B;;OAEG;IACH,cAeC;IAED;;;;OAIG;IACH,gBAAY;IAEZ;;;OAGG;IACH,aAFa,iBAAiB,CAI7B;IAED;;;;;;;;;;OAUG;IACH,oBALW,MAAM,UACN,MAAM,0BACN,OAAO,GACL,iBAAiB,GAAC,eAAe,CAI7C;IAgDD;;;OAGG;IACH,cAFa,wBAAwB,GAAC,qBAAqB,GAAC,gBAAgB,CAI3E;IAED;;;;;;;OAOG;IACH,wCAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;;OAOG;IACH,4BAJW,UAAU,GACR,OAAO,CAcnB;IAED;;;;;;OAMG;IAEH,0BAJW,UAAU,QAIO;IAE5B;;;;;;;;;;;;OAYG;IAEH,mBATW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,YAAY,cACZ,OAAO,QAG2C;IAE7D;;;;;;;;OAQG;IAEH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGiB;IAElC;;;;OAIG;IACH,0BAAsB;IAEtB;;;;;;;OAOG;IAEH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGoB;IAErC;;;OAGG;IACH,uBAAmB;IAEnB;;;;OAIG;IAEH,wBAHW,OAAO,QAGQ;IAE1B;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IAEH,0BANW,QAAQ,CAAC,MAAM,CAAC,YAChB,MAAM,eACN,MAAM,eACN,MAAM,QAqBhB;IAPC,wCAA8B;IAShC;;;;;;;;;;;;;;;;;;;;OAoBG;IAEH,iBAJW,MAAM,QAMhB;IAED;;;;;;;;;;;;OAYG;IACH,qBAHW,MAAM,QACN,IAAI,QA4Bd;IAED;;;;OAIG;IAEH,gBAHW,KAAK,GAAC,MAAM,GAAC,QAAQ,QAK/B;IAED;;;OAGG;IACH,YAFa,KAAK,CAIjB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,sBARW,MAAM,EAAE,QAsBlB;IAED;;;OAGG;IACH,eAFa,MAAM,EAAE,CAIpB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GAAC,MAAM,GACT,OAAO,CASnB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAchB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAOjB;IAED;;;;;;;;;;;OAWG;IACH,2BAFa,QAAQ,GAAC,SAAS,CAS9B;IAED;;;;;;OAMG;IACH,wBAFW,MAAM,GAAC,SAAS,GAAC,QAAQ,QAInC;IAED;;;;OAIG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,cAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QAiFjB;IAED;;;OAGG;IACH,YAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;;;;;OAMG;IACH,UALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,SAClD,KAAK,GAAC,MAAM,SACZ,MAAM,GACJ,iBAAiB,GAAC,eAAe,CAyB7C;IAED;;;;;;;OAOG;IAEH,YANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGe;IAEhC;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,aAAS;IAET;;;;OAIG;IACH,gBAAY;IAEZ;;;;OAIG;IAEH,aAJW,MAAM,KACN,MAAM,QAGC;IAElB;;;OAGG;IAEH,cAHW,MAAM,QAGD;IAEhB;;;;OAIG;IAEH,SAJW,MAAM,KACN,MAAM,QAGH;IAEd;;;;OAIG;IAEH,sBAHW,MAAM,QAGO;IAExB;;;;;;;OAOG;IAEH,YANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGe;IAEhC;;;;;;;;OAQG;IAEH,cAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,OAAO,QAGsB;IAExC;;;;;;;OAOG;IAEH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAGS;IAE1B;;;;;;;;OAQG;IAEH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,OAAO,QAGgB;IAElC;;;;;;;OAOG;IAEH,mBANW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAGwB;IAEzC;;;;;;;;;;;;;;;;;;OAkBG;IAEH,iBAXW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,MAC1G,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGkC;IAEnD;;;;;;OAMG;IACH,gBAAY;IAEZ;;;OAGG;IACH,kBAAc;IAEd;;;;OAIG;IACH,cAHW,KAAK,UACL,MAAM,QAMhB;IAED;;;OAGG;IACH,kBAGC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAHW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;OAQG;IACH,qBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEH,yBAfG;QAAiC,MAAM;QAIwC,MAAM;eAAlE,MAAM;eAAK,MAAM;mBAAS,MAAM;oBAAU,MAAM;;KAMnE,GAAU,SAAS,CAOrB;CACD;;;;;+BAp2C8B,sCAAsC;yBAL5C,qBAAqB;kCAQb,sCAAsC;mBAXpD,2BAA2B;sBACxB,oBAAoB;wBAMlB,kBAAkB;yBALjB,qBAAqB;0BAavB,8BAA8B;yBAT5B,eAAe;4BAcf,wBAAwB;+BAJrB,8BAA8B;6BAChC,0BAA0B;0BAC7B,yBAAyB;6BACtB,4BAA4B;0CAEf,wBAAwB"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/video/renderer.js"],"names":[],"mappings":"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"}

package/build/video/renderstate.d.ts

@@ -60,60 +60,11 @@ export default class RenderState {
      * @type {number}
      */
     currentDepth: number;
-    /**
-     * @ignore
-     */
-    _stackCapacity: number;
-    /**
-     * current stack depth
-     * @ignore
-     */
-    _stackDepth: number;
-    /** @ignore */
-    _colorStack: Color[];
-    /** @ignore */
-    _tintStack: Color[];
-    /** @ignore */
-    _matrixStack: Matrix3d[];
-    /** @ignore */
-    _scissorStack: Int32Array<ArrayBuffer>[];
-    /** @ignore */
-    _lineDashStack: any[];
-    /** @ignore */
-    _scissorActive: Uint8Array<ArrayBuffer>;
-    /** @ignore */
-    _gradientStack: any[];
-    /** @ignore */
-    _blendStack: any[];
-    /** @ignore */
-    _shaderStack: any[];
-    /** @ignore */
-    _depthStack: Float32Array<ArrayBuffer>;
     /**
      * Save the current state onto the stack (zero allocations).
      * @param {boolean} [scissorTestActive=false] - whether scissor/clip is currently enabled
      */
     save(scissorTestActive?: boolean): void;
-    /**
-     * Inspect the scissor box that the next `restore()` would install,
-     * without mutating any state. Lets renderers detect whether a
-     * pending `restore()` will actually change the scissor (and
-     * decide, e.g., whether to flush GPU work first).
-     *
-     * Returns:
-     * - `Int32Array` (length 4) — `[x, y, width, height]` of the
-     *   saved scissor when scissor was active at the matching `save()`
-     *   call.
-     * - `null` — when the saved state had scissor disabled, or the
-     *   stack is empty. Treat this as "next scissor will be inactive".
-     *
-     * The returned array is a **live reference into the internal
-     * stack** — zero allocation on a hot path. Callers MUST treat it
-     * as read-only; mutating it corrupts subsequent `restore()` calls.
-     * @ignore
-     * @returns {Int32Array | null}
-     */
-    peekScissor(): Int32Array | null;
     /**
      * Restore state from the stack.
      * Color, tint, transform, and scissor are restored in place.
@@ -133,8 +84,6 @@ export default class RenderState {
      * @param {number} height - canvas height
      */
     reset(width: number, height: number): void;
-    /** @private — doubles stack capacity when exceeded */
-    private _growStacks;
 }
 import { Color } from "./../math/color.ts";
 import { Matrix3d } from "../math/matrix3d.ts";

package/build/video/renderstate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderstate.d.ts","sourceRoot":"","sources":["../../src/video/renderstate.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAEE;;;OAGG;IACH,cAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,aAFU,KAAK,CAEiC;IAEhD;;;OAGG;IACH,kBAFU,QAAQ,CAEoB;IAEtC;;;OAGG;IACH,gBAFU,UAAU,CAEmB;IAEvC;;;OAGG;IACH,iBAFU,QAAQ,GAAC,IAAI,CAEI;IAE3B;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,eAFU,YAAY,GAAC,SAAS,CAEF;IAE9B;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEK;IAIrB;;OAEG;IACH,uBAAwB;IAExB;;;OAGG;IACH,oBAAoB;IAEpB,cAAc;IACd,qBAEE;IAEF,cAAc;IACd,oBAEE;IAEF,cAAc;IACd,yBAEE;IAEF,cAAc;IACd,yCAEE;IAEF,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,wCAAyD;IAEzD,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,mBAAiD;IAEjD,cAAc;IACd,oBAAkD;IAElD,cAAc;IACd,uCAAwD;IAGzD;;;OAGG;IACH,yBAFW,OAAO,QA0BjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAFa,UAAU,GAAG,IAAI,CAQ7B;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,gBACN,MAAM,GACJ;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CA0BhE;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAWhB;IAED,sDAAsD;IACtD,oBAoBC;CACD;sBAlQqB,oBAAoB;yBACjB,qBAAqB;8BAGnB,eAAe"}
+{"version":3,"file":"renderstate.d.ts","sourceRoot":"","sources":["../../src/video/renderstate.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAEE;;;OAGG;IACH,cAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,aAFU,KAAK,CAEiC;IAEhD;;;OAGG;IACH,kBAFU,QAAQ,CAEoB;IAEtC;;;OAGG;IACH,gBAFU,UAAU,CAEmB;IAEvC;;;OAGG;IACH,iBAFU,QAAQ,GAAC,IAAI,CAEI;IAE3B;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,eAFU,YAAY,GAAC,SAAS,CAEF;IAE9B;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEK;IAIrB;;;OAGG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,oBAAoB;IAEpB;;;OAGG;IACH,qBAEE;IAEF;;;OAGG;IACH,oBAEE;IAEF;;;OAGG;IACH,yBAEE;IAEF;;;OAGG;IACH,yCAEE;IAEF;;;OAGG;IACH,sBAAoD;IAEpD;;;OAGG;IACH,wCAAyD;IAEzD;;;OAGG;IACH,sBAAoD;IAEpD;;;OAGG;IACH,mBAAiD;IAEjD;;;OAGG;IACH,oBAAkD;IAElD;;;OAGG;IACH,uCAAwD;IAGzD;;;OAGG;IACH,yBAFW,OAAO,QA0BjB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAFa,UAAU,GAAG,IAAI,CAQ7B;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,gBACN,MAAM,GACJ;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CA0BhE;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,oBAoBC;CACD;sBAvSqB,oBAAoB;yBACjB,qBAAqB;8BAGnB,eAAe"}

package/build/video/rendertarget/canvasrendertarget.d.ts

@@ -50,10 +50,6 @@ declare class CanvasRenderTarget extends RenderTarget {
      * @deprecated since 20.0.0 — the WebGL renderer is WebGL 2 only, this is always `2`
      */
     WebGLVersion: number;
-    /**
-     * @ignore
-     */
-    onResetEvent(width: any, height: any): void;
     /**
      * enable/disable image smoothing (scaling interpolation)
      * @param {boolean} [enable=false] - whether to enable or not image smoothing (scaling interpolation)
@@ -76,12 +72,6 @@ declare class CanvasRenderTarget extends RenderTarget {
      */
     invalidate(renderer: CanvasRenderer | WebGLRenderer): void;
     glTextureUnit: any;
-    /**
-     * Destroy this canvas render target and release associated GPU resources.
-     * @param {CanvasRenderer|WebGLRenderer} [renderer] - the renderer to clean up WebGL resources from
-     * @ignore
-     */
-    destroy(renderer?: CanvasRenderer | WebGLRenderer): void;
     #private;
 }
 import RenderTarget from "./rendertarget.ts";

package/build/video/rendertarget/canvasrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA6EA;;;;;;GAMG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAoCA;IAhCA;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAGzD;;;;OAIG;IACH,cAHU,MAAM,CAGK;IAOvB;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAsBtC;IAWC,mBAEC;IAeH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAyCtC;;CA2BD;yBAvXwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}
+{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA6EA;;;;;;GAMG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAoCA;IAhCA;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAGzD;;;;OAIG;IACH,cAHU,MAAM,CAGK;IAOvB;;;OAGG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAsBtC;IAcC,mBAEC;IAeH;;;;;OAKG;IACH,mBAJW,cAAc,GAAC,aAAa,QA0CtC;;CA2BD;yBA5XwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}