sdfsdfs

node_modules/pixi.js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2013-2023 Mathew Groves, Chad Engler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/pixi.js/README.md

@@ -0,0 +1,197 @@
+PixiJS — The HTML5 Creation Engine
+=============
+
+![pixi.js logo](https://pixijs.download/pixijs-banner-no-version.png?v=1)
+
+[![Discord](https://badgen.net/badge/icon/discord?icon=discord&label)](https://discord.gg/QrnxmQUPGV)
+[![npm version](https://badge.fury.io/js/pixi.js.svg)](https://badge.fury.io/js/pixi.js)
+[![Node.js CI](https://github.com/pixijs/pixijs/workflows/Node.js%20CI/badge.svg)](https://github.com/pixijs/pixijs/actions?query=workflow%3A%22Node.js+CI%22)
+[![Financial Contributors](https://opencollective.com/pixijs/tiers/badge.svg)](https://opencollective.com/pixijs/donate)
+
+This project aims to provide a fast, lightweight 2D library that works
+across all devices. The PixiJS renderer allows everyone to enjoy the power of
+hardware acceleration without prior knowledge of WebGL. Also, it's fast. Really fast.
+
+If you want to keep up to date with the latest PixiJS news then feel free to follow us on Twitter [@PixiJS](https://twitter.com/PixiJS)
+and we will keep you posted! You can also check back on [our site](https://pixijs.com)
+as any breakthroughs will be posted up there too!
+
+**We are now a part of the [Open Collective](https://opencollective.com/pixijs) and with your support you can help us make PixiJS even better. To make a donation, simply click the button below and we'll love you forever!**
+
+<div align="center">
+  <a href="https://opencollective.com/pixijs/donate" target="_blank">
+    <img src="https://opencollective.com/pixijs/donate/button@2x.png?color=blue" width=250 />
+  </a>
+</div>
+
+### What to Use PixiJS for and When to Use It
+
+PixiJS is a rendering library that will allow you to create rich, interactive graphics and cross-platform applications and games without having to dive into the WebGL API or deal with browser and device compatibility.
+
+PixiJS supports [WebGPU](https://en.wikipedia.org/wiki/WebGPU) with fallback support for [WebGL](https://en.wikipedia.org/wiki/WebGL). As a library, PixiJS is a fantastic tool for authoring interactive content. Use it for your graphics-rich, interactive websites, applications, and HTML5 games. Out-of-the-box, cross-platform compatibility and graceful degradation mean you have less work to do and more fun doing it! If you want to create polished and refined experiences relatively quickly without delving into dense, low-level code, all while avoiding the headaches of browser inconsistencies, then sprinkle your next project with some PixiJS magic!
+
+**Boost your development and feel free to use your imagination!**
+
+### Current features ###
+
+- WebGL renderer (with automatic smart batching, allowing for REALLY fast performance)
+- WebGPU renderer (new to the latest browsers!)
+- Canvas renderer (Fastest in town!)
+- Full scene graph
+- Super easy to use API (similar to the flash display list API)
+- Support for texture atlases
+- Asset loader / sprite sheet loader
+- Auto-detect which renderer should be used
+- Full Mouse and Multi-touch Interaction
+- Text
+- BitmapFont text
+- Multiline Text
+- Render Texture
+- Primitive Drawing
+- Masking
+- Filters
+- Community-Supported Plugins
+  - [React](https://github.com/pixijs/pixi-react)
+  - [Spine](https://github.com/pixijs/spine)
+  - [Filters](https://github.com/pixijs/filters)
+  - [Animate](https://github.com/pixijs/animate)
+  - [Lights](https://github.com/pixijs/lights)
+  - [UI](https://github.com/pixijs/ui)
+  - [Layout](https://github.com/pixijs/layout)
+  - [GIF](https://github.com/pixijs/gif)
+  - And more!
+
+### Setup ###
+
+It's easy to get started with PixiJS! Simply download a [prebuilt build](https://github.com/pixijs/pixijs/wiki/FAQs#where-can-i-get-a-build)!
+
+Alternatively, PixiJS can be installed with [npm](https://docs.npmjs.com/getting-started/what-is-npm) or simply using a content delivery network (CDN) URL to embed PixiJS directly on your HTML page.
+
+#### NPM Install
+
+```sh
+npm install pixi.js
+```
+
+There is no default export. The correct way to import PixiJS is:
+
+```js
+import * as PIXI from 'pixi.js';
+```
+
+#### CDN Install
+
+Via jsDelivr:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/pixi.js@7.x/dist/pixi.min.js"></script>
+```
+
+Or via unpkg:
+
+```html
+<script src="https://unpkg.com/pixi.js@7.x/dist/pixi.min.js"></script>
+```
+
+### Basic Usage Example ###
+
+```js
+import { Application, Sprite, Assets } from 'pixi.js';
+
+// The application will create a renderer using WebGL, if possible,
+// with a fallback to a canvas render. It will also setup the ticker
+// and the root stage PIXI.Container
+const app = new Application();
+
+// Wait for the Renderer to be available
+await app.init();
+
+// The application will create a canvas element for you that you
+// can then insert into the DOM
+document.body.appendChild(app.canvas);
+
+// load the texture we need
+const texture = await Assets.load('bunny.png');
+
+// This creates a texture from a 'bunny.png' image
+const bunny = new Sprite(texture);
+
+// Setup the position of the bunny
+bunny.x = app.renderer.width / 2;
+bunny.y = app.renderer.height / 2;
+
+// Rotate around the center
+bunny.anchor.x = 0.5;
+bunny.anchor.y = 0.5;
+
+// Add the bunny to the scene we are building
+app.stage.addChild(bunny);
+
+// Listen for frame updates
+app.ticker.add(() => {
+    // each frame we spin the bunny around a bit
+    bunny.rotation += 0.01;
+});
+```
+
+### Learn ###
+- Website: Find out more about PixiJS on the [official website](https://pixijs.com).
+- Getting Started:
+    - Check out the [getting started guide](https://pixijs.com/guides/basics/getting-started).
+    - Also, check out @miltoncandelero's PixiJS tutorials aimed toward videogames with recipes and best practices [here](https://www.pixijselementals.com)
+- Examples: Get stuck right in and play around with PixiJS code and features right [here](https://pixijs.com/examples)!
+- API Documentation: Get to know the PixiJS API by checking out the [docs](https://pixijs.io/docs).
+- Guide: Supplementary usage guides to the API Documentation [here](https://pixijs.com/guides).
+
+### Demos ###
+
+- [Filters Demo](https://pixijs.io/filters/examples)
+- [Bunny Demo](http://www.goodboydigital.com/pixijs/bunnymark)
+- [Masking Demo](https://pixijs.com/examples/masks/graphics)
+- [Interaction Demo](https://pixijs.com/examples/events/interactivity)
+- [More examples](https://pixijs.com/examples)
+
+### Community ###
+
+- Forums: Check out the [discussions](https://github.com/pixijs/pixijs/discussions) and [Stackoverflow](http://stackoverflow.com/search?q=pixi.js) -- both friendly places to ask your PixiJS questions.
+- Chat: You can join us on [Discord](https://discord.gg/QrnxmQUPGV) to chat about PixiJS.
+
+### How to build ###
+
+Note that for most users you don't need to build this project. If all you want is to use PixiJS, then
+just download one of our [prebuilt releases](https://github.com/pixijs/pixijs/releases).
+The only time you should need to build PixiJS is if you are developing it.
+
+If you don't already have Node.js and NPM, go install them. Then, in the folder where you have cloned
+the repository, install the build dependencies using npm:
+
+```sh
+npm install
+```
+
+Then, to build the source, run:
+
+```sh
+npm run build
+```
+
+### How to generate the documentation ###
+
+The docs can be generated using npm:
+
+```sh
+npm run docs
+```
+
+### Contribute ###
+
+Want to be part of the PixiJS project? Great! All are welcome! We will get there quicker
+together :) Whether you find a bug, have a great feature request, or you fancy owning a task
+from the road map above, feel free to get in touch.
+
+Make sure to read the [Contributing Guide](.github/CONTRIBUTING.md)
+before submitting changes.
+
+### License ###
+
+This content is released under the [MIT License](http://opensource.org/licenses/MIT).

node_modules/pixi.js/dist/packages/advanced-blend-modes.min.js

@@ -0,0 +1,653 @@
+/*!
+ * PixiJS - v8.4.1
+ * Compiled Thu, 19 Sep 2024 10:28:58 UTC
+ *
+ * PixiJS is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ */this.PIXI=this.PIXI||{};var advanced_blend_modes_js=function(e){"use strict";"use strict";class l extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                ${PIXI.hslgl}
+
+                vec3 blendColor(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                ${PIXI.hslgpu}
+
+                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}l.extension={name:"color",type:PIXI.ExtensionType.BlendMode};class b extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0 - ((1.0 - base) / blend)), 0.0);
+                }
+
+                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}b.extension={name:"color-burn",type:PIXI.ExtensionType.BlendMode};class a extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float colorDodge(float base, float blend)
+                {
+                    return base / (1.0 - blend);
+                }
+
+                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return base / (1.0 - blend);
+                }
+
+                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}a.extension={name:"color-dodge",type:PIXI.ExtensionType.BlendMode};class d extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                vec3 blendDarken(vec3 base, vec3 blend, float opacity)
+                {
+                    return (min(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (min(blend,base) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}d.extension={name:"darken",type:PIXI.ExtensionType.BlendMode};class t extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}t.extension={name:"difference",type:PIXI.ExtensionType.BlendMode};class r extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float divide(float base, float blend)
+                {
+                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;
+                }
+
+                vec3 blendDivide(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn divide(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);
+                }
+
+                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}r.extension={name:"divide",type:PIXI.ExtensionType.BlendMode};class o extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                vec3 exclusion(vec3 base, vec3 blend)
+                {
+                    return base + blend - 2.0 * base * blend;
+                }
+
+                vec3 blendExclusion(vec3 base, vec3 blend, float opacity)
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendExclusion(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn exclusion(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return base+blend-2.0*base*blend;
+                }
+
+                fn blendExclusion(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendExclusion(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}o.extension={name:"exclusion",type:PIXI.ExtensionType.BlendMode};class i extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float hardLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+                }
+
+                vec3 blendHardLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendHardLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                fn hardLight(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, blend < 0.5);
+                }
+
+                fn blendHardLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendHardLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}i.extension={name:"hard-light",type:PIXI.ExtensionType.BlendMode};class s extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float hardMix(float base, float blend)
+                {
+                    return (base + blend >= 1.0) ? 1.0 : 0.0;
+                }
+
+                vec3 blendHardMix(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendHardMix(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                fn hardMix(base: f32, blend: f32) -> f32
+                {
+                    return select(0.0, 1.0, base + blend >= 1.0);
+                }
+
+                fn blendHardMix(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendHardMix(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}s.extension={name:"hard-mix",type:PIXI.ExtensionType.BlendMode};class c extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                vec3 blendLighten(vec3 base, vec3 blend, float opacity)
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendLighten(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn blendLighten(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendLighten(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}c.extension={name:"lighten",type:PIXI.ExtensionType.BlendMode};class f extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float linearBurn(float base, float blend)
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendLinearBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn blendLinearBurn(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendLinearBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}f.extension={name:"linear-burn",type:PIXI.ExtensionType.BlendMode};class u extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendLinearDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1, base + blend);
+                }
+
+                fn blendLinearDodge(base:vec3<f32>, blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendLinearDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}u.extension={name:"linear-dodge",type:PIXI.ExtensionType.BlendMode};class g extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float linearBurn(float base, float blend) {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                float linearLight(float base, float blend) {
+                    return (blend <= 0.5) ? linearBurn(base,2.0*blend) : linearBurn(base,2.0*(blend-0.5));
+                }
+
+                vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendLinearLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1.0, base + blend);
+                }
+
+                fn linearLight(base: f32, blend: f32) -> f32
+                {
+                    return select(linearBurn(base,2.0*(blend-0.5)), linearBurn(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendLinearLightOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendLinearLightOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}g.extension={name:"linear-light",type:PIXI.ExtensionType.BlendMode};class v extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                ${PIXI.hslgl}
+
+                vec3 blendLuminosity(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendLuminosity = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendLuminosity(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                ${PIXI.hslgpu}
+
+                fn blendLuminosity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendLuminosity: vec3<f32> = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendLuminosity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}v.extension={name:"luminosity",type:PIXI.ExtensionType.BlendMode};class p extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                vec3 negation(vec3 base, vec3 blend)
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                vec3 blendNegation(vec3 base, vec3 blend, float opacity)
+                {
+                    return (negation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendNegation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn blendNegation(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                fn blendNegationOpacity(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendNegationOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}p.extension={name:"negation",type:PIXI.ExtensionType.BlendMode};class y extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float overlay(float base, float blend)
+                {
+                    return (base < 0.5) ? (2.0*base*blend) : (1.0-2.0*(1.0-base)*(1.0-blend));
+                }
+
+                vec3 blendOverlay(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+   
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendOverlay(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn overlay(base: f32, blend: f32) -> f32
+                {
+                    return select((1.0-2.0*(1.0-base)*(1.0-blend)), (2.0*base*blend), base < 0.5);
+                }
+
+                fn blendOverlay(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendOverlay(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}y.extension={name:"overlay",type:PIXI.ExtensionType.BlendMode};class B extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float pinLight(float base, float blend)
+                {
+                    return (blend <= 0.5) ? min(base, 2.0 * blend) : max(base, 2.0 * (blend - 0.5));
+                }
+
+                vec3 blendPinLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn pinLight(base: f32, blend: f32) -> f32
+                {
+                    return select(max(base,2.0*(blend-0.5)), min(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendPinLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}B.extension={name:"pin-light",type:PIXI.ExtensionType.BlendMode};class h extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                ${PIXI.hslgl}
+
+                vec3 blendSaturation(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                ${PIXI.hslgpu}
+
+                fn blendSaturation(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                out = vec4<f32>(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `}})}}h.extension={name:"saturation",type:PIXI.ExtensionType.BlendMode};class m extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float softLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend));
+                }
+
+                vec3 blendSoftLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn softLight(base: f32, blend: f32) -> f32
+                {
+                    return select(2.0 * base * blend + base * base * (1.0 - 2.0 * blend), sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend), blend < 0.5);
+                }
+
+                fn blendSoftLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}m.extension={name:"soft-light",type:PIXI.ExtensionType.BlendMode};class L extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float subtract(float base, float blend)
+                {
+                    return max(0.0, base - blend);
+                }
+
+                vec3 blendSubtract(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                finalColor = vec4(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `},gpu:{functions:`
+                fn subtract(base: f32, blend: f32) -> f32
+                {
+                    return max(0, base - blend);
+                }
+
+                fn blendSubtract(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}L.extension={name:"subtract",type:PIXI.ExtensionType.BlendMode};class I extends PIXI.BlendModeFilter{constructor(){super({gl:{functions:`
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                float colorDodge(float base, float blend)
+                {
+                    return min(1.0, base / (1.0-blend));
+                }
+
+                float vividLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? colorBurn(base,(2.0*blend)) : colorDodge(base,(2.0*(blend-0.5)));
+                }
+
+                vec3 blendVividLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        vividLight(base.r, blend.r),
+                        vividLight(base.g, blend.g),
+                        vividLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,main:`
+                finalColor = vec4(blendVividLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `},gpu:{functions:`
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1.0, base / (1.0-blend));
+                }
+
+                fn vividLight(base: f32, blend: f32) -> f32
+                {
+                    return select(colorDodge(base,(2.0*(blend-0.5))), colorBurn(base,(2.0*blend)), blend<0.5);
+                }
+
+                fn blendVividLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        vividLight(base.r, blend.r),
+                        vividLight(base.g, blend.g),
+                        vividLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,main:`
+                out = vec4<f32>(blendVividLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `}})}}return I.extension={name:"vivid-light",type:PIXI.ExtensionType.BlendMode},PIXI.extensions.add(l,b,a,d,t,r,o,i,s,c,f,g,u,v,p,y,B,h,m,L,I),e.ColorBlend=l,e.ColorBurnBlend=b,e.ColorDodgeBlend=a,e.DarkenBlend=d,e.DifferenceBlend=t,e.DivideBlend=r,e.ExclusionBlend=o,e.HardLightBlend=i,e.HardMixBlend=s,e.LightenBlend=c,e.LinearBurnBlend=f,e.LinearDodgeBlend=u,e.LinearLightBlend=g,e.LuminosityBlend=v,e.NegationBlend=p,e.OverlayBlend=y,e.PinLightBlend=B,e.SaturationBlend=h,e.SoftLightBlend=m,e.SubtractBlend=L,e.VividLightBlend=I,e}({});Object.assign(this.PIXI,advanced_blend_modes_js);
+//# sourceMappingURL=advanced-blend-modes.min.js.map

node_modules/pixi.js/dist/packages/math-extras.js

@@ -0,0 +1,516 @@
+/*!
+ * PixiJS - v8.4.1
+ * Compiled Thu, 19 Sep 2024 10:28:58 UTC
+ *
+ * PixiJS is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ */
+this.PIXI = this.PIXI || {};
+var math_extras_js = (function (exports) {
+    'use strict';
+
+    "use strict";
+
+    const pointExtraMixins = {
+      /**
+       * Adds `other` to `this` point and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method add
+       * @memberof maths.Point#
+       * @param {maths.PointData} other - The point to add to `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the result of the addition.
+       */
+      /**
+       * Adds `other` to `this` point and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method add
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} other - The point to add to `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the result of the addition.
+       */
+      add(other, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        outPoint.x = this.x + other.x;
+        outPoint.y = this.y + other.y;
+        return outPoint;
+      },
+      /**
+       * Subtracts `other` from `this` point and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method subtract
+       * @memberof maths.Point#
+       * @param {maths.PointData} other - The point to subtract to `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the result of the subtraction.
+       */
+      /**
+       * Subtracts `other` from `this` point and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method subtract
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} other - The point to subtract to `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the result of the subtraction.
+       */
+      subtract(other, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        outPoint.x = this.x - other.x;
+        outPoint.y = this.y - other.y;
+        return outPoint;
+      },
+      /**
+       * Multiplies component-wise `other` and `this` points and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method multiply
+       * @memberof maths.Point#
+       * @param {maths.PointData} other - The point to multiply with `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the component-wise multiplication.
+       */
+      /**
+       * Multiplies component-wise `other` and `this` points and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method multiply
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} other - The point to multiply with `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the component-wise multiplication.
+       */
+      multiply(other, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        outPoint.x = this.x * other.x;
+        outPoint.y = this.y * other.y;
+        return outPoint;
+      },
+      /**
+       * Multiplies each component of `this` point with the number `scalar` and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method multiplyScalar
+       * @memberof maths.Point#
+       * @param {number} scalar - The number to multiply both components of `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the multiplication.
+       */
+      /**
+       * Multiplies each component of `this` point with the number `scalar` and outputs into `outPoint` or a new Point.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method multiplyScalar
+       * @memberof maths.ObservablePoint#
+       * @param {number} scalar - The number to multiply both components of `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `outPoint` reference or a new Point, with the multiplication.
+       */
+      multiplyScalar(scalar, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        outPoint.x = this.x * scalar;
+        outPoint.y = this.y * scalar;
+        return outPoint;
+      },
+      /**
+       * Computes the dot product of `other` with `this` point.
+       * The dot product is the sum of the products of the corresponding components of two vectors.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method dot
+       * @memberof maths.Point#
+       * @param {maths.PointData} other - The other point to calculate the dot product with `this`.
+       * @returns {number} The result of the dot product. This is an scalar value.
+       */
+      /**
+       * Computes the dot product of `other` with `this` point.
+       * The dot product is the sum of the products of the corresponding components of two vectors.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method dot
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} other - The other point to calculate the dot product with `this`.
+       * @returns {number} The result of the dot product. This is an scalar value.
+       */
+      dot(other) {
+        return this.x * other.x + this.y * other.y;
+      },
+      /**
+       * Computes the cross product of `other` with `this` point.
+       * Given two linearly independent R3 vectors a and b, the cross product, a × b (read "a cross b"),
+       * is a vector that is perpendicular to both a and b, and thus normal to the plane containing them.
+       * While cross product only exists on 3D space, we can assume the z component of 2D to be zero and
+       * the result becomes a vector that will only have magnitude on the z axis.
+       *
+       * This function returns the z component of the cross product of the two points.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method cross
+       * @memberof maths.Point#
+       * @param {maths.PointData} other - The other point to calculate the cross product with `this`.
+       * @returns {number} The z component of the result of the cross product.
+       */
+      /**
+       * Computes the cross product of `other` with `this` point.
+       * Given two linearly independent R3 vectors a and b, the cross product, a × b (read "a cross b"),
+       * is a vector that is perpendicular to both a and b, and thus normal to the plane containing them.
+       * While cross product only exists on 3D space, we can assume the z component of 2D to be zero and
+       * the result becomes a vector that will only have magnitude on the z axis.
+       *
+       * This function returns the z component of the cross product of the two points.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method cross
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} other - The other point to calculate the cross product with `this`.
+       * @returns {number} The z component of the result of the cross product.
+       */
+      cross(other) {
+        return this.x * other.y - this.y * other.x;
+      },
+      /**
+       * Computes a normalized version of `this` point.
+       *
+       * A normalized vector is a vector of magnitude (length) 1
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method normalize
+       * @memberof maths.Point#
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The normalized point.
+       */
+      /**
+       * Computes a normalized version of `this` point.
+       *
+       * A normalized vector is a vector of magnitude (length) 1
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method normalize
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The normalized point.
+       */
+      normalize(outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        const magnitude = Math.sqrt(this.x * this.x + this.y * this.y);
+        outPoint.x = this.x / magnitude;
+        outPoint.y = this.y / magnitude;
+        return outPoint;
+      },
+      /**
+       * Computes the magnitude of this point (Euclidean distance from 0, 0).
+       *
+       * Defined as the square root of the sum of the squares of each component.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method magnitude
+       * @memberof maths.Point#
+       * @returns {number} The magnitude (length) of the vector.
+       */
+      /**
+       * Computes the magnitude of this point (Euclidean distance from 0, 0).
+       *
+       * Defined as the square root of the sum of the squares of each component.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method magnitude
+       * @memberof maths.ObservablePoint#
+       * @returns {number} The magnitude (length) of the vector.
+       */
+      magnitude() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+      },
+      /**
+       * Computes the square magnitude of this point.
+       * If you are comparing the lengths of vectors, you should compare the length squared instead
+       * as it is slightly more efficient to calculate.
+       *
+       * Defined as the sum of the squares of each component.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method magnitudeSquared
+       * @memberof maths.Point#
+       * @returns {number} The magnitude squared (length squared) of the vector.
+       */
+      /**
+       * Computes the square magnitude of this point.
+       * If you are comparing the lengths of vectors, you should compare the length squared instead
+       * as it is slightly more efficient to calculate.
+       *
+       * Defined as the sum of the squares of each component.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method magnitudeSquared
+       * @memberof maths.ObservablePoint#
+       * @returns {number} The magnitude squared (length squared) of the vector.
+       */
+      magnitudeSquared() {
+        return this.x * this.x + this.y * this.y;
+      },
+      /**
+       * Computes vector projection of `this` on `onto`.
+       *
+       * Imagine a light source, parallel to `onto`, above `this`.
+       * The light would cast rays perpendicular to `onto`.
+       * `this.project(onto)` is the shadow cast by `this` on the line defined by `onto` .
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method project
+       * @memberof maths.Point#
+       * @param {maths.PointData} onto - A non zero vector describing a line on which to project `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `this` on `onto` projection.
+       */
+      /**
+       * Computes vector projection of `this` on `onto`.
+       *
+       * Imagine a light source, parallel to `onto`, above `this`.
+       * The light would cast rays perpendicular to `onto`.
+       * `this.project(onto)` is the shadow cast by `this` on the line defined by `onto` .
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method project
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} onto - A non zero vector describing a line on which to project `this`.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The `this` on `onto` projection.
+       */
+      project(onto, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        const normalizedScalarProjection = (this.x * onto.x + this.y * onto.y) / (onto.x * onto.x + onto.y * onto.y);
+        outPoint.x = onto.x * normalizedScalarProjection;
+        outPoint.y = onto.y * normalizedScalarProjection;
+        return outPoint;
+      },
+      /**
+       * Reflects `this` vector off of a plane orthogonal to `normal`.
+       * `normal` is not normalized during this process. Consider normalizing your `normal` before use.
+       *
+       * Imagine a light source bouncing onto a mirror.
+       * `this` vector is the light and `normal` is a vector perpendicular to the mirror.
+       * `this.reflect(normal)` is the reflection of `this` on that mirror.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method reflect
+       * @memberof maths.Point#
+       * @param {maths.PointData} normal - The normal vector of your reflecting plane.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The reflection of `this` on your reflecting plane.
+       */
+      /**
+       * Reflects `this` vector off of a plane orthogonal to `normal`.
+       * `normal` is not normalized during this process. Consider normalizing your `normal` before use.
+       *
+       * Imagine a light source bouncing onto a mirror.
+       * `this` vector is the light and `normal` is a vector perpendicular to the mirror.
+       * `this.reflect(normal)` is the reflection of `this` on that mirror.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method reflect
+       * @memberof maths.ObservablePoint#
+       * @param {maths.PointData} normal - The normal vector of your reflecting plane.
+       * @param {maths.PointData} [outPoint] - A Point-like object in which to store the value,
+       * optional (otherwise will create a new Point).
+       * @returns {PointData} The reflection of `this` on your reflecting plane.
+       */
+      reflect(normal, outPoint) {
+        if (!outPoint) {
+          outPoint = new PIXI.Point();
+        }
+        const dotProduct = this.x * normal.x + this.y * normal.y;
+        outPoint.x = this.x - 2 * dotProduct * normal.x;
+        outPoint.y = this.y - 2 * dotProduct * normal.y;
+        return outPoint;
+      }
+    };
+
+    "use strict";
+
+    const rectangleExtraMixins = {
+      /**
+       * Determines whether the `other` Rectangle is contained within `this` Rectangle object.
+       * Rectangles that occupy the same space are considered to be containing each other.
+       * Rectangles without area (width or height equal to zero) can't contain anything,
+       * not even other arealess rectangles.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method containsRect
+       * @memberof maths.Rectangle#
+       * @param {Rectangle} other - The Rectangle to fit inside `this`.
+       * @returns {boolean} A value of `true` if `this` Rectangle contains `other`; otherwise `false`.
+       */
+      containsRect(other) {
+        if (other.width <= 0 || other.height <= 0) {
+          return other.x > this.x && other.y > this.y && other.right < this.right && other.bottom < this.bottom;
+        }
+        return other.x >= this.x && other.y >= this.y && other.right <= this.right && other.bottom <= this.bottom;
+      },
+      /**
+       * Accepts `other` Rectangle and returns true if the given Rectangle is equal to `this` Rectangle.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method equals
+       * @memberof maths.Rectangle#
+       * @param {Rectangle} other - The Rectangle to compare with `this`
+       * @returns {boolean} Returns true if all `x`, `y`, `width`, and `height` are equal.
+       */
+      equals(other) {
+        if (other === this) {
+          return true;
+        }
+        return other && this.x === other.x && this.y === other.y && this.width === other.width && this.height === other.height;
+      },
+      /**
+       * If the area of the intersection between the Rectangles `other` and `this` is not zero,
+       * returns the area of intersection as a Rectangle object. Otherwise, return an empty Rectangle
+       * with its properties set to zero.
+       * Rectangles without area (width or height equal to zero) can't intersect or be intersected
+       * and will always return an empty rectangle with its properties set to zero.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method intersection
+       * @memberof maths.Rectangle#
+       * @param {Rectangle} other - The Rectangle to intersect with `this`.
+       * @param {Rectangle} [outRect] - A Rectangle object in which to store the value,
+       * optional (otherwise will create a new Rectangle).
+       * @returns {Rectangle} The intersection of `this` and `other`.
+       */
+      intersection(other, outRect) {
+        if (!outRect) {
+          outRect = new PIXI.Rectangle();
+        }
+        const x0 = this.x < other.x ? other.x : this.x;
+        const x1 = this.right > other.right ? other.right : this.right;
+        if (x1 <= x0) {
+          outRect.x = outRect.y = outRect.width = outRect.height = 0;
+          return outRect;
+        }
+        const y0 = this.y < other.y ? other.y : this.y;
+        const y1 = this.bottom > other.bottom ? other.bottom : this.bottom;
+        if (y1 <= y0) {
+          outRect.x = outRect.y = outRect.width = outRect.height = 0;
+          return outRect;
+        }
+        outRect.x = x0;
+        outRect.y = y0;
+        outRect.width = x1 - x0;
+        outRect.height = y1 - y0;
+        return outRect;
+      },
+      /**
+       * Adds `this` and `other` Rectangles together to create a new Rectangle object filling
+       * the horizontal and vertical space between the two rectangles.
+       *
+       * _Note: Only available with **pixi.js/math-extras**._
+       * @method union
+       * @memberof maths.Rectangle#
+       * @param {Rectangle} other - The Rectangle to unite with `this`.
+       * @param {Rectangle} [outRect] - A Rectangle object in which to store the value,
+       * optional (otherwise will create a new Rectangle).
+       * @returns {Rectangle} The union of `this` and `other`.
+       */
+      union(other, outRect) {
+        if (!outRect) {
+          outRect = new PIXI.Rectangle();
+        }
+        const x1 = Math.min(this.x, other.x);
+        const x2 = Math.max(this.x + this.width, other.x + other.width);
+        const y1 = Math.min(this.y, other.y);
+        const y2 = Math.max(this.y + this.height, other.y + other.height);
+        outRect.x = x1;
+        outRect.y = y1;
+        outRect.width = x2 - x1;
+        outRect.height = y2 - y1;
+        return outRect;
+      }
+    };
+
+    "use strict";
+    Object.assign(PIXI.Point.prototype, pointExtraMixins);
+    Object.assign(PIXI.ObservablePoint.prototype, pointExtraMixins);
+    Object.assign(PIXI.Rectangle.prototype, rectangleExtraMixins);
+
+    "use strict";
+    function floatEqual(a, b, epsilon = Number.EPSILON) {
+      if (a === b) {
+        return true;
+      }
+      const diff = Math.abs(a - b);
+      return diff < epsilon;
+    }
+    function genericLineIntersection(aStart, aEnd, bStart, bEnd, isLine, outPoint) {
+      if (!outPoint) {
+        outPoint = new PIXI.Point();
+      }
+      const dxa = aEnd.x - aStart.x;
+      const dya = aEnd.y - aStart.y;
+      const dxb = bEnd.x - bStart.x;
+      const dyb = bEnd.y - bStart.y;
+      const denominator = dyb * dxa - dxb * dya;
+      if (floatEqual(denominator, 0)) {
+        outPoint.x = NaN;
+        outPoint.y = NaN;
+        return outPoint;
+      }
+      const ua = (dxb * (aStart.y - bStart.y) - dyb * (aStart.x - bStart.x)) / denominator;
+      const ub = (dxa * (aStart.y - bStart.y) - dya * (aStart.x - bStart.x)) / denominator;
+      if (!isLine && (ua < 0 || ua > 1 || ub < 0 || ub > 1)) {
+        outPoint.x = NaN;
+        outPoint.y = NaN;
+        return outPoint;
+      }
+      outPoint.x = aStart.x + ua * dxa;
+      outPoint.y = bStart.y + ub * dyb;
+      return outPoint;
+    }
+    function lineIntersection(aStart, aEnd, bStart, bEnd, outPoint) {
+      return genericLineIntersection(aStart, aEnd, bStart, bEnd, true, outPoint);
+    }
+    function segmentIntersection(aStart, aEnd, bStart, bEnd, outPoint) {
+      return genericLineIntersection(aStart, aEnd, bStart, bEnd, false, outPoint);
+    }
+
+    "use strict";
+
+    "use strict";
+
+    exports.floatEqual = floatEqual;
+    exports.lineIntersection = lineIntersection;
+    exports.pointExtraMixins = pointExtraMixins;
+    exports.rectangleExtraMixins = rectangleExtraMixins;
+    exports.segmentIntersection = segmentIntersection;
+
+    return exports;
+
+})({});
+Object.assign(this.PIXI, math_extras_js);
+//# sourceMappingURL=math-extras.js.map

node_modules/pixi.js/dist/packages/math-extras.min.js

@@ -0,0 +1,8 @@
+/*!
+ * PixiJS - v8.4.1
+ * Compiled Thu, 19 Sep 2024 10:28:58 UTC
+ *
+ * PixiJS is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ */this.PIXI=this.PIXI||{};var math_extras_js=function(x){"use strict";"use strict";const s={add(t,i){return i||(i=new PIXI.Point),i.x=this.x+t.x,i.y=this.y+t.y,i},subtract(t,i){return i||(i=new PIXI.Point),i.x=this.x-t.x,i.y=this.y-t.y,i},multiply(t,i){return i||(i=new PIXI.Point),i.x=this.x*t.x,i.y=this.y*t.y,i},multiplyScalar(t,i){return i||(i=new PIXI.Point),i.x=this.x*t,i.y=this.y*t,i},dot(t){return this.x*t.x+this.y*t.y},cross(t){return this.x*t.y-this.y*t.x},normalize(t){t||(t=new PIXI.Point);const i=Math.sqrt(this.x*this.x+this.y*this.y);return t.x=this.x/i,t.y=this.y/i,t},magnitude(){return Math.sqrt(this.x*this.x+this.y*this.y)},magnitudeSquared(){return this.x*this.x+this.y*this.y},project(t,i){i||(i=new PIXI.Point);const h=(this.x*t.x+this.y*t.y)/(t.x*t.x+t.y*t.y);return i.x=t.x*h,i.y=t.y*h,i},reflect(t,i){i||(i=new PIXI.Point);const h=this.x*t.x+this.y*t.y;return i.x=this.x-2*h*t.x,i.y=this.y-2*h*t.y,i}},g={containsRect(t){return t.width<=0||t.height<=0?t.x>this.x&&t.y>this.y&&t.right<this.right&&t.bottom<this.bottom:t.x>=this.x&&t.y>=this.y&&t.right<=this.right&&t.bottom<=this.bottom},equals(t){return t===this?!0:t&&this.x===t.x&&this.y===t.y&&this.width===t.width&&this.height===t.height},intersection(t,i){i||(i=new PIXI.Rectangle);const h=this.x<t.x?t.x:this.x,r=this.right>t.right?t.right:this.right;if(r<=h)return i.x=i.y=i.width=i.height=0,i;const e=this.y<t.y?t.y:this.y,n=this.bottom>t.bottom?t.bottom:this.bottom;return n<=e?(i.x=i.y=i.width=i.height=0,i):(i.x=h,i.y=e,i.width=r-h,i.height=n-e,i)},union(t,i){i||(i=new PIXI.Rectangle);const h=Math.min(this.x,t.x),r=Math.max(this.x+this.width,t.x+t.width),e=Math.min(this.y,t.y),n=Math.max(this.y+this.height,t.y+t.height);return i.x=h,i.y=e,i.width=r-h,i.height=n-e,i}};Object.assign(PIXI.Point.prototype,s),Object.assign(PIXI.ObservablePoint.prototype,s),Object.assign(PIXI.Rectangle.prototype,g);function P(t,i,h=Number.EPSILON){return t===i?!0:Math.abs(t-i)<h}function m(t,i,h,r,e,n){n||(n=new PIXI.Point);const y=i.x-t.x,l=i.y-t.y,w=r.x-h.x,o=r.y-h.y,u=o*y-w*l;if(P(u,0))return n.x=NaN,n.y=NaN,n;const c=(w*(t.y-h.y)-o*(t.x-h.x))/u,I=(y*(t.y-h.y)-l*(t.x-h.x))/u;return!e&&(c<0||c>1||I<0||I>1)?(n.x=NaN,n.y=NaN,n):(n.x=t.x+c*y,n.y=h.y+I*o,n)}function b(t,i,h,r,e){return m(t,i,h,r,!0,e)}function X(t,i,h,r,e){return m(t,i,h,r,!1,e)}return x.floatEqual=P,x.lineIntersection=b,x.pointExtraMixins=s,x.rectangleExtraMixins=g,x.segmentIntersection=X,x}({});Object.assign(this.PIXI,math_extras_js);
+//# sourceMappingURL=math-extras.min.js.map

node_modules/pixi.js/dist/packages/unsafe-eval.js

@@ -0,0 +1,644 @@
+/*!
+ * PixiJS - v8.4.1
+ * Compiled Thu, 19 Sep 2024 10:28:58 UTC
+ *
+ * PixiJS is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ */
+this.PIXI = this.PIXI || {};
+var unsafe_eval_js = (function (exports) {
+    'use strict';
+
+    "use strict";
+
+
+
+
+    function generateShaderSyncPolyfill() {
+      return syncShader;
+    }
+    function syncShader(renderer, shader, syncData) {
+      const gl = renderer.gl;
+      const shaderSystem = renderer.shader;
+      const programData = shaderSystem._getProgramData(shader.glProgram);
+      for (const i in shader.groups) {
+        const bindGroup = shader.groups[i];
+        for (const j in bindGroup.resources) {
+          const resource = bindGroup.resources[j];
+          if (resource instanceof PIXI.UniformGroup) {
+            if (resource.ubo) {
+              shaderSystem.bindUniformBlock(
+                resource,
+                shader._uniformBindMap[i][j],
+                syncData.blockIndex++
+              );
+            } else {
+              shaderSystem.updateUniformGroup(resource);
+            }
+          } else if (resource instanceof PIXI.BufferResource) {
+            shaderSystem.bindUniformBlock(
+              resource,
+              shader._uniformBindMap[i][j],
+              syncData.blockIndex++
+            );
+          } else if (resource instanceof PIXI.TextureSource) {
+            renderer.texture.bind(resource, syncData.textureCount);
+            const uniformName = shader._uniformBindMap[i][j];
+            const uniformData = programData.uniformData[uniformName];
+            if (uniformData) {
+              if (uniformData.value !== syncData.textureCount) {
+                gl.uniform1i(uniformData.location, syncData.textureCount);
+              }
+              syncData.textureCount++;
+            }
+          } else if (resource instanceof PIXI.TextureStyle) {
+          }
+        }
+      }
+    }
+
+    "use strict";
+    const uboParserFunctions = [
+      (name, data, offset, uv, _v) => {
+        const matrix = uv[name].toArray(true);
+        data[offset] = matrix[0];
+        data[offset + 1] = matrix[1];
+        data[offset + 2] = matrix[2];
+        data[offset + 4] = matrix[3];
+        data[offset + 5] = matrix[4];
+        data[offset + 6] = matrix[5];
+        data[offset + 8] = matrix[6];
+        data[offset + 9] = matrix[7];
+        data[offset + 10] = matrix[8];
+      },
+      (name, data, offset, uv, v) => {
+        v = uv[name];
+        data[offset] = v.x;
+        data[offset + 1] = v.y;
+        data[offset + 2] = v.width;
+        data[offset + 3] = v.height;
+      },
+      (name, data, offset, uv, v) => {
+        v = uv[name];
+        data[offset] = v.x;
+        data[offset + 1] = v.y;
+      },
+      (name, data, offset, uv, v) => {
+        v = uv[name];
+        data[offset] = v.red;
+        data[offset + 1] = v.green;
+        data[offset + 2] = v.blue;
+        data[offset + 3] = v.alpha;
+      },
+      (name, data, offset, uv, v) => {
+        v = uv[name];
+        data[offset] = v.red;
+        data[offset + 1] = v.green;
+        data[offset + 2] = v.blue;
+      }
+    ];
+    const uboSingleFunctionsWGSL = {
+      f32: (_name, data, offset, _uv, v) => {
+        data[offset] = v;
+      },
+      i32: (_name, data, offset, _uv, v) => {
+        data[offset] = v;
+      },
+      "vec2<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+      },
+      "vec3<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+      },
+      "vec4<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];
+      },
+      "mat2x2<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];
+      },
+      "mat3x3<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 4] = v[3];
+        data[offset + 5] = v[4];
+        data[offset + 6] = v[5];
+        data[offset + 8] = v[6];
+        data[offset + 9] = v[7];
+        data[offset + 10] = v[8];
+      },
+      "mat4x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 16; i++) {
+          data[offset + i] = v[i];
+        }
+      },
+      "mat3x2<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 6; i++) {
+          data[offset + (i / 3 | 0) * 4 + i % 3] = v[i];
+        }
+      },
+      "mat4x2<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 8; i++) {
+          data[offset + (i / 4 | 0) * 4 + i % 4] = v[i];
+        }
+      },
+      "mat2x3<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 6; i++) {
+          data[offset + (i / 2 | 0) * 4 + i % 2] = v[i];
+        }
+      },
+      "mat4x3<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 12; i++) {
+          data[offset + (i / 4 | 0) * 4 + i % 4] = v[i];
+        }
+      },
+      "mat2x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 8; i++) {
+          data[offset + (i / 2 | 0) * 4 + i % 2] = v[i];
+        }
+      },
+      "mat3x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 12; i++) {
+          data[offset + (i / 3 | 0) * 4 + i % 3] = v[i];
+        }
+      }
+    };
+    const uboSingleFunctionsSTD40 = {
+      f32: (_name, data, offset, _uv, v) => {
+        data[offset] = v;
+      },
+      i32: (_name, data, offset, _uv, v) => {
+        data[offset] = v;
+      },
+      "vec2<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+      },
+      "vec3<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+      },
+      "vec4<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];
+      },
+      "mat2x2<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 4] = v[2];
+        data[offset + 5] = v[3];
+      },
+      "mat3x3<f32>": (_name, data, offset, _uv, v) => {
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 4] = v[3];
+        data[offset + 5] = v[4];
+        data[offset + 6] = v[5];
+        data[offset + 8] = v[6];
+        data[offset + 9] = v[7];
+        data[offset + 10] = v[8];
+      },
+      "mat4x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 16; i++) {
+          data[offset + i] = v[i];
+        }
+      },
+      "mat3x2<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 6; i++) {
+          data[offset + (i / 3 | 0) * 4 + i % 3] = v[i];
+        }
+      },
+      "mat4x2<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 8; i++) {
+          data[offset + (i / 4 | 0) * 4 + i % 4] = v[i];
+        }
+      },
+      "mat2x3<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 6; i++) {
+          data[offset + (i / 2 | 0) * 4 + i % 2] = v[i];
+        }
+      },
+      "mat4x3<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 12; i++) {
+          data[offset + (i / 4 | 0) * 4 + i % 4] = v[i];
+        }
+      },
+      "mat2x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 8; i++) {
+          data[offset + (i / 2 | 0) * 4 + i % 2] = v[i];
+        }
+      },
+      "mat3x4<f32>": (_name, data, offset, _uv, v) => {
+        for (let i = 0; i < 12; i++) {
+          data[offset + (i / 3 | 0) * 4 + i % 3] = v[i];
+        }
+      }
+    };
+
+    "use strict";
+    function generateUboSyncPolyfillSTD40(uboElements) {
+      return generateUboSyncPolyfill(
+        uboElements,
+        uboSingleFunctionsSTD40,
+        (uboElement) => {
+          const rowSize = Math.max(PIXI.WGSL_TO_STD40_SIZE[uboElement.data.type] / 16, 1);
+          const elementSize = uboElement.data.value.length / uboElement.data.size;
+          const remainder = (4 - elementSize % 4) % 4;
+          return (_name, data, offset, _uv, v) => {
+            let t = 0;
+            for (let i = 0; i < uboElement.data.size * rowSize; i++) {
+              for (let j = 0; j < elementSize; j++) {
+                data[offset++] = v[t++];
+              }
+              offset += remainder;
+            }
+          };
+        }
+      );
+    }
+    function generateUboSyncPolyfillWGSL(uboElements) {
+      return generateUboSyncPolyfill(
+        uboElements,
+        uboSingleFunctionsWGSL,
+        (uboElement) => {
+          const { size, align } = PIXI.WGSL_ALIGN_SIZE_DATA[uboElement.data.type];
+          const remainder = (size - align) / 4;
+          return (_name, data, offset, _uv, v) => {
+            let t = 0;
+            for (let i = 0; i < uboElement.data.size * (size / 4); i++) {
+              for (let j = 0; j < size / 4; j++) {
+                data[offset++] = v[t++];
+              }
+              offset += remainder;
+            }
+          };
+        }
+      );
+    }
+    function generateUboSyncPolyfill(uboElements, uboFunctions, arrayUploadFunction) {
+      const functionMap = {};
+      for (const i in uboElements) {
+        const uboElement = uboElements[i];
+        const uniform = uboElement.data;
+        let parsed = false;
+        functionMap[uniform.name] = {
+          offset: uboElement.offset / 4,
+          func: null
+        };
+        for (let j = 0; j < PIXI.uniformParsers.length; j++) {
+          const parser = PIXI.uniformParsers[j];
+          if (uniform.type === parser.type && parser.test(uniform)) {
+            functionMap[uniform.name].func = uboParserFunctions[j];
+            parsed = true;
+            break;
+          }
+        }
+        if (!parsed) {
+          if (uniform.size === 1) {
+            functionMap[uniform.name].func = uboFunctions[uniform.type];
+          } else {
+            functionMap[uniform.name].func = arrayUploadFunction(uboElement);
+          }
+        }
+      }
+      return (uniforms, data, offset) => {
+        for (const i in functionMap) {
+          functionMap[i].func(i, data, offset + functionMap[i].offset, uniforms, uniforms[i]);
+        }
+      };
+    }
+
+    "use strict";
+    const uniformSingleParserFunctions = {
+      f32(name, cu, cv, v, ud, _uv, gl) {
+        if (cv !== v) {
+          cu.value = v;
+          gl.uniform1f(ud[name].location, v);
+        }
+      },
+      "vec2<f32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          gl.uniform2f(ud[name].location, v[0], v[1]);
+        }
+      },
+      "vec3<f32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          gl.uniform3f(ud[name].location, v[0], v[1], v[2]);
+        }
+      },
+      "vec4<f32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          cv[3] = v[3];
+          gl.uniform4f(ud[name].location, v[0], v[1], v[2], v[3]);
+        }
+      },
+      i32(name, cu, cv, v, ud, _uv, gl) {
+        if (cv !== v) {
+          cu.value = v;
+          gl.uniform1i(ud[name].location, v);
+        }
+      },
+      "vec2<i32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          gl.uniform2i(ud[name].location, v[0], v[1]);
+        }
+      },
+      "vec3<i32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          gl.uniform3i(ud[name].location, v[0], v[1], v[2]);
+        }
+      },
+      "vec4<i32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          cv[3] = v[3];
+          gl.uniform4i(ud[name].location, v[0], v[1], v[2], v[3]);
+        }
+      },
+      u32(name, cu, cv, v, ud, _uv, gl) {
+        if (cv !== v) {
+          cu.value = v;
+          gl.uniform1ui(ud[name].location, v);
+        }
+      },
+      "vec2<u32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          gl.uniform2ui(ud[name].location, v[0], v[1]);
+        }
+      },
+      "vec3<u32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          gl.uniform3ui(ud[name].location, v[0], v[1], v[2]);
+        }
+      },
+      "vec4<u32>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          cv[3] = v[3];
+          gl.uniform4ui(ud[name].location, v[0], v[1], v[2], v[3]);
+        }
+      },
+      bool(name, cu, cv, v, ud, _uv, gl) {
+        if (cv !== v) {
+          cu.value = v;
+          gl.uniform1i(ud[name].location, v);
+        }
+      },
+      "vec2<bool>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          gl.uniform2i(ud[name].location, v[0], v[1]);
+        }
+      },
+      "vec3<bool>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          gl.uniform3i(ud[name].location, v[0], v[1], v[2]);
+        }
+      },
+      "vec4<bool>"(name, _cu, cv, v, ud, _uv, gl) {
+        if (cv[0] !== v[0] || cv[1] !== v[1] || cv[2] !== v[2] || cv[3] !== v[3]) {
+          cv[0] = v[0];
+          cv[1] = v[1];
+          cv[2] = v[2];
+          cv[3] = v[3];
+          gl.uniform4i(ud[name].location, v[0], v[1], v[2], v[3]);
+        }
+      },
+      "mat2x2<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix2fv(ud[name].location, false, v);
+      },
+      "mat3x3<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix3fv(ud[name].location, false, v);
+      },
+      "mat4x4<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix4fv(ud[name].location, false, v);
+      }
+    };
+    const uniformArrayParserFunctions = {
+      f32(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform1fv(ud[name].location, v);
+      },
+      "vec2<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform2fv(ud[name].location, v);
+      },
+      "vec3<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform3fv(ud[name].location, v);
+      },
+      "vec4<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform4fv(ud[name].location, v);
+      },
+      "mat2x2<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix2fv(ud[name].location, false, v);
+      },
+      "mat3x3<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix3fv(ud[name].location, false, v);
+      },
+      "mat4x4<f32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniformMatrix4fv(ud[name].location, false, v);
+      },
+      i32(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform1iv(ud[name].location, v);
+      },
+      "vec2<i32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform2iv(ud[name].location, v);
+      },
+      "vec3<i32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform3iv(ud[name].location, v);
+      },
+      "vec4<i32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform4iv(ud[name].location, v);
+      },
+      u32(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform1iv(ud[name].location, v);
+      },
+      "vec2<u32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform2iv(ud[name].location, v);
+      },
+      "vec3<u32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform3iv(ud[name].location, v);
+      },
+      "vec4<u32>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform4iv(ud[name].location, v);
+      },
+      bool(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform1iv(ud[name].location, v);
+      },
+      "vec2<bool>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform2iv(ud[name].location, v);
+      },
+      "vec3<bool>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform3iv(ud[name].location, v);
+      },
+      "vec4<bool>"(name, _cu, _cv, v, ud, _uv, gl) {
+        gl.uniform4iv(ud[name].location, v);
+      }
+    };
+    const uniformParserFunctions = [
+      (name, _cu, _cv, _v, ud, uv, gl) => {
+        gl.uniformMatrix3fv(ud[name].location, false, uv[name].toArray(true));
+      },
+      (name, _cu, cv, v, ud, uv, gl) => {
+        cv = ud[name].value;
+        v = uv[name];
+        if (cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height) {
+          cv[0] = v.x;
+          cv[1] = v.y;
+          cv[2] = v.width;
+          cv[3] = v.height;
+          gl.uniform4f(ud[name].location, v.x, v.y, v.width, v.height);
+        }
+      },
+      (name, _cu, cv, v, ud, uv, gl) => {
+        cv = ud[name].value;
+        v = uv[name];
+        if (cv[0] !== v.x || cv[1] !== v.y) {
+          cv[0] = v.x;
+          cv[1] = v.y;
+          gl.uniform2f(ud[name].location, v.x, v.y);
+        }
+      },
+      (name, _cu, cv, v, ud, uv, gl) => {
+        cv = ud[name].value;
+        v = uv[name];
+        if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue || cv[3] !== v.alpha) {
+          cv[0] = v.red;
+          cv[1] = v.green;
+          cv[2] = v.blue;
+          cv[3] = v.alpha;
+          gl.uniform4f(ud[name].location, v.red, v.green, v.blue, v.alpha);
+        }
+      },
+      (name, _cu, cv, v, ud, uv, gl) => {
+        cv = ud[name].value;
+        v = uv[name];
+        if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue) {
+          cv[0] = v.red;
+          cv[1] = v.green;
+          cv[2] = v.blue;
+          gl.uniform3f(ud[name].location, v.red, v.green, v.blue);
+        }
+      }
+    ];
+
+    "use strict";
+    function generateUniformsSyncPolyfill(group, uniformData) {
+      const functionMap = {};
+      for (const i in group.uniformStructures) {
+        if (!uniformData[i])
+          continue;
+        const uniform = group.uniformStructures[i];
+        let parsed = false;
+        for (let j = 0; j < PIXI.uniformParsers.length; j++) {
+          const parser = PIXI.uniformParsers[j];
+          if (uniform.type === parser.type && parser.test(uniform)) {
+            functionMap[i] = uniformParserFunctions[j];
+            parsed = true;
+            break;
+          }
+        }
+        if (!parsed) {
+          const templateType = uniform.size === 1 ? uniformSingleParserFunctions : uniformArrayParserFunctions;
+          functionMap[i] = templateType[uniform.type];
+        }
+      }
+      return (ud, uv, renderer) => {
+        const gl = renderer.gl;
+        for (const i in functionMap) {
+          const v = uv[i];
+          const cu = ud[i];
+          const cv = ud[i].value;
+          functionMap[i](i, cu, cv, v, ud, uv, gl);
+        }
+      };
+    }
+
+    "use strict";
+    function selfInstall() {
+      Object.assign(PIXI.AbstractRenderer.prototype, {
+        // override unsafeEval check, as we don't need to use it
+        _unsafeEvalCheck() {
+        }
+      });
+      Object.assign(PIXI.UboSystem.prototype, {
+        // override unsafeEval check, as we don't need to use it
+        _systemCheck() {
+        }
+      });
+      Object.assign(PIXI.GlUniformGroupSystem.prototype, {
+        // use polyfill which avoids eval method
+        _generateUniformsSync: generateUniformsSyncPolyfill
+      });
+      Object.assign(PIXI.GlUboSystem.prototype, {
+        // use polyfill which avoids eval method
+        _generateUboSync: generateUboSyncPolyfillSTD40
+      });
+      Object.assign(PIXI.GpuUboSystem.prototype, {
+        // use polyfill which avoids eval method
+        _generateUboSync: generateUboSyncPolyfillWGSL
+      });
+      Object.assign(PIXI.GlShaderSystem.prototype, {
+        // use polyfill which avoids eval method
+        _generateShaderSync: generateShaderSyncPolyfill
+      });
+    }
+    selfInstall();
+
+    "use strict";
+
+    "use strict";
+
+    exports.generateShaderSyncPolyfill = generateShaderSyncPolyfill;
+    exports.generateUboSyncPolyfillSTD40 = generateUboSyncPolyfillSTD40;
+    exports.generateUboSyncPolyfillWGSL = generateUboSyncPolyfillWGSL;
+    exports.generateUniformsSyncPolyfill = generateUniformsSyncPolyfill;
+    exports.uboParserFunctions = uboParserFunctions;
+    exports.uboSingleFunctionsSTD40 = uboSingleFunctionsSTD40;
+    exports.uboSingleFunctionsWGSL = uboSingleFunctionsWGSL;
+    exports.uniformArrayParserFunctions = uniformArrayParserFunctions;
+    exports.uniformParserFunctions = uniformParserFunctions;
+    exports.uniformSingleParserFunctions = uniformSingleParserFunctions;
+
+    return exports;
+
+})({});
+Object.assign(this.PIXI, unsafe_eval_js);
+//# sourceMappingURL=unsafe-eval.js.map

node_modules/pixi.js/lib/Shaders.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="@webgpu/types" />
+
+declare module '*.wgsl'
+{
+    const shader: 'string';
+
+    export default shader;
+}
+
+declare module '*.vert'
+{
+    const shader: 'string';
+
+    export default shader;
+}
+
+declare module '*.frag'
+{
+    const shader: 'string';
+
+    export default shader;
+}

node_modules/pixi.js/lib/_virtual/basis.worker.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    function createLevelBuffers(basisTexture, basisTranscoderFormat) {\n      const images = basisTexture.getNumImages();\n      const levels = basisTexture.getNumLevels(0);\n      const success = basisTexture.startTranscoding();\n      if (!success) {\n        throw new Error(\"startTranscoding failed\");\n      }\n      const levelBuffers = [];\n      for (let levelIndex = 0; levelIndex < levels; ++levelIndex) {\n        for (let sliceIndex = 0; sliceIndex < images; ++sliceIndex) {\n          const transcodeSize = basisTexture.getImageTranscodedSizeInBytes(sliceIndex, levelIndex, basisTranscoderFormat);\n          const levelBuffer = new Uint8Array(transcodeSize);\n          const success2 = basisTexture.transcodeImage(levelBuffer, sliceIndex, levelIndex, basisTranscoderFormat, 1, 0);\n          if (!success2) {\n            throw new Error(\"transcodeImage failed\");\n          }\n          levelBuffers.push(levelBuffer);\n        }\n      }\n      return levelBuffers;\n    }\n\n    const gpuFormatToBasisTranscoderFormatMap = {\n      \"bc3-rgba-unorm\": 3,\n      // cTFBC3_RGBA\n      \"bc7-rgba-unorm\": 6,\n      // cTFBC7_RGBA,\n      \"etc2-rgba8unorm\": 1,\n      // cTFETC2_RGBA,\n      \"astc-4x4-unorm\": 10,\n      // cTFASTC_4x4_RGBA,\n      // Uncompressed\n      rgba8unorm: 13,\n      // cTFRGBA32,\n      rgba4unorm: 16\n      // cTFRGBA4444,\n    };\n    function gpuFormatToBasisTranscoderFormat(transcoderFormat) {\n      const format = gpuFormatToBasisTranscoderFormatMap[transcoderFormat];\n      if (format) {\n        return format;\n      }\n      throw new Error(`Unsupported transcoderFormat: ${transcoderFormat}`);\n    }\n\n    const settings = {\n      jsUrl: \"basis/basis_transcoder.js\",\n      wasmUrl: \"basis/basis_transcoder.wasm\"\n    };\n    let basisTranscoderFormat;\n    let basisTranscodedTextureFormat;\n    let basisPromise;\n    async function getBasis() {\n      if (!basisPromise) {\n        const absoluteJsUrl = new URL(settings.jsUrl, location.origin).href;\n        const absoluteWasmUrl = new URL(settings.wasmUrl, location.origin).href;\n        importScripts(absoluteJsUrl);\n        basisPromise = new Promise((resolve) => {\n          BASIS({\n            locateFile: (_file) => absoluteWasmUrl\n          }).then((module) => {\n            module.initializeBasis();\n            resolve(module.BasisFile);\n          });\n        });\n      }\n      return basisPromise;\n    }\n    async function fetchBasisTexture(url, BasisTexture) {\n      const basisResponse = await fetch(url);\n      if (basisResponse.ok) {\n        const basisArrayBuffer = await basisResponse.arrayBuffer();\n        return new BasisTexture(new Uint8Array(basisArrayBuffer));\n      }\n      throw new Error(`Failed to load Basis texture: ${url}`);\n    }\n    const preferredTranscodedFormat = [\n      \"bc7-rgba-unorm\",\n      \"astc-4x4-unorm\",\n      \"etc2-rgba8unorm\",\n      \"bc3-rgba-unorm\",\n      \"rgba8unorm\"\n    ];\n    async function load(url) {\n      const BasisTexture = await getBasis();\n      const basisTexture = await fetchBasisTexture(url, BasisTexture);\n      const levelBuffers = createLevelBuffers(basisTexture, basisTranscoderFormat);\n      return {\n        width: basisTexture.getImageWidth(0, 0),\n        height: basisTexture.getImageHeight(0, 0),\n        format: basisTranscodedTextureFormat,\n        resource: levelBuffers,\n        alphaMode: \"no-premultiply-alpha\"\n      };\n    }\n    async function init(jsUrl, wasmUrl, supportedTextures) {\n      if (jsUrl)\n        settings.jsUrl = jsUrl;\n      if (wasmUrl)\n        settings.wasmUrl = wasmUrl;\n      basisTranscodedTextureFormat = preferredTranscodedFormat.filter((format) => supportedTextures.includes(format))[0];\n      basisTranscoderFormat = gpuFormatToBasisTranscoderFormat(basisTranscodedTextureFormat);\n      await getBasis();\n    }\n    const messageHandlers = {\n      init: async (data) => {\n        const { jsUrl, wasmUrl, supportedTextures } = data;\n        await init(jsUrl, wasmUrl, supportedTextures);\n      },\n      load: async (data) => {\n        try {\n          const textureOptions = await load(data.url);\n          return {\n            type: \"load\",\n            url: data.url,\n            success: true,\n            textureOptions,\n            transferables: textureOptions.resource?.map((arr) => arr.buffer)\n          };\n        } catch (e) {\n          throw e;\n        }\n      }\n    };\n    self.onmessage = async (messageEvent) => {\n      const message = messageEvent.data;\n      const response = await messageHandlers[message.type](message);\n      if (response) {\n        self.postMessage(response, response.transferables);\n      }\n    };\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+exports.default = WorkerInstance;
+//# sourceMappingURL=basis.worker.js.map

node_modules/pixi.js/lib/_virtual/basis.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basis.worker.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/basis.worker.mjs

@@ -0,0 +1,24 @@
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    function createLevelBuffers(basisTexture, basisTranscoderFormat) {\n      const images = basisTexture.getNumImages();\n      const levels = basisTexture.getNumLevels(0);\n      const success = basisTexture.startTranscoding();\n      if (!success) {\n        throw new Error(\"startTranscoding failed\");\n      }\n      const levelBuffers = [];\n      for (let levelIndex = 0; levelIndex < levels; ++levelIndex) {\n        for (let sliceIndex = 0; sliceIndex < images; ++sliceIndex) {\n          const transcodeSize = basisTexture.getImageTranscodedSizeInBytes(sliceIndex, levelIndex, basisTranscoderFormat);\n          const levelBuffer = new Uint8Array(transcodeSize);\n          const success2 = basisTexture.transcodeImage(levelBuffer, sliceIndex, levelIndex, basisTranscoderFormat, 1, 0);\n          if (!success2) {\n            throw new Error(\"transcodeImage failed\");\n          }\n          levelBuffers.push(levelBuffer);\n        }\n      }\n      return levelBuffers;\n    }\n\n    const gpuFormatToBasisTranscoderFormatMap = {\n      \"bc3-rgba-unorm\": 3,\n      // cTFBC3_RGBA\n      \"bc7-rgba-unorm\": 6,\n      // cTFBC7_RGBA,\n      \"etc2-rgba8unorm\": 1,\n      // cTFETC2_RGBA,\n      \"astc-4x4-unorm\": 10,\n      // cTFASTC_4x4_RGBA,\n      // Uncompressed\n      rgba8unorm: 13,\n      // cTFRGBA32,\n      rgba4unorm: 16\n      // cTFRGBA4444,\n    };\n    function gpuFormatToBasisTranscoderFormat(transcoderFormat) {\n      const format = gpuFormatToBasisTranscoderFormatMap[transcoderFormat];\n      if (format) {\n        return format;\n      }\n      throw new Error(`Unsupported transcoderFormat: ${transcoderFormat}`);\n    }\n\n    const settings = {\n      jsUrl: \"basis/basis_transcoder.js\",\n      wasmUrl: \"basis/basis_transcoder.wasm\"\n    };\n    let basisTranscoderFormat;\n    let basisTranscodedTextureFormat;\n    let basisPromise;\n    async function getBasis() {\n      if (!basisPromise) {\n        const absoluteJsUrl = new URL(settings.jsUrl, location.origin).href;\n        const absoluteWasmUrl = new URL(settings.wasmUrl, location.origin).href;\n        importScripts(absoluteJsUrl);\n        basisPromise = new Promise((resolve) => {\n          BASIS({\n            locateFile: (_file) => absoluteWasmUrl\n          }).then((module) => {\n            module.initializeBasis();\n            resolve(module.BasisFile);\n          });\n        });\n      }\n      return basisPromise;\n    }\n    async function fetchBasisTexture(url, BasisTexture) {\n      const basisResponse = await fetch(url);\n      if (basisResponse.ok) {\n        const basisArrayBuffer = await basisResponse.arrayBuffer();\n        return new BasisTexture(new Uint8Array(basisArrayBuffer));\n      }\n      throw new Error(`Failed to load Basis texture: ${url}`);\n    }\n    const preferredTranscodedFormat = [\n      \"bc7-rgba-unorm\",\n      \"astc-4x4-unorm\",\n      \"etc2-rgba8unorm\",\n      \"bc3-rgba-unorm\",\n      \"rgba8unorm\"\n    ];\n    async function load(url) {\n      const BasisTexture = await getBasis();\n      const basisTexture = await fetchBasisTexture(url, BasisTexture);\n      const levelBuffers = createLevelBuffers(basisTexture, basisTranscoderFormat);\n      return {\n        width: basisTexture.getImageWidth(0, 0),\n        height: basisTexture.getImageHeight(0, 0),\n        format: basisTranscodedTextureFormat,\n        resource: levelBuffers,\n        alphaMode: \"no-premultiply-alpha\"\n      };\n    }\n    async function init(jsUrl, wasmUrl, supportedTextures) {\n      if (jsUrl)\n        settings.jsUrl = jsUrl;\n      if (wasmUrl)\n        settings.wasmUrl = wasmUrl;\n      basisTranscodedTextureFormat = preferredTranscodedFormat.filter((format) => supportedTextures.includes(format))[0];\n      basisTranscoderFormat = gpuFormatToBasisTranscoderFormat(basisTranscodedTextureFormat);\n      await getBasis();\n    }\n    const messageHandlers = {\n      init: async (data) => {\n        const { jsUrl, wasmUrl, supportedTextures } = data;\n        await init(jsUrl, wasmUrl, supportedTextures);\n      },\n      load: async (data) => {\n        try {\n          const textureOptions = await load(data.url);\n          return {\n            type: \"load\",\n            url: data.url,\n            success: true,\n            textureOptions,\n            transferables: textureOptions.resource?.map((arr) => arr.buffer)\n          };\n        } catch (e) {\n          throw e;\n        }\n      }\n    };\n    self.onmessage = async (messageEvent) => {\n      const message = messageEvent.data;\n      const response = await messageHandlers[message.type](message);\n      if (response) {\n        self.postMessage(response, response.transferables);\n      }\n    };\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+export { WorkerInstance as default };
+//# sourceMappingURL=basis.worker.mjs.map

node_modules/pixi.js/lib/_virtual/basis.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"basis.worker.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/checkImageBitmap.worker.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    const WHITE_PNG = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=\";\n    async function checkImageBitmap() {\n      try {\n        if (typeof createImageBitmap !== \"function\")\n          return false;\n        const response = await fetch(WHITE_PNG);\n        const imageBlob = await response.blob();\n        const imageBitmap = await createImageBitmap(imageBlob);\n        return imageBitmap.width === 1 && imageBitmap.height === 1;\n      } catch (e) {\n        return false;\n      }\n    }\n    void checkImageBitmap().then((result) => {\n      self.postMessage(result);\n    });\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+exports.default = WorkerInstance;
+//# sourceMappingURL=checkImageBitmap.worker.js.map

node_modules/pixi.js/lib/_virtual/checkImageBitmap.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkImageBitmap.worker.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/checkImageBitmap.worker.mjs

@@ -0,0 +1,24 @@
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    const WHITE_PNG = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=\";\n    async function checkImageBitmap() {\n      try {\n        if (typeof createImageBitmap !== \"function\")\n          return false;\n        const response = await fetch(WHITE_PNG);\n        const imageBlob = await response.blob();\n        const imageBitmap = await createImageBitmap(imageBlob);\n        return imageBitmap.width === 1 && imageBitmap.height === 1;\n      } catch (e) {\n        return false;\n      }\n    }\n    void checkImageBitmap().then((result) => {\n      self.postMessage(result);\n    });\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+export { WorkerInstance as default };
+//# sourceMappingURL=checkImageBitmap.worker.mjs.map

node_modules/pixi.js/lib/_virtual/checkImageBitmap.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkImageBitmap.worker.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/ktx.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx.worker.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/ktx.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx.worker.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/loadImageBitmap.worker.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    async function loadImageBitmap(url, alphaMode) {\n      const response = await fetch(url);\n      if (!response.ok) {\n        throw new Error(`[WorkerManager.loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);\n      }\n      const imageBlob = await response.blob();\n      return alphaMode === \"premultiplied-alpha\" ? createImageBitmap(imageBlob, { premultiplyAlpha: \"none\" }) : createImageBitmap(imageBlob);\n    }\n    self.onmessage = async (event) => {\n      try {\n        const imageBitmap = await loadImageBitmap(event.data.data[0], event.data.data[1]);\n        self.postMessage({\n          data: imageBitmap,\n          uuid: event.data.uuid,\n          id: event.data.id\n        }, [imageBitmap]);\n      } catch (e) {\n        self.postMessage({\n          error: e,\n          uuid: event.data.uuid,\n          id: event.data.id\n        });\n      }\n    };\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+exports.default = WorkerInstance;
+//# sourceMappingURL=loadImageBitmap.worker.js.map

node_modules/pixi.js/lib/_virtual/loadImageBitmap.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadImageBitmap.worker.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/_virtual/loadImageBitmap.worker.mjs

@@ -0,0 +1,24 @@
+const WORKER_CODE = "(function () {\n    'use strict';\n\n    async function loadImageBitmap(url, alphaMode) {\n      const response = await fetch(url);\n      if (!response.ok) {\n        throw new Error(`[WorkerManager.loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);\n      }\n      const imageBlob = await response.blob();\n      return alphaMode === \"premultiplied-alpha\" ? createImageBitmap(imageBlob, { premultiplyAlpha: \"none\" }) : createImageBitmap(imageBlob);\n    }\n    self.onmessage = async (event) => {\n      try {\n        const imageBitmap = await loadImageBitmap(event.data.data[0], event.data.data[1]);\n        self.postMessage({\n          data: imageBitmap,\n          uuid: event.data.uuid,\n          id: event.data.id\n        }, [imageBitmap]);\n      } catch (e) {\n        self.postMessage({\n          error: e,\n          uuid: event.data.uuid,\n          id: event.data.id\n        });\n      }\n    };\n\n})();\n";
+let WORKER_URL = null;
+class WorkerInstance
+{
+    constructor()
+    {
+        if (!WORKER_URL)
+        {
+            WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: 'application/javascript' }));
+        }
+        this.worker = new Worker(WORKER_URL);
+    }
+}
+WorkerInstance.revokeObjectURL = function revokeObjectURL()
+{
+    if (WORKER_URL)
+    {
+        URL.revokeObjectURL(WORKER_URL);
+        WORKER_URL = null;
+    }
+};
+
+export { WorkerInstance as default };
+//# sourceMappingURL=loadImageBitmap.worker.mjs.map

node_modules/pixi.js/lib/_virtual/loadImageBitmap.worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadImageBitmap.worker.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/pixi.js/lib/accessibility/AccessibilityMixins.d.ts

@@ -0,0 +1,18 @@
+declare global
+{
+    namespace PixiMixins
+    {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+        interface Container extends Partial<import('./accessibilityTarget').AccessibleTarget> {}
+
+        // eslint-disable-next-line @typescript-eslint/no-empty-interface
+        interface ContainerOptions extends Partial<import('./accessibilityTarget').AccessibleOptions> {}
+
+        interface RendererSystems
+        {
+            accessibility: import('./AccessibilitySystem').AccessibilitySystem;
+        }
+    }
+}
+
+export {};

node_modules/pixi.js/lib/accessibility/AccessibilitySystem.d.ts

@@ -0,0 +1,164 @@
+import { ExtensionType } from '../extensions/Extensions';
+import type { System } from '../rendering/renderers/shared/system/System';
+import type { Renderer } from '../rendering/renderers/types';
+import type { isMobileResult } from '../utils/browser/isMobile';
+/** @ignore */
+export interface AccessibilityOptions {
+    /** Setting this to true will visually show the divs. */
+    debug?: boolean;
+}
+/**
+ * The Accessibility system recreates the ability to tab and have content read by screen readers.
+ * This is very important as it can possibly help people with disabilities access PixiJS content.
+ *
+ * A Container can be made accessible just like it can be made interactive. This manager will map the
+ * events as if the mouse was being used, minimizing the effort required to implement.
+ *
+ * An instance of this class is automatically created by default, and can be found at `renderer.accessibility`
+ * @memberof accessibility
+ */
+export declare class AccessibilitySystem implements System<AccessibilityOptions> {
+    private readonly _mobileInfo;
+    /** @ignore */
+    static extension: {
+        readonly type: readonly [ExtensionType.WebGLSystem, ExtensionType.WebGPUSystem];
+        readonly name: "accessibility";
+    };
+    /** Setting this to true will visually show the divs. */
+    debug: boolean;
+    /**
+     * The renderer this accessibility manager works for.
+     * @type {WebGLRenderer|WebGPURenderer}
+     */
+    private _renderer;
+    /** Internal variable, see isActive getter. */
+    private _isActive;
+    /** Internal variable, see isMobileAccessibility getter. */
+    private _isMobileAccessibility;
+    /** Button element for handling touch hooks. */
+    private _hookDiv;
+    /** This is the dom element that will sit over the PixiJS element. This is where the div overlays will go. */
+    private _div;
+    /** A simple pool for storing divs. */
+    private _pool;
+    /** This is a tick used to check if an object is no longer being rendered. */
+    private _renderId;
+    /** The array of currently active accessible items. */
+    private _children;
+    /** Count to throttle div updates on android devices. */
+    private _androidUpdateCount;
+    /**  The frequency to update the div elements. */
+    private readonly _androidUpdateFrequency;
+    /**
+     * @param {WebGLRenderer|WebGPURenderer} renderer - A reference to the current renderer
+     */
+    constructor(renderer: Renderer, _mobileInfo?: isMobileResult);
+    /**
+     * Value of `true` if accessibility is currently active and accessibility layers are showing.
+     * @member {boolean}
+     * @readonly
+     */
+    get isActive(): boolean;
+    /**
+     * Value of `true` if accessibility is enabled for touch devices.
+     * @member {boolean}
+     * @readonly
+     */
+    get isMobileAccessibility(): boolean;
+    get hookDiv(): HTMLElement;
+    /**
+     * Creates the touch hooks.
+     * @private
+     */
+    private _createTouchHook;
+    /**
+     * Destroys the touch hooks.
+     * @private
+     */
+    private _destroyTouchHook;
+    /**
+     * Activating will cause the Accessibility layer to be shown.
+     * This is called when a user presses the tab key.
+     * @private
+     */
+    private _activate;
+    /**
+     * Deactivating will cause the Accessibility layer to be hidden.
+     * This is called when a user moves the mouse.
+     * @private
+     */
+    private _deactivate;
+    /**
+     * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.
+     * @private
+     * @param {Container} container - The Container to check.
+     */
+    private _updateAccessibleObjects;
+    /**
+     * Runner init called, view is available at this point.
+     * @ignore
+     */
+    init(options?: AccessibilityOptions): void;
+    /**
+     * Runner postrender was called, ensure that all divs are mapped correctly to their Containers.
+     * Only fires while active.
+     * @ignore
+     */
+    postrender(): void;
+    /**
+     * private function that will visually add the information to the
+     * accessibility div
+     * @param {HTMLElement} div -
+     */
+    private _updateDebugHTML;
+    /**
+     * Adjust the hit area based on the bounds of a display object
+     * @param {Rectangle} hitArea - Bounds of the child
+     */
+    private _capHitArea;
+    /**
+     * Adds a Container to the accessibility manager
+     * @private
+     * @param {Container} container - The child to make accessible.
+     */
+    private _addChild;
+    /**
+     * Dispatch events with the EventSystem.
+     * @param e
+     * @param type
+     * @private
+     */
+    private _dispatchEvent;
+    /**
+     * Maps the div button press to pixi's EventSystem (click)
+     * @private
+     * @param {MouseEvent} e - The click event.
+     */
+    private _onClick;
+    /**
+     * Maps the div focus events to pixi's EventSystem (mouseover)
+     * @private
+     * @param {FocusEvent} e - The focus event.
+     */
+    private _onFocus;
+    /**
+     * Maps the div focus events to pixi's EventSystem (mouseout)
+     * @private
+     * @param {FocusEvent} e - The focusout event.
+     */
+    private _onFocusOut;
+    /**
+     * Is called when a key is pressed
+     * @private
+     * @param {KeyboardEvent} e - The keydown event.
+     */
+    private _onKeyDown;
+    /**
+     * Is called when the mouse moves across the renderer element
+     * @private
+     * @param {MouseEvent} e - The mouse event.
+     */
+    private _onMouseMove;
+    /** Destroys the accessibility manager */
+    destroy(): void;
+}

node_modules/pixi.js/lib/accessibility/AccessibilitySystem.js

@@ -0,0 +1,404 @@
+'use strict';
+
+var FederatedEvent = require('../events/FederatedEvent.js');
+var Extensions = require('../extensions/Extensions.js');
+var isMobile = require('../utils/browser/isMobile.js');
+var removeItems = require('../utils/data/removeItems.js');
+
+"use strict";
+const KEY_CODE_TAB = 9;
+const DIV_TOUCH_SIZE = 100;
+const DIV_TOUCH_POS_X = 0;
+const DIV_TOUCH_POS_Y = 0;
+const DIV_TOUCH_ZINDEX = 2;
+const DIV_HOOK_SIZE = 1;
+const DIV_HOOK_POS_X = -1e3;
+const DIV_HOOK_POS_Y = -1e3;
+const DIV_HOOK_ZINDEX = 2;
+class AccessibilitySystem {
+  // 2fps
+  // eslint-disable-next-line jsdoc/require-param
+  /**
+   * @param {WebGLRenderer|WebGPURenderer} renderer - A reference to the current renderer
+   */
+  constructor(renderer, _mobileInfo = isMobile.isMobile) {
+    this._mobileInfo = _mobileInfo;
+    /** Setting this to true will visually show the divs. */
+    this.debug = false;
+    /** Internal variable, see isActive getter. */
+    this._isActive = false;
+    /** Internal variable, see isMobileAccessibility getter. */
+    this._isMobileAccessibility = false;
+    /** A simple pool for storing divs. */
+    this._pool = [];
+    /** This is a tick used to check if an object is no longer being rendered. */
+    this._renderId = 0;
+    /** The array of currently active accessible items. */
+    this._children = [];
+    /** Count to throttle div updates on android devices. */
+    this._androidUpdateCount = 0;
+    /**  The frequency to update the div elements. */
+    this._androidUpdateFrequency = 500;
+    this._hookDiv = null;
+    if (_mobileInfo.tablet || _mobileInfo.phone) {
+      this._createTouchHook();
+    }
+    const div = document.createElement("div");
+    div.style.width = `${DIV_TOUCH_SIZE}px`;
+    div.style.height = `${DIV_TOUCH_SIZE}px`;
+    div.style.position = "absolute";
+    div.style.top = `${DIV_TOUCH_POS_X}px`;
+    div.style.left = `${DIV_TOUCH_POS_Y}px`;
+    div.style.zIndex = DIV_TOUCH_ZINDEX.toString();
+    this._div = div;
+    this._renderer = renderer;
+    this._onKeyDown = this._onKeyDown.bind(this);
+    this._onMouseMove = this._onMouseMove.bind(this);
+    globalThis.addEventListener("keydown", this._onKeyDown, false);
+  }
+  /**
+   * Value of `true` if accessibility is currently active and accessibility layers are showing.
+   * @member {boolean}
+   * @readonly
+   */
+  get isActive() {
+    return this._isActive;
+  }
+  /**
+   * Value of `true` if accessibility is enabled for touch devices.
+   * @member {boolean}
+   * @readonly
+   */
+  get isMobileAccessibility() {
+    return this._isMobileAccessibility;
+  }
+  get hookDiv() {
+    return this._hookDiv;
+  }
+  /**
+   * Creates the touch hooks.
+   * @private
+   */
+  _createTouchHook() {
+    const hookDiv = document.createElement("button");
+    hookDiv.style.width = `${DIV_HOOK_SIZE}px`;
+    hookDiv.style.height = `${DIV_HOOK_SIZE}px`;
+    hookDiv.style.position = "absolute";
+    hookDiv.style.top = `${DIV_HOOK_POS_X}px`;
+    hookDiv.style.left = `${DIV_HOOK_POS_Y}px`;
+    hookDiv.style.zIndex = DIV_HOOK_ZINDEX.toString();
+    hookDiv.style.backgroundColor = "#FF0000";
+    hookDiv.title = "select to enable accessibility for this content";
+    hookDiv.addEventListener("focus", () => {
+      this._isMobileAccessibility = true;
+      this._activate();
+      this._destroyTouchHook();
+    });
+    document.body.appendChild(hookDiv);
+    this._hookDiv = hookDiv;
+  }
+  /**
+   * Destroys the touch hooks.
+   * @private
+   */
+  _destroyTouchHook() {
+    if (!this._hookDiv) {
+      return;
+    }
+    document.body.removeChild(this._hookDiv);
+    this._hookDiv = null;
+  }
+  /**
+   * Activating will cause the Accessibility layer to be shown.
+   * This is called when a user presses the tab key.
+   * @private
+   */
+  _activate() {
+    if (this._isActive) {
+      return;
+    }
+    this._isActive = true;
+    globalThis.document.addEventListener("mousemove", this._onMouseMove, true);
+    globalThis.removeEventListener("keydown", this._onKeyDown, false);
+    this._renderer.runners.postrender.add(this);
+    this._renderer.view.canvas.parentNode?.appendChild(this._div);
+  }
+  /**
+   * Deactivating will cause the Accessibility layer to be hidden.
+   * This is called when a user moves the mouse.
+   * @private
+   */
+  _deactivate() {
+    if (!this._isActive || this._isMobileAccessibility) {
+      return;
+    }
+    this._isActive = false;
+    globalThis.document.removeEventListener("mousemove", this._onMouseMove, true);
+    globalThis.addEventListener("keydown", this._onKeyDown, false);
+    this._renderer.runners.postrender.remove(this);
+    this._div.parentNode?.removeChild(this._div);
+  }
+  /**
+   * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.
+   * @private
+   * @param {Container} container - The Container to check.
+   */
+  _updateAccessibleObjects(container) {
+    if (!container.visible || !container.accessibleChildren) {
+      return;
+    }
+    if (container.accessible && container.isInteractive()) {
+      if (!container._accessibleActive) {
+        this._addChild(container);
+      }
+      container._renderId = this._renderId;
+    }
+    const children = container.children;
+    if (children) {
+      for (let i = 0; i < children.length; i++) {
+        this._updateAccessibleObjects(children[i]);
+      }
+    }
+  }
+  /**
+   * Runner init called, view is available at this point.
+   * @ignore
+   */
+  init(options) {
+    this.debug = options?.debug ?? this.debug;
+    this._renderer.runners.postrender.remove(this);
+  }
+  /**
+   * Runner postrender was called, ensure that all divs are mapped correctly to their Containers.
+   * Only fires while active.
+   * @ignore
+   */
+  postrender() {
+    const now = performance.now();
+    if (this._mobileInfo.android.device && now < this._androidUpdateCount) {
+      return;
+    }
+    this._androidUpdateCount = now + this._androidUpdateFrequency;
+    if (!this._renderer.renderingToScreen || !this._renderer.view.canvas) {
+      return;
+    }
+    if (this._renderer.lastObjectRendered) {
+      this._updateAccessibleObjects(this._renderer.lastObjectRendered);
+    }
+    const { x, y, width, height } = this._renderer.view.canvas.getBoundingClientRect();
+    const { width: viewWidth, height: viewHeight, resolution } = this._renderer;
+    const sx = width / viewWidth * resolution;
+    const sy = height / viewHeight * resolution;
+    let div = this._div;
+    div.style.left = `${x}px`;
+    div.style.top = `${y}px`;
+    div.style.width = `${viewWidth}px`;
+    div.style.height = `${viewHeight}px`;
+    for (let i = 0; i < this._children.length; i++) {
+      const child = this._children[i];
+      if (child._renderId !== this._renderId) {
+        child._accessibleActive = false;
+        removeItems.removeItems(this._children, i, 1);
+        this._div.removeChild(child._accessibleDiv);
+        this._pool.push(child._accessibleDiv);
+        child._accessibleDiv = null;
+        i--;
+      } else {
+        div = child._accessibleDiv;
+        let hitArea = child.hitArea;
+        const wt = child.worldTransform;
+        if (child.hitArea) {
+          div.style.left = `${(wt.tx + hitArea.x * wt.a) * sx}px`;
+          div.style.top = `${(wt.ty + hitArea.y * wt.d) * sy}px`;
+          div.style.width = `${hitArea.width * wt.a * sx}px`;
+          div.style.height = `${hitArea.height * wt.d * sy}px`;
+        } else {
+          hitArea = child.getBounds().rectangle;
+          this._capHitArea(hitArea);
+          div.style.left = `${hitArea.x * sx}px`;
+          div.style.top = `${hitArea.y * sy}px`;
+          div.style.width = `${hitArea.width * sx}px`;
+          div.style.height = `${hitArea.height * sy}px`;
+          if (div.title !== child.accessibleTitle && child.accessibleTitle !== null) {
+            div.title = child.accessibleTitle || "";
+          }
+          if (div.getAttribute("aria-label") !== child.accessibleHint && child.accessibleHint !== null) {
+            div.setAttribute("aria-label", child.accessibleHint || "");
+          }
+        }
+        if (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex) {
+          div.title = child.accessibleTitle || "";
+          div.tabIndex = child.tabIndex;
+          if (this.debug) {
+            this._updateDebugHTML(div);
+          }
+        }
+      }
+    }
+    this._renderId++;
+  }
+  /**
+   * private function that will visually add the information to the
+   * accessibility div
+   * @param {HTMLElement} div -
+   */
+  _updateDebugHTML(div) {
+    div.innerHTML = `type: ${div.type}</br> title : ${div.title}</br> tabIndex: ${div.tabIndex}`;
+  }
+  /**
+   * Adjust the hit area based on the bounds of a display object
+   * @param {Rectangle} hitArea - Bounds of the child
+   */
+  _capHitArea(hitArea) {
+    if (hitArea.x < 0) {
+      hitArea.width += hitArea.x;
+      hitArea.x = 0;
+    }
+    if (hitArea.y < 0) {
+      hitArea.height += hitArea.y;
+      hitArea.y = 0;
+    }
+    const { width: viewWidth, height: viewHeight } = this._renderer;
+    if (hitArea.x + hitArea.width > viewWidth) {
+      hitArea.width = viewWidth - hitArea.x;
+    }
+    if (hitArea.y + hitArea.height > viewHeight) {
+      hitArea.height = viewHeight - hitArea.y;
+    }
+  }
+  /**
+   * Adds a Container to the accessibility manager
+   * @private
+   * @param {Container} container - The child to make accessible.
+   */
+  _addChild(container) {
+    let div = this._pool.pop();
+    if (!div) {
+      div = document.createElement("button");
+      div.style.width = `${DIV_TOUCH_SIZE}px`;
+      div.style.height = `${DIV_TOUCH_SIZE}px`;
+      div.style.backgroundColor = this.debug ? "rgba(255,255,255,0.5)" : "transparent";
+      div.style.position = "absolute";
+      div.style.zIndex = DIV_TOUCH_ZINDEX.toString();
+      div.style.borderStyle = "none";
+      if (navigator.userAgent.toLowerCase().includes("chrome")) {
+        div.setAttribute("aria-live", "off");
+      } else {
+        div.setAttribute("aria-live", "polite");
+      }
+      if (navigator.userAgent.match(/rv:.*Gecko\//)) {
+        div.setAttribute("aria-relevant", "additions");
+      } else {
+        div.setAttribute("aria-relevant", "text");
+      }
+      div.addEventListener("click", this._onClick.bind(this));
+      div.addEventListener("focus", this._onFocus.bind(this));
+      div.addEventListener("focusout", this._onFocusOut.bind(this));
+    }
+    div.style.pointerEvents = container.accessiblePointerEvents;
+    div.type = container.accessibleType;
+    if (container.accessibleTitle && container.accessibleTitle !== null) {
+      div.title = container.accessibleTitle;
+    } else if (!container.accessibleHint || container.accessibleHint === null) {
+      div.title = `container ${container.tabIndex}`;
+    }
+    if (container.accessibleHint && container.accessibleHint !== null) {
+      div.setAttribute("aria-label", container.accessibleHint);
+    }
+    if (this.debug) {
+      this._updateDebugHTML(div);
+    }
+    container._accessibleActive = true;
+    container._accessibleDiv = div;
+    div.container = container;
+    this._children.push(container);
+    this._div.appendChild(container._accessibleDiv);
+    container._accessibleDiv.tabIndex = container.tabIndex;
+  }
+  /**
+   * Dispatch events with the EventSystem.
+   * @param e
+   * @param type
+   * @private
+   */
+  _dispatchEvent(e, type) {
+    const { container: target } = e.target;
+    const boundary = this._renderer.events.rootBoundary;
+    const event = Object.assign(new FederatedEvent.FederatedEvent(boundary), { target });
+    boundary.rootTarget = this._renderer.lastObjectRendered;
+    type.forEach((type2) => boundary.dispatchEvent(event, type2));
+  }
+  /**
+   * Maps the div button press to pixi's EventSystem (click)
+   * @private
+   * @param {MouseEvent} e - The click event.
+   */
+  _onClick(e) {
+    this._dispatchEvent(e, ["click", "pointertap", "tap"]);
+  }
+  /**
+   * Maps the div focus events to pixi's EventSystem (mouseover)
+   * @private
+   * @param {FocusEvent} e - The focus event.
+   */
+  _onFocus(e) {
+    if (!e.target.getAttribute("aria-live")) {
+      e.target.setAttribute("aria-live", "assertive");
+    }
+    this._dispatchEvent(e, ["mouseover"]);
+  }
+  /**
+   * Maps the div focus events to pixi's EventSystem (mouseout)
+   * @private
+   * @param {FocusEvent} e - The focusout event.
+   */
+  _onFocusOut(e) {
+    if (!e.target.getAttribute("aria-live")) {
+      e.target.setAttribute("aria-live", "polite");
+    }
+    this._dispatchEvent(e, ["mouseout"]);
+  }
+  /**
+   * Is called when a key is pressed
+   * @private
+   * @param {KeyboardEvent} e - The keydown event.
+   */
+  _onKeyDown(e) {
+    if (e.keyCode !== KEY_CODE_TAB) {
+      return;
+    }
+    this._activate();
+  }
+  /**
+   * Is called when the mouse moves across the renderer element
+   * @private
+   * @param {MouseEvent} e - The mouse event.
+   */
+  _onMouseMove(e) {
+    if (e.movementX === 0 && e.movementY === 0) {
+      return;
+    }
+    this._deactivate();
+  }
+  /** Destroys the accessibility manager */
+  destroy() {
+    this._destroyTouchHook();
+    this._div = null;
+    globalThis.document.removeEventListener("mousemove", this._onMouseMove, true);
+    globalThis.removeEventListener("keydown", this._onKeyDown);
+    this._pool = null;
+    this._children = null;
+    this._renderer = null;
+  }
+}
+/** @ignore */
+AccessibilitySystem.extension = {
+  type: [
+    Extensions.ExtensionType.WebGLSystem,
+    Extensions.ExtensionType.WebGPUSystem
+  ],
+  name: "accessibility"
+};
+
+exports.AccessibilitySystem = AccessibilitySystem;
+//# sourceMappingURL=AccessibilitySystem.js.map

node_modules/pixi.js/lib/accessibility/AccessibilitySystem.mjs

@@ -0,0 +1,402 @@
+import { FederatedEvent } from '../events/FederatedEvent.mjs';
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { isMobile } from '../utils/browser/isMobile.mjs';
+import { removeItems } from '../utils/data/removeItems.mjs';
+
+"use strict";
+const KEY_CODE_TAB = 9;
+const DIV_TOUCH_SIZE = 100;
+const DIV_TOUCH_POS_X = 0;
+const DIV_TOUCH_POS_Y = 0;
+const DIV_TOUCH_ZINDEX = 2;
+const DIV_HOOK_SIZE = 1;
+const DIV_HOOK_POS_X = -1e3;
+const DIV_HOOK_POS_Y = -1e3;
+const DIV_HOOK_ZINDEX = 2;
+class AccessibilitySystem {
+  // 2fps
+  // eslint-disable-next-line jsdoc/require-param
+  /**
+   * @param {WebGLRenderer|WebGPURenderer} renderer - A reference to the current renderer
+   */
+  constructor(renderer, _mobileInfo = isMobile) {
+    this._mobileInfo = _mobileInfo;
+    /** Setting this to true will visually show the divs. */
+    this.debug = false;
+    /** Internal variable, see isActive getter. */
+    this._isActive = false;
+    /** Internal variable, see isMobileAccessibility getter. */
+    this._isMobileAccessibility = false;
+    /** A simple pool for storing divs. */
+    this._pool = [];
+    /** This is a tick used to check if an object is no longer being rendered. */
+    this._renderId = 0;
+    /** The array of currently active accessible items. */
+    this._children = [];
+    /** Count to throttle div updates on android devices. */
+    this._androidUpdateCount = 0;
+    /**  The frequency to update the div elements. */
+    this._androidUpdateFrequency = 500;
+    this._hookDiv = null;
+    if (_mobileInfo.tablet || _mobileInfo.phone) {
+      this._createTouchHook();
+    }
+    const div = document.createElement("div");
+    div.style.width = `${DIV_TOUCH_SIZE}px`;
+    div.style.height = `${DIV_TOUCH_SIZE}px`;
+    div.style.position = "absolute";
+    div.style.top = `${DIV_TOUCH_POS_X}px`;
+    div.style.left = `${DIV_TOUCH_POS_Y}px`;
+    div.style.zIndex = DIV_TOUCH_ZINDEX.toString();
+    this._div = div;
+    this._renderer = renderer;
+    this._onKeyDown = this._onKeyDown.bind(this);
+    this._onMouseMove = this._onMouseMove.bind(this);
+    globalThis.addEventListener("keydown", this._onKeyDown, false);
+  }
+  /**
+   * Value of `true` if accessibility is currently active and accessibility layers are showing.
+   * @member {boolean}
+   * @readonly
+   */
+  get isActive() {
+    return this._isActive;
+  }
+  /**
+   * Value of `true` if accessibility is enabled for touch devices.
+   * @member {boolean}
+   * @readonly
+   */
+  get isMobileAccessibility() {
+    return this._isMobileAccessibility;
+  }
+  get hookDiv() {
+    return this._hookDiv;
+  }
+  /**
+   * Creates the touch hooks.
+   * @private
+   */
+  _createTouchHook() {
+    const hookDiv = document.createElement("button");
+    hookDiv.style.width = `${DIV_HOOK_SIZE}px`;
+    hookDiv.style.height = `${DIV_HOOK_SIZE}px`;
+    hookDiv.style.position = "absolute";
+    hookDiv.style.top = `${DIV_HOOK_POS_X}px`;
+    hookDiv.style.left = `${DIV_HOOK_POS_Y}px`;
+    hookDiv.style.zIndex = DIV_HOOK_ZINDEX.toString();
+    hookDiv.style.backgroundColor = "#FF0000";
+    hookDiv.title = "select to enable accessibility for this content";
+    hookDiv.addEventListener("focus", () => {
+      this._isMobileAccessibility = true;
+      this._activate();
+      this._destroyTouchHook();
+    });
+    document.body.appendChild(hookDiv);
+    this._hookDiv = hookDiv;
+  }
+  /**
+   * Destroys the touch hooks.
+   * @private
+   */
+  _destroyTouchHook() {
+    if (!this._hookDiv) {
+      return;
+    }
+    document.body.removeChild(this._hookDiv);
+    this._hookDiv = null;
+  }
+  /**
+   * Activating will cause the Accessibility layer to be shown.
+   * This is called when a user presses the tab key.
+   * @private
+   */
+  _activate() {
+    if (this._isActive) {
+      return;
+    }
+    this._isActive = true;
+    globalThis.document.addEventListener("mousemove", this._onMouseMove, true);
+    globalThis.removeEventListener("keydown", this._onKeyDown, false);
+    this._renderer.runners.postrender.add(this);
+    this._renderer.view.canvas.parentNode?.appendChild(this._div);
+  }
+  /**
+   * Deactivating will cause the Accessibility layer to be hidden.
+   * This is called when a user moves the mouse.
+   * @private
+   */
+  _deactivate() {
+    if (!this._isActive || this._isMobileAccessibility) {
+      return;
+    }
+    this._isActive = false;
+    globalThis.document.removeEventListener("mousemove", this._onMouseMove, true);
+    globalThis.addEventListener("keydown", this._onKeyDown, false);
+    this._renderer.runners.postrender.remove(this);
+    this._div.parentNode?.removeChild(this._div);
+  }
+  /**
+   * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.
+   * @private
+   * @param {Container} container - The Container to check.
+   */
+  _updateAccessibleObjects(container) {
+    if (!container.visible || !container.accessibleChildren) {
+      return;
+    }
+    if (container.accessible && container.isInteractive()) {
+      if (!container._accessibleActive) {
+        this._addChild(container);
+      }
+      container._renderId = this._renderId;
+    }
+    const children = container.children;
+    if (children) {
+      for (let i = 0; i < children.length; i++) {
+        this._updateAccessibleObjects(children[i]);
+      }
+    }
+  }
+  /**
+   * Runner init called, view is available at this point.
+   * @ignore
+   */
+  init(options) {
+    this.debug = options?.debug ?? this.debug;
+    this._renderer.runners.postrender.remove(this);
+  }
+  /**
+   * Runner postrender was called, ensure that all divs are mapped correctly to their Containers.
+   * Only fires while active.
+   * @ignore
+   */
+  postrender() {
+    const now = performance.now();
+    if (this._mobileInfo.android.device && now < this._androidUpdateCount) {
+      return;
+    }
+    this._androidUpdateCount = now + this._androidUpdateFrequency;
+    if (!this._renderer.renderingToScreen || !this._renderer.view.canvas) {
+      return;
+    }
+    if (this._renderer.lastObjectRendered) {
+      this._updateAccessibleObjects(this._renderer.lastObjectRendered);
+    }
+    const { x, y, width, height } = this._renderer.view.canvas.getBoundingClientRect();
+    const { width: viewWidth, height: viewHeight, resolution } = this._renderer;
+    const sx = width / viewWidth * resolution;
+    const sy = height / viewHeight * resolution;
+    let div = this._div;
+    div.style.left = `${x}px`;
+    div.style.top = `${y}px`;
+    div.style.width = `${viewWidth}px`;
+    div.style.height = `${viewHeight}px`;
+    for (let i = 0; i < this._children.length; i++) {
+      const child = this._children[i];
+      if (child._renderId !== this._renderId) {
+        child._accessibleActive = false;
+        removeItems(this._children, i, 1);
+        this._div.removeChild(child._accessibleDiv);
+        this._pool.push(child._accessibleDiv);
+        child._accessibleDiv = null;
+        i--;
+      } else {
+        div = child._accessibleDiv;
+        let hitArea = child.hitArea;
+        const wt = child.worldTransform;
+        if (child.hitArea) {
+          div.style.left = `${(wt.tx + hitArea.x * wt.a) * sx}px`;
+          div.style.top = `${(wt.ty + hitArea.y * wt.d) * sy}px`;
+          div.style.width = `${hitArea.width * wt.a * sx}px`;
+          div.style.height = `${hitArea.height * wt.d * sy}px`;
+        } else {
+          hitArea = child.getBounds().rectangle;
+          this._capHitArea(hitArea);
+          div.style.left = `${hitArea.x * sx}px`;
+          div.style.top = `${hitArea.y * sy}px`;
+          div.style.width = `${hitArea.width * sx}px`;
+          div.style.height = `${hitArea.height * sy}px`;
+          if (div.title !== child.accessibleTitle && child.accessibleTitle !== null) {
+            div.title = child.accessibleTitle || "";
+          }
+          if (div.getAttribute("aria-label") !== child.accessibleHint && child.accessibleHint !== null) {
+            div.setAttribute("aria-label", child.accessibleHint || "");
+          }
+        }
+        if (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex) {
+          div.title = child.accessibleTitle || "";
+          div.tabIndex = child.tabIndex;
+          if (this.debug) {
+            this._updateDebugHTML(div);
+          }
+        }
+      }
+    }
+    this._renderId++;
+  }
+  /**
+   * private function that will visually add the information to the
+   * accessibility div
+   * @param {HTMLElement} div -
+   */
+  _updateDebugHTML(div) {
+    div.innerHTML = `type: ${div.type}</br> title : ${div.title}</br> tabIndex: ${div.tabIndex}`;
+  }
+  /**
+   * Adjust the hit area based on the bounds of a display object
+   * @param {Rectangle} hitArea - Bounds of the child
+   */
+  _capHitArea(hitArea) {
+    if (hitArea.x < 0) {
+      hitArea.width += hitArea.x;
+      hitArea.x = 0;
+    }
+    if (hitArea.y < 0) {
+      hitArea.height += hitArea.y;
+      hitArea.y = 0;
+    }
+    const { width: viewWidth, height: viewHeight } = this._renderer;
+    if (hitArea.x + hitArea.width > viewWidth) {
+      hitArea.width = viewWidth - hitArea.x;
+    }
+    if (hitArea.y + hitArea.height > viewHeight) {
+      hitArea.height = viewHeight - hitArea.y;
+    }
+  }
+  /**
+   * Adds a Container to the accessibility manager
+   * @private
+   * @param {Container} container - The child to make accessible.
+   */
+  _addChild(container) {
+    let div = this._pool.pop();
+    if (!div) {
+      div = document.createElement("button");
+      div.style.width = `${DIV_TOUCH_SIZE}px`;
+      div.style.height = `${DIV_TOUCH_SIZE}px`;
+      div.style.backgroundColor = this.debug ? "rgba(255,255,255,0.5)" : "transparent";
+      div.style.position = "absolute";
+      div.style.zIndex = DIV_TOUCH_ZINDEX.toString();
+      div.style.borderStyle = "none";
+      if (navigator.userAgent.toLowerCase().includes("chrome")) {
+        div.setAttribute("aria-live", "off");
+      } else {
+        div.setAttribute("aria-live", "polite");
+      }
+      if (navigator.userAgent.match(/rv:.*Gecko\//)) {
+        div.setAttribute("aria-relevant", "additions");
+      } else {
+        div.setAttribute("aria-relevant", "text");
+      }
+      div.addEventListener("click", this._onClick.bind(this));
+      div.addEventListener("focus", this._onFocus.bind(this));
+      div.addEventListener("focusout", this._onFocusOut.bind(this));
+    }
+    div.style.pointerEvents = container.accessiblePointerEvents;
+    div.type = container.accessibleType;
+    if (container.accessibleTitle && container.accessibleTitle !== null) {
+      div.title = container.accessibleTitle;
+    } else if (!container.accessibleHint || container.accessibleHint === null) {
+      div.title = `container ${container.tabIndex}`;
+    }
+    if (container.accessibleHint && container.accessibleHint !== null) {
+      div.setAttribute("aria-label", container.accessibleHint);
+    }
+    if (this.debug) {
+      this._updateDebugHTML(div);
+    }
+    container._accessibleActive = true;
+    container._accessibleDiv = div;
+    div.container = container;
+    this._children.push(container);
+    this._div.appendChild(container._accessibleDiv);
+    container._accessibleDiv.tabIndex = container.tabIndex;
+  }
+  /**
+   * Dispatch events with the EventSystem.
+   * @param e
+   * @param type
+   * @private
+   */
+  _dispatchEvent(e, type) {
+    const { container: target } = e.target;
+    const boundary = this._renderer.events.rootBoundary;
+    const event = Object.assign(new FederatedEvent(boundary), { target });
+    boundary.rootTarget = this._renderer.lastObjectRendered;
+    type.forEach((type2) => boundary.dispatchEvent(event, type2));
+  }
+  /**
+   * Maps the div button press to pixi's EventSystem (click)
+   * @private
+   * @param {MouseEvent} e - The click event.
+   */
+  _onClick(e) {
+    this._dispatchEvent(e, ["click", "pointertap", "tap"]);
+  }
+  /**
+   * Maps the div focus events to pixi's EventSystem (mouseover)
+   * @private
+   * @param {FocusEvent} e - The focus event.
+   */
+  _onFocus(e) {
+    if (!e.target.getAttribute("aria-live")) {
+      e.target.setAttribute("aria-live", "assertive");
+    }
+    this._dispatchEvent(e, ["mouseover"]);
+  }
+  /**
+   * Maps the div focus events to pixi's EventSystem (mouseout)
+   * @private
+   * @param {FocusEvent} e - The focusout event.
+   */
+  _onFocusOut(e) {
+    if (!e.target.getAttribute("aria-live")) {
+      e.target.setAttribute("aria-live", "polite");
+    }
+    this._dispatchEvent(e, ["mouseout"]);
+  }
+  /**
+   * Is called when a key is pressed
+   * @private
+   * @param {KeyboardEvent} e - The keydown event.
+   */
+  _onKeyDown(e) {
+    if (e.keyCode !== KEY_CODE_TAB) {
+      return;
+    }
+    this._activate();
+  }
+  /**
+   * Is called when the mouse moves across the renderer element
+   * @private
+   * @param {MouseEvent} e - The mouse event.
+   */
+  _onMouseMove(e) {
+    if (e.movementX === 0 && e.movementY === 0) {
+      return;
+    }
+    this._deactivate();
+  }
+  /** Destroys the accessibility manager */
+  destroy() {
+    this._destroyTouchHook();
+    this._div = null;
+    globalThis.document.removeEventListener("mousemove", this._onMouseMove, true);
+    globalThis.removeEventListener("keydown", this._onKeyDown);
+    this._pool = null;
+    this._children = null;
+    this._renderer = null;
+  }
+}
+/** @ignore */
+AccessibilitySystem.extension = {
+  type: [
+    ExtensionType.WebGLSystem,
+    ExtensionType.WebGPUSystem
+  ],
+  name: "accessibility"
+};
+
+export { AccessibilitySystem };
+//# sourceMappingURL=AccessibilitySystem.mjs.map

node_modules/pixi.js/lib/accessibility/accessibilityTarget.d.ts

@@ -0,0 +1,86 @@
+import type { Container } from '../scene/container/Container';
+/**
+ * The type of the pointer event to listen for.
+ * Can be any of the following:
+ * - `auto`
+ * - `none`
+ * - `visiblePainted`
+ * - `visibleFill`
+ * - `visibleStroke`
+ * - `visible`
+ * - `painted`
+ * - `fill`
+ * - `stroke`
+ * - `all`
+ * - `inherit`
+ * @memberof accessibility
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/pointer-events
+ */
+export type PointerEvents = 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all' | 'inherit';
+/**
+ * When `accessible` is enabled on any display object, these properties will affect its accessibility.
+ * @memberof accessibility
+ */
+export interface AccessibleOptions {
+    /**
+     * Flag for if the object is accessible. If true AccessibilityManager will overlay a
+     * shadow div with attributes set
+     * @default false
+     */
+    accessible: boolean;
+    /**
+     * Sets the title attribute of the shadow div
+     * If accessibleTitle AND accessibleHint has not been this will default to 'container [tabIndex]'
+     * @member {string}
+     */
+    accessibleTitle: string | null;
+    /** Sets the aria-label attribute of the shadow div */
+    accessibleHint: string | null;
+    /**
+     * @default 0
+     */
+    tabIndex: number;
+    /**
+     * Specify the type of div the accessible layer is. Screen readers treat the element differently
+     * depending on this type. Defaults to button.
+     * @default 'button'
+     */
+    accessibleType: string;
+    /**
+     * Specify the pointer-events the accessible div will use
+     * Defaults to auto.
+     * @default 'auto'
+     * @type {accessibility.PointerEvents}
+     */
+    accessiblePointerEvents: PointerEvents;
+    /**
+     * Setting to false will prevent any children inside this container to
+     * be accessible. Defaults to true.
+     * @default true
+     */
+    accessibleChildren: boolean;
+}
+/**
+ * The Accessibility object is attached to the {@link Container}.
+ * @private
+ */
+export interface AccessibleTarget extends AccessibleOptions {
+    _accessibleActive: boolean;
+    _accessibleDiv: AccessibleHTMLElement | null;
+    _renderId: number;
+}
+export interface AccessibleHTMLElement extends HTMLElement {
+    type?: string;
+    container?: Container;
+}
+/**
+ * Default property values of accessible objects
+ * used by {@link AccessibilitySystem}.
+ * @private
+ * @example
+ * import { accessibleTarget } from 'pixi.js';
+ *
+ * function MyObject() {}
+ * Object.assign(MyObject.prototype, accessibleTarget);
+ */
+export declare const accessibilityTarget: AccessibleTarget;

node_modules/pixi.js/lib/accessibility/accessibilityTarget.js

@@ -0,0 +1,75 @@
+'use strict';
+
+"use strict";
+const accessibilityTarget = {
+  /**
+   * Flag for if the object is accessible. If true AccessibilityManager will overlay a
+   * shadow div with attributes set
+   * @member {boolean}
+   * @memberof scene.Container#
+   */
+  accessible: false,
+  /**
+   * Sets the title attribute of the shadow div
+   * If accessibleTitle AND accessibleHint has not been this will default to 'container [tabIndex]'
+   * @member {string}
+   * @memberof scene.Container#
+   */
+  accessibleTitle: null,
+  /**
+   * Sets the aria-label attribute of the shadow div
+   * @member {string}
+   * @memberof scene.Container#
+   */
+  accessibleHint: null,
+  /**
+   * @member {number}
+   * @memberof scene.Container#
+   * @todo Needs docs.
+   */
+  tabIndex: 0,
+  /**
+   * @member {boolean}
+   * @memberof scene.Container#
+   * @private
+   */
+  _accessibleActive: false,
+  /**
+   * @memberof scene.Container#
+   * @private
+   */
+  _accessibleDiv: null,
+  /**
+   * Specify the type of div the accessible layer is. Screen readers treat the element differently
+   * depending on this type. Defaults to button.
+   * @member {string}
+   * @memberof scene.Container#
+   * @default 'button'
+   */
+  accessibleType: "button",
+  /**
+   * Specify the pointer-events the accessible div will use
+   * Defaults to auto.
+   * @type {PointerEvents}
+   * @memberof scene.Container#
+   * @default 'auto'
+   */
+  accessiblePointerEvents: "auto",
+  /**
+   * Setting to false will prevent any children inside this container to
+   * be accessible. Defaults to true.
+   * @member {boolean}
+   * @memberof scene.Container#
+   * @default true
+   */
+  accessibleChildren: true,
+  /**
+   * @member {number}
+   * @memberof scene.Container#
+   * @private
+   */
+  _renderId: -1
+};
+
+exports.accessibilityTarget = accessibilityTarget;
+//# sourceMappingURL=accessibilityTarget.js.map

node_modules/pixi.js/lib/accessibility/accessibilityTarget.mjs

@@ -0,0 +1,73 @@
+"use strict";
+const accessibilityTarget = {
+  /**
+   * Flag for if the object is accessible. If true AccessibilityManager will overlay a
+   * shadow div with attributes set
+   * @member {boolean}
+   * @memberof scene.Container#
+   */
+  accessible: false,
+  /**
+   * Sets the title attribute of the shadow div
+   * If accessibleTitle AND accessibleHint has not been this will default to 'container [tabIndex]'
+   * @member {string}
+   * @memberof scene.Container#
+   */
+  accessibleTitle: null,
+  /**
+   * Sets the aria-label attribute of the shadow div
+   * @member {string}
+   * @memberof scene.Container#
+   */
+  accessibleHint: null,
+  /**
+   * @member {number}
+   * @memberof scene.Container#
+   * @todo Needs docs.
+   */
+  tabIndex: 0,
+  /**
+   * @member {boolean}
+   * @memberof scene.Container#
+   * @private
+   */
+  _accessibleActive: false,
+  /**
+   * @memberof scene.Container#
+   * @private
+   */
+  _accessibleDiv: null,
+  /**
+   * Specify the type of div the accessible layer is. Screen readers treat the element differently
+   * depending on this type. Defaults to button.
+   * @member {string}
+   * @memberof scene.Container#
+   * @default 'button'
+   */
+  accessibleType: "button",
+  /**
+   * Specify the pointer-events the accessible div will use
+   * Defaults to auto.
+   * @type {PointerEvents}
+   * @memberof scene.Container#
+   * @default 'auto'
+   */
+  accessiblePointerEvents: "auto",
+  /**
+   * Setting to false will prevent any children inside this container to
+   * be accessible. Defaults to true.
+   * @member {boolean}
+   * @memberof scene.Container#
+   * @default true
+   */
+  accessibleChildren: true,
+  /**
+   * @member {number}
+   * @memberof scene.Container#
+   * @private
+   */
+  _renderId: -1
+};
+
+export { accessibilityTarget };
+//# sourceMappingURL=accessibilityTarget.mjs.map

node_modules/pixi.js/lib/accessibility/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AccessibilitySystem';
+export * from './accessibilityTarget';

node_modules/pixi.js/lib/accessibility/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var AccessibilitySystem = require('./AccessibilitySystem.js');
+var accessibilityTarget = require('./accessibilityTarget.js');
+
+"use strict";
+
+exports.AccessibilitySystem = AccessibilitySystem.AccessibilitySystem;
+exports.accessibilityTarget = accessibilityTarget.accessibilityTarget;
+//# sourceMappingURL=index.js.map

node_modules/pixi.js/lib/accessibility/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

node_modules/pixi.js/lib/accessibility/index.mjs

@@ -0,0 +1,5 @@
+export { AccessibilitySystem } from './AccessibilitySystem.mjs';
+export { accessibilityTarget } from './accessibilityTarget.mjs';
+
+"use strict";
+//# sourceMappingURL=index.mjs.map

node_modules/pixi.js/lib/accessibility/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

node_modules/pixi.js/lib/accessibility/init.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/pixi.js/lib/accessibility/init.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var Container = require('../scene/container/Container.js');
+var AccessibilitySystem = require('./AccessibilitySystem.js');
+var accessibilityTarget = require('./accessibilityTarget.js');
+
+"use strict";
+Extensions.extensions.add(AccessibilitySystem.AccessibilitySystem);
+Container.Container.mixin(accessibilityTarget.accessibilityTarget);
+//# sourceMappingURL=init.js.map

node_modules/pixi.js/lib/accessibility/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sources":["../../src/accessibility/init.ts"],"sourcesContent":["import { extensions } from '../extensions/Extensions';\nimport { Container } from '../scene/container/Container';\nimport { AccessibilitySystem } from './AccessibilitySystem';\nimport { accessibilityTarget } from './accessibilityTarget';\n\nextensions.add(AccessibilitySystem);\nContainer.mixin(accessibilityTarget);\n"],"names":["extensions","AccessibilitySystem","Container","accessibilityTarget"],"mappings":";;;;;;;;AAKAA,qBAAA,CAAW,IAAIC,uCAAmB,CAAA,CAAA;AAClCC,mBAAA,CAAU,MAAMC,uCAAmB,CAAA;;"}

node_modules/pixi.js/lib/accessibility/init.mjs

@@ -0,0 +1,9 @@
+import { extensions } from '../extensions/Extensions.mjs';
+import { Container } from '../scene/container/Container.mjs';
+import { AccessibilitySystem } from './AccessibilitySystem.mjs';
+import { accessibilityTarget } from './accessibilityTarget.mjs';
+
+"use strict";
+extensions.add(AccessibilitySystem);
+Container.mixin(accessibilityTarget);
+//# sourceMappingURL=init.mjs.map

node_modules/pixi.js/lib/accessibility/init.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.mjs","sources":["../../src/accessibility/init.ts"],"sourcesContent":["import { extensions } from '../extensions/Extensions';\nimport { Container } from '../scene/container/Container';\nimport { AccessibilitySystem } from './AccessibilitySystem';\nimport { accessibilityTarget } from './accessibilityTarget';\n\nextensions.add(AccessibilitySystem);\nContainer.mixin(accessibilityTarget);\n"],"names":[],"mappings":";;;;;;AAKA,UAAA,CAAW,IAAI,mBAAmB,CAAA,CAAA;AAClC,SAAA,CAAU,MAAM,mBAAmB,CAAA"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color'
+ * @memberof filters
+ */
+export declare class ColorBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+var GLhls = require('../filters/blend-modes/hls/GLhls.js');
+var GPUhls = require('../filters/blend-modes/hls/GPUhls.js');
+
+"use strict";
+class ColorBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${GLhls.hslgl}
+
+                vec3 blendColor(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${GPUhls.hslgpu}
+
+                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBlend.extension = {
+  name: "color",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorBlend = ColorBlend;
+//# sourceMappingURL=ColorBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBlend.js","sources":["../../src/advanced-blend-modes/ColorBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color'\n * @memberof filters\n */\nexport class ColorBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendColor(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","hslgl","hslgpu","ExtensionType"],"mappings":";;;;;;;;AAiBO,MAAM,mBAAmBA,+BAChC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,WAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,aAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOR,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvCa,UAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,OAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.mjs

@@ -0,0 +1,46 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+import { hslgl } from '../filters/blend-modes/hls/GLhls.mjs';
+import { hslgpu } from '../filters/blend-modes/hls/GPUhls.mjs';
+
+"use strict";
+class ColorBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${hslgl}
+
+                vec3 blendColor(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${hslgpu}
+
+                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBlend.extension = {
+  name: "color",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorBlend };
+//# sourceMappingURL=ColorBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBlend.mjs","sources":["../../src/advanced-blend-modes/ColorBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color'\n * @memberof filters\n */\nexport class ColorBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendColor(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,mBAAmB,eAChC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,KAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,MAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOR,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvCa,UAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,OAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.d.ts

@@ -0,0 +1,20 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and darkens the base color to
+ * reflect the blend color by increasing the contrast between the two.
+ *
+ * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color-burn'
+ * @memberof filters
+ */
+export declare class ColorBurnBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class ColorBurnBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0 - ((1.0 - base) / blend)), 0.0);
+                }
+
+                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBurnBlend.extension = {
+  name: "color-burn",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorBurnBlend = ColorBurnBlend;
+//# sourceMappingURL=ColorBurnBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBurnBlend.js","sources":["../../src/advanced-blend-modes/ColorBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-burn'\n * @memberof filters\n */\nexport class ColorBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorBurn(float base, float blend)\n                {\n                    return max((1.0 - ((1.0 - base) / blend)), 0.0);\n                }\n\n                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn colorBurn(base:f32, blend:f32) -> f32\n                {\n                    return max((1.0-((1.0-base)/blend)),0.0);\n                }\n\n                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAoBO,MAAM,uBAAuBA,+BACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class ColorBurnBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0 - ((1.0 - base) / blend)), 0.0);
+                }
+
+                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBurnBlend.extension = {
+  name: "color-burn",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorBurnBlend };
+//# sourceMappingURL=ColorBurnBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBurnBlend.mjs","sources":["../../src/advanced-blend-modes/ColorBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-burn'\n * @memberof filters\n */\nexport class ColorBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorBurn(float base, float blend)\n                {\n                    return max((1.0 - ((1.0 - base) / blend)), 0.0);\n                }\n\n                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn colorBurn(base:f32, blend:f32) -> f32\n                {\n                    return max((1.0-((1.0-base)/blend)),0.0);\n                }\n\n                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAoBO,MAAM,uBAAuB,eACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.
+ * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color-dodge'
+ * @memberof filters
+ */
+export declare class ColorDodgeBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class ColorDodgeBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorDodge(float base, float blend)
+                {
+                    return base / (1.0 - blend);
+                }
+
+                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return base / (1.0 - blend);
+                }
+
+                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorDodgeBlend.extension = {
+  name: "color-dodge",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorDodgeBlend = ColorDodgeBlend;
+//# sourceMappingURL=ColorDodgeBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorDodgeBlend.js","sources":["../../src/advanced-blend-modes/ColorDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-dodge'\n * @memberof filters\n */\nexport class ColorDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorDodge(float base, float blend)\n                {\n                    return base / (1.0 - blend);\n                }\n\n                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn colorDodge(base: f32, blend: f32) -> f32\n                {\n                    return base / (1.0 - blend);\n                }\n\n                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class ColorDodgeBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorDodge(float base, float blend)
+                {
+                    return base / (1.0 - blend);
+                }
+
+                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return base / (1.0 - blend);
+                }
+
+                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorDodgeBlend.extension = {
+  name: "color-dodge",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorDodgeBlend };
+//# sourceMappingURL=ColorDodgeBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorDodgeBlend.mjs","sources":["../../src/advanced-blend-modes/ColorDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-dodge'\n * @memberof filters\n */\nexport class ColorDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorDodge(float base, float blend)\n                {\n                    return base / (1.0 - blend);\n                }\n\n                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn colorDodge(base: f32, blend: f32) -> f32\n                {\n                    return base / (1.0 - blend);\n                }\n\n                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Uses each color channel to select the darker of the following two values; base or blend color
+ * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'darken'
+ * @memberof filters
+ */
+export declare class DarkenBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DarkenBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDarken(vec3 base, vec3 blend, float opacity)
+                {
+                    return (min(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (min(blend,base) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+DarkenBlend.extension = {
+  name: "darken",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DarkenBlend = DarkenBlend;
+//# sourceMappingURL=DarkenBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DarkenBlend.js","sources":["../../src/advanced-blend-modes/DarkenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Uses each color channel to select the darker of the following two values; base or blend color\n * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'darken'\n * @memberof filters\n */\nexport class DarkenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'darken',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDarken(vec3 base, vec3 blend, float opacity)\n                {\n                    return (min(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (min(blend,base) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAgBO,MAAM,oBAAoBA,+BACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.mjs

@@ -0,0 +1,40 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DarkenBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDarken(vec3 base, vec3 blend, float opacity)
+                {
+                    return (min(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (min(blend,base) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+DarkenBlend.extension = {
+  name: "darken",
+  type: ExtensionType.BlendMode
+};
+
+export { DarkenBlend };
+//# sourceMappingURL=DarkenBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DarkenBlend.mjs","sources":["../../src/advanced-blend-modes/DarkenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Uses each color channel to select the darker of the following two values; base or blend color\n * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'darken'\n * @memberof filters\n */\nexport class DarkenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'darken',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDarken(vec3 base, vec3 blend, float opacity)\n                {\n                    return (min(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (min(blend,base) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAgBO,MAAM,oBAAoB,eACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'difference'
+ * @memberof filters
+ */
+export declare class DifferenceBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DifferenceBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DifferenceBlend.extension = {
+  name: "difference",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DifferenceBlend = DifferenceBlend;
+//# sourceMappingURL=DifferenceBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DifferenceBlend.js","sources":["../../src/advanced-blend-modes/DifferenceBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'difference'\n * @memberof filters\n */\nexport class DifferenceBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'difference',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAeO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.mjs

@@ -0,0 +1,40 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DifferenceBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DifferenceBlend.extension = {
+  name: "difference",
+  type: ExtensionType.BlendMode
+};
+
+export { DifferenceBlend };
+//# sourceMappingURL=DifferenceBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DifferenceBlend.mjs","sources":["../../src/advanced-blend-modes/DifferenceBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'difference'\n * @memberof filters\n */\nexport class DifferenceBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'difference',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAeO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Divides the blend from the base color using each color channel
+ * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'divide'
+ * @memberof filters
+ */
+export declare class DivideBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DivideBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float divide(float base, float blend)
+                {
+                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;
+                }
+
+                vec3 blendDivide(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn divide(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);
+                }
+
+                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DivideBlend.extension = {
+  name: "divide",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DivideBlend = DivideBlend;
+//# sourceMappingURL=DivideBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DivideBlend.js","sources":["../../src/advanced-blend-modes/DivideBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Divides the blend from the base color using each color channel\n * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'divide'\n * @memberof filters\n */\nexport class DivideBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'divide',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float divide(float base, float blend)\n                {\n                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;\n                }\n\n                vec3 blendDivide(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn divide(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);\n                }\n\n                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,oBAAoBA,+BACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.mjs

@@ -0,0 +1,61 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DivideBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float divide(float base, float blend)
+                {
+                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;
+                }
+
+                vec3 blendDivide(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn divide(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);
+                }
+
+                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DivideBlend.extension = {
+  name: "divide",
+  type: ExtensionType.BlendMode
+};
+
+export { DivideBlend };
+//# sourceMappingURL=DivideBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DivideBlend.mjs","sources":["../../src/advanced-blend-modes/DivideBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Divides the blend from the base color using each color channel\n * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'divide'\n * @memberof filters\n */\nexport class DivideBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'divide',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float divide(float base, float blend)\n                {\n                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;\n                }\n\n                vec3 blendDivide(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn divide(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);\n                }\n\n                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,oBAAoB,eACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'exclusion'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'exclusion'
+ * @memberof filters
+ */
+export declare class ExclusionBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}